public void SetUp()
{
Container.Reset();
_lst = new List<Segment>();
Container.Register<ISplitter, Splitter>();
_sut = Container.Resolve<ISplitter>();
}
public void TestServerBasics()
{
m_noAdmitCount = 0;
m_admitCount = 0;
m_model = new Model();
((Model)m_model).RandomServer = new Randoms.RandomServer(54321, 100);
ItemSource patientFactory = CreatePatientGenerator("Patient_", 500, 5.0, 3.0);
IServer receiving = CreateProcessStep("Receiving", 3.0, 5.0, 8.0);
ISplitter evaluation = CreateBranch("Evaluation", 0.20);
IServer admit = CreateProcessStep("Admit", 3.0, 5.0, 9.0);
IServer inPatientTreat = CreateProcessStep("InPatientTreat", 300.0, 2160.0, 7200.0);
IServer discharge = CreateProcessStep("Discharge", 3.0, 5.0, 8.0);
IServer outPatientTreat = CreateProcessStep("OutPatientTreat", 300.0, 2160.0, 7200.0);
IJoiner toStreet = new PushJoiner(m_model, "Push Joiner", Guid.NewGuid(), 2);
ItemSink street = new ItemSink(m_model, "Street", Guid.NewGuid());
ConnectorFactory.Connect(patientFactory.Output, receiving.Input);
ConnectorFactory.Connect(receiving.Output, evaluation.Input);
ConnectorFactory.Connect(evaluation.Outputs[0], admit.Input);
ConnectorFactory.Connect(admit.Output, inPatientTreat.Input);
ConnectorFactory.Connect(inPatientTreat.Output, discharge.Input);
ConnectorFactory.Connect(discharge.Output, toStreet.Inputs[0]);
ConnectorFactory.Connect(evaluation.Outputs[1], outPatientTreat.Input);
ConnectorFactory.Connect(outPatientTreat.Output, toStreet.Inputs[1]);
ConnectorFactory.Connect(toStreet.Output, street.Input);
evaluation.Outputs[0].PortDataPresented += new PortDataEvent(Admit_Patient); // Count admitted.
evaluation.Outputs[1].PortDataPresented += new PortDataEvent(NoAdmit_Patient); // Count not-admitted.
inPatientTreat.ServiceBeginning += new ServiceEvent(Server_ServiceBeginning);
inPatientTreat.ServiceCompleted += new ServiceEvent(Server_ServiceCompleted);
outPatientTreat.ServiceBeginning += new ServiceEvent(Server_ServiceBeginning);
outPatientTreat.ServiceCompleted += new ServiceEvent(Server_ServiceCompleted);
m_model.Start();
Console.WriteLine("NoAdmit = " + m_noAdmitCount + ", and admitted = " + m_admitCount);
}
private async Task FileSplit()
{
var fileSplitInfo = _argumentParser.BuildFileSplitInfo();
Console.WriteLine($"{fileSplitInfo}{Environment.NewLine}" +
$"Splitting file...");
if (fileSplitInfo.NumberOfChunks > 0)
{
_fileSplitter = new NumberOfChunksSplitter(_config);
}
else if (fileSplitInfo.ChunkSize > 0)
{
_fileSplitter = new SizeOfChunksSplitter(_config);
}
_fileSplitter.FileSplittingInfo = fileSplitInfo;
await _fileSplitter.Split();
Console.WriteLine($"Created files:{Environment.NewLine}" +
$"{string.Join(Environment.NewLine, _fileSplitter.CreatedFiles)}");
}
public int Grow(ForestGrowParameters growParameters)
{
if (growParameters == null)
{
throw new Exception();
}
int qty = 0;
switch (growParameters.SplitMode)
{
case SplitMode.GINI:
_splitter = new SplitterGini();
break;
case SplitMode.RSS:
_splitter = new SplitterRss();
break;
default:
_splitter = new SplitterRss();
break;
}
InitializeItemSet(growParameters.TrainingDataPath);
qty = GenerateTreesTPL(
growParameters.TreeCount,
growParameters.ResolutionFeatureName,
growParameters.MaxItemCountInCategory,
growParameters.ItemSubsetCountRatio);
if (growParameters.ExportToJson)
{
ExportToJsonTPL(growParameters.ExportDirectoryPath);
}
return(qty);
}
public OCRReader(ISplitter splitter)
{
Splitter = splitter;
}
public IEnumerable <PeriodStatistic> GetStatisticsPerPeriod <T>(IEnumerable <T> collection, ISplitter splitter) where T : ISplittable
{
var splitted = splitter.Split(collection);
foreach (var singlePeriod in splitted)
{
yield return(new PeriodStatistic(singlePeriod.Key, singlePeriod.Value.Count()));
}
}
public TupleParser(string separator)
{
splitter = new StringSplitter(separator);
}
public SplittingTableMapper(ISplitter splitter,
Func <string, ITableMapper> factory)
{
Splitter = splitter;
TableMappers = splitter.Names.Select(factory).ToArray();
}
private CaseFormat(ISplitter splitter)
{
_splitter = splitter ?? throw new ArgumentNullException(nameof(splitter));
_humanizerMode = false;
}
public EvalutationContext(IModel model, ISplitter <T> splitter)
{
Model = model;
Splitter = splitter;
_items = new Dictionary <string, object>();
}
public static IRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData, IRandom random, ILeafModel leafModel = null, ISplitter splitter = null, IPruning pruning = null,
bool useHoldout = false, double holdoutSize = 0.2, int minimumLeafSize = 1, bool generateRules = false, ResultCollection results = null, CancellationToken?cancellationToken = null)
{
if (leafModel == null)
{
leafModel = new LinearLeaf();
}
if (splitter == null)
{
splitter = new Splitter();
}
if (cancellationToken == null)
{
cancellationToken = CancellationToken.None;
}
if (pruning == null)
{
pruning = new ComplexityPruning();
}
var stateScope = InitializeScope(random, problemData, pruning, minimumLeafSize, leafModel, splitter, generateRules, useHoldout, holdoutSize);
var model = Build(stateScope, results, cancellationToken.Value);
return(model.CreateRegressionSolution(problemData));
}
public static void LearnFromFile(this ChainDictionary dictionary, string filepath, ISplitter splitter)
{
dictionary.LearnFrom(File.ReadLines(filepath), splitter);
}
/// <summary>
/// 処理を実行する
/// </summary>
protected override IEnumerator <float> ExecuteInternal(TileDataMap prevTildeDataMap)
{
_splitter = _splitFactory.Create();
MapRect = new MapRectData();
// 全体を一つの区画にする
// Width&Heightが20の場合
// (0, 0, 20, 20)になる。
// 区画が (0, 0, 10, 20), (10, 0, 20, 20)
// となった場合、引き算するだけで
// 10 - 0 = 10
// 20 - 10 = 10
// とマスの幅が求まり
// for (int x = 0; x < w; ++x)
// とすると区画のループ処理がかける
var extra = 3;
MapRect.CreateRect(0 + extra, 0 + extra, Width - extra, Height - extra);
// 区画を作る
var splitEnumerator = _splitter?.SplitRect(_data, MapRect);
while (splitEnumerator.MoveNext())
{
yield return(splitEnumerator.Current);
}
// 部屋を作る
var roomEnumerator = CreateRoom();
while (roomEnumerator.MoveNext())
{
yield return(roomEnumerator.Current);
}
// 道を作る
_roadBuilder = _roadFactory.Create(SplitConst.RoadBuilderType.Simple);
var roadEnumerator = _roadBuilder.Build(TileDataMap, MapRect);
while (roadEnumerator.MoveNext())
{
yield return(roadEnumerator.Current);
}
// 前マップの下階段の位置に部屋を作成する
// 下り階段の場所が部屋なら何もしない
if (prevTildeDataMap != null)
{
var prevRoomEnumerator = CreateEntrance(prevTildeDataMap);
while (prevRoomEnumerator.MoveNext())
{
yield return(prevRoomEnumerator.Current);
}
}
else
{
// マップだけ作成しておく
TileDataMap.BuildRoomMap();
}
// 部屋に対して道が重なっていた場合、その道を取り除く
RemoveExtraRoad();
// 下階段を作る
var pos = GetRandomRoomCellPos();
TileDataMap.SetStepDownFlag(pos.x, pos.y);
}
static public int Split <T>(string inString, ISplitter inSplitter, StringSplitOptions inSplitOptions, ref T outSlices) where T : ITempList <StringSlice>
{
return(Split(inString, 0, inString.Length, inSplitter, inSplitOptions, ref outSlices));
}
static public IEnumerable <StringSlice> EnumeratedSplit(string inString, ISplitter inSplitter, StringSplitOptions inSplitOptions)
{
return(EnumerableSplit(inString, 0, inString.Length, inSplitter, inSplitOptions));
}
static public int Split(string inString, ISplitter inSplitter, StringSplitOptions inSplitOptions, IList <StringSlice> outSlices)
{
return(Split(inString, 0, inString.Length, inSplitter, inSplitOptions, outSlices));
}
static public StringSlice[] Split(string inString, ISplitter inSplitter, StringSplitOptions inSplitOptions)
{
return(Split(inString, 0, inString.Length, inSplitter, inSplitOptions));
}
public IEnumerable <StringSlice> EnumeratedSplit(ISplitter inSplitter, StringSplitOptions inSplitOptions)
{
return(EnumerableSplit(m_Source, m_StartIndex, Length, inSplitter, inSplitOptions));
}
public int Split <T>(ISplitter inSplitter, StringSplitOptions inSplitOptions, ref T outSlices) where T : ITempList <StringSlice>
{
return(Split(m_Source, m_StartIndex, Length, inSplitter, inSplitOptions, ref outSlices));
}
public int Split(ISplitter inSplitter, StringSplitOptions inSplitOptions, IList <StringSlice> outSlices)
{
return(Split(m_Source, m_StartIndex, Length, inSplitter, inSplitOptions, outSlices));
}
public void LearnFrom(IEnumerable<string> lines, ISplitter splitter)
{
_items.Clear ();
_separator = splitter.Separator;
_endOfSequence = splitter.EndOfSequence;
foreach (var l in lines)
{
bool atStart = true;
ChainItem current = null;
foreach (string item in splitter.Split(l)) {
if (item == splitter.EndOfSequence) {
if (current != null) {
current.CanFinish = true;
}
atStart = true;
continue;
}
var next = GetOrAdd (item);
if (!atStart) {
current.Register (next.Value);
}
else
{
if (char.IsUpper(next.Value[0]))
next.CanStart = true;
atStart = false;
}
current = next;
}
}
Normalize ();
}
public SplittingTableMapper(ISplitter splitter,
Func<string, ITableMapper> factory)
{
Splitter = splitter;
TableMappers = splitter.Names.Select(factory).ToArray();
}
public LocalhostClientForTesting(string filePath,
ISplitLogger log = null,
ISplitter splitter = null) : base(filePath, log)
{
}
public static void LearnFromFile(this ChainDictionary dictionary, string filepath, ISplitter splitter)
{
dictionary.LearnFrom(File.ReadLines (filepath), splitter);
}
public DefaultCodeReader(ISplitter splitter, ITranslator translator)
{
_splitter = splitter;
_translator = translator;
}
public void Setup()
{
_fixture = new Fixture();
_salesmanSplitter = new SalesmanSplitter();
}
private static IScope InitializeScope(IRandom random, IRegressionProblemData problemData, IPruning pruning, int minLeafSize, ILeafModel leafModel, ISplitter splitter, bool generateRules, bool useHoldout, double holdoutSize)
{
var stateScope = new Scope("RegressionTreeStateScope");
//reduce RegressionProblemData to AllowedInput & Target column wise and to TrainingSet row wise
var doubleVars = new HashSet <string>(problemData.Dataset.DoubleVariables);
var vars = problemData.AllowedInputVariables.Concat(new[] { problemData.TargetVariable }).ToArray();
if (vars.Any(v => !doubleVars.Contains(v)))
{
throw new NotSupportedException("Decision tree regression supports only double valued input or output features.");
}
var doubles = vars.Select(v => problemData.Dataset.GetDoubleValues(v, problemData.TrainingIndices).ToArray()).ToArray();
if (doubles.Any(v => v.Any(x => double.IsNaN(x) || double.IsInfinity(x))))
{
throw new NotSupportedException("Decision tree regression does not support NaN or infinity values in the input dataset.");
}
var trainingData = new Dataset(vars, doubles);
var pd = new RegressionProblemData(trainingData, problemData.AllowedInputVariables, problemData.TargetVariable);
pd.TrainingPartition.End = pd.TestPartition.Start = pd.TestPartition.End = pd.Dataset.Rows;
pd.TrainingPartition.Start = 0;
//store regression tree parameters
var regressionTreeParams = new RegressionTreeParameters(pruning, minLeafSize, leafModel, pd, random, splitter);
stateScope.Variables.Add(new Variable(RegressionTreeParameterVariableName, regressionTreeParams));
//initialize tree operators
pruning.Initialize(stateScope);
splitter.Initialize(stateScope);
leafModel.Initialize(stateScope);
//store unbuilt model
IItem model;
if (generateRules)
{
model = RegressionRuleSetModel.CreateRuleModel(problemData.TargetVariable, regressionTreeParams);
RegressionRuleSetModel.Initialize(stateScope);
}
else
{
model = RegressionNodeTreeModel.CreateTreeModel(problemData.TargetVariable, regressionTreeParams);
}
stateScope.Variables.Add(new Variable(ModelVariableName, model));
//store training & pruning indices
IReadOnlyList <int> trainingSet, pruningSet;
GeneratePruningSet(pd.TrainingIndices.ToArray(), random, useHoldout, holdoutSize, out trainingSet, out pruningSet);
stateScope.Variables.Add(new Variable(TrainingSetVariableName, new IntArray(trainingSet.ToArray())));
stateScope.Variables.Add(new Variable(PruningSetVariableName, new IntArray(pruningSet.ToArray())));
return(stateScope);
}
public RegressionTreeParameters(IPruning pruning, int minleafSize, ILeafModel leafModel,
IRegressionProblemData problemData, IRandom random, ISplitter splitter)
{
this.problemData = problemData;
this.random = random;
this.leafModel = leafModel;
this.splitter = splitter;
this.pruning = pruning;
minLeafSize = Math.Max(pruning.MinLeafSize(problemData, leafModel), Math.Max(minleafSize, leafModel.MinLeafSize(problemData)));
}
public void SetUp()
{
_splitter = A.Fake <ISplitter <Meeting, int> >(x => x.Strict().Named("Merger"));
sut = new ListMerger <Meeting, int>(_splitter);
}
public void Setup()
{
_fixture = new Fixture();
_customerSplitter = new CustomerSplitter();
}
private CaseFormat()
{
_splitter = null;
_humanizerMode = true;
}
public Manager(ISplitter splitter)
{
this.splitter = splitter;
this.parsers = new List<IParser>();
}
public TupleParser(char separator)
{
splitter = new CharSplitter(separator);
}
public Splitter(Generator g)
: base(g, typeof(ISplitter))
{
inner = (ISplitter)base.Handler;
}
public TupleParser(ISplitter splitter)
{
this.splitter = splitter;
}
protected Splitter (Generator generator, Type type, bool initialize = true)
: base (generator, type, initialize)
{
handler = (ISplitter)base.Handler;
}
public RatingDataset(Data.Dataset dataset, RecSysContext context, ISplitter splitter)
{
_allSamples = context.Ratings.Where(r => r.DatasetId == dataset.Id);
splitter.Split(dataset, context, ref _trainSamples, ref _testSamples, ref _evalSamples);
}
public SplittingFieldMapper(ISplitter splitter, Func<string, IEnumerable<IFieldMapper>> fieldMapperFactory)
{
Splitter = splitter;
FieldMappers = splitter.Names.Select(name => fieldMapperFactory(name).ToArray()).ToArray();
}
