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(); }