public Labeler(string modelPath, string repoOwner = "", string repoName = "", string accessToken = "") { _modelPath = modelPath; _repoOwner = repoOwner; _repoName = repoName; _mlContext = new MLContext(seed: 1); //Load model from file using (var stream = new FileStream(_modelPath, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read)) { _trainedModel = _mlContext.Model.Load(stream); } // Create prediction engine related to the loaded trained model _predFunction = _trainedModel.MakePredictionFunction <GitHubIssue, GitHubIssuePrediction>(_mlContext); //Configure Client to access a GitHub repo if (accessToken != string.Empty) { var productInformation = new ProductHeaderValue("MLGitHubLabeler"); _client = new GitHubClient(productInformation) { Credentials = new Credentials(accessToken) }; } }
public void SetupIrisPipeline() { _irisExample = new IrisData() { SepalLength = 3.3f, SepalWidth = 1.6f, PetalLength = 0.2f, PetalWidth = 5.1f, }; string _irisDataPath = Program.GetInvariantCultureDataPath("iris.txt"); var env = new MLContext(seed: 1, conc: 1); var reader = new TextLoader(env, columns: new[] { new TextLoader.Column("Label", DataKind.R4, 0), new TextLoader.Column("SepalLength", DataKind.R4, 1), new TextLoader.Column("SepalWidth", DataKind.R4, 2), new TextLoader.Column("PetalLength", DataKind.R4, 3), new TextLoader.Column("PetalWidth", DataKind.R4, 4), }, hasHeader: true ); IDataView data = reader.Read(_irisDataPath); var pipeline = new ColumnConcatenatingEstimator(env, "Features", new[] { "SepalLength", "SepalWidth", "PetalLength", "PetalWidth" }) .Append(new SdcaMultiClassTrainer(env, "Label", "Features", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; })); var model = pipeline.Fit(data); _irisModel = model.MakePredictionFunction <IrisData, IrisPrediction>(env); }
// Controller public HomeController(ISeederRepository repository, PredictionFunction <StdRoomRateData, RoomRatePrediction> StdRoomRatePredFunction, PredictionFunction <SprRoomRateData, RoomRatePrediction> SprRoomRatePredFunction, PredictionFunction <FamRoomRateData, RoomRatePrediction> FamRoomRatePredFunction, PredictionFunction <SuiteRoomRateData, RoomRatePrediction> SuiteRoomRatePredFunction, PredictionFunction <DlxRoomRateData, RoomRatePrediction> DlxRoomRatePredFunction, PredictionFunction <StdOccupancyData, OccupancyPrediction> StdOccupancyPredFunction, PredictionFunction <SprOccupancyData, OccupancyPrediction> SprOccupancyPredFunction, PredictionFunction <FamOccupancyData, OccupancyPrediction> FamOccupancyPredFunction, PredictionFunction <SuiteOccupancyData, OccupancyPrediction> SuiteOccupancyPredFunction, PredictionFunction <DlxOccupancyData, OccupancyPrediction> DlxOccupancyPredFunction) { this.repository = repository; this.StdRoomRatePredFunction = StdRoomRatePredFunction; this.SprRoomRatePredFunction = SprRoomRatePredFunction; this.FamRoomRatePredFunction = FamRoomRatePredFunction; this.SuiteRoomRatePredFunction = SuiteRoomRatePredFunction; this.DlxRoomRatePredFunction = DlxRoomRatePredFunction; this.StdOccupancyPredFunction = StdOccupancyPredFunction; this.SprOccupancyPredFunction = SprOccupancyPredFunction; this.FamOccupancyPredFunction = FamOccupancyPredFunction; this.SuiteOccupancyPredFunction = SuiteOccupancyPredFunction; this.DlxOccupancyPredFunction = DlxOccupancyPredFunction; }
protected void EvaluateModel(string testLocation, PredictionFunction <ImageNetData, ImageNetPrediction> model) { ConsoleWriteHeader("Metrics for Image Classification"); var evaluator = new MultiClassClassifierEvaluator(env, new MultiClassClassifierEvaluator.Arguments()); var data = TextLoader.ReadFile(env, new TextLoader.Arguments { Separator = "tab", HasHeader = false, Column = new [] { new TextLoader.Column("ImagePath", DataKind.Text, 0), new TextLoader.Column("Label", DataKind.Text, 1) } }, new MultiFileSource(testLocation)); var evalRoles = new RoleMappedData(data, label: "Label", feature: "ImagePath"); var metrics = evaluator.Evaluate(evalRoles); //var logLoss = metrics[MultiClassClassifierEvaluator.LogLoss]; foreach (var item in metrics) { Console.WriteLine($"{item.Key}: {item.Value}"); } }
public void SetupBreastCancerPipeline() { _breastCancerExample = new BreastCancerData() { Features = new[] { 5f, 1f, 1f, 1f, 2f, 1f, 3f, 1f, 1f } }; string _breastCancerDataPath = Program.GetInvariantCultureDataPath("breast-cancer.txt"); using (var env = new ConsoleEnvironment(seed: 1, conc: 1, verbose: false, sensitivity: MessageSensitivity.None, outWriter: EmptyWriter.Instance)) { var reader = new TextLoader(env, new TextLoader.Arguments() { Separator = "\t", HasHeader = false, Column = new[] { new TextLoader.Column("Label", DataKind.BL, 0), new TextLoader.Column("Features", DataKind.R4, new[] { new TextLoader.Range(1, 9) }) } }); IDataView data = reader.Read(_breastCancerDataPath); var pipeline = new LinearClassificationTrainer(env, "Features", "Label", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; }); var model = pipeline.Fit(data); _breastCancerModel = model.MakePredictionFunction <BreastCancerData, BreastCancerPrediction>(env); } }
public void SetupSentimentPipeline() { _sentimentExample = new SentimentData() { SentimentText = "Not a big fan of this." }; string _sentimentDataPath = Program.GetInvariantCultureDataPath("wikipedia-detox-250-line-data.tsv"); using (var env = new ConsoleEnvironment(seed: 1, conc: 1, verbose: false, sensitivity: MessageSensitivity.None, outWriter: EmptyWriter.Instance)) { var reader = new TextLoader(env, new TextLoader.Arguments() { Separator = "\t", HasHeader = true, Column = new[] { new TextLoader.Column("Label", DataKind.BL, 0), new TextLoader.Column("SentimentText", DataKind.Text, 1) } }); IDataView data = reader.Read(_sentimentDataPath); var pipeline = new TextTransform(env, "SentimentText", "Features") .Append(new LinearClassificationTrainer(env, "Features", "Label", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; })); var model = pipeline.Fit(data); _sentimentModel = model.MakePredictionFunction <SentimentData, SentimentPrediction>(env); } }
private static void EvaluateModel(PredictionFunction <TrafficObservation, AlertPrediction> predictor) { Console.WriteLine("Predicting the Future!"); // Can you find a data set that would trigger the prediction to be true? var predictionResult = predictor.Predict(new TrafficObservation() { AvgTotalBytes = 0, AvgTotalPackets = 0, AvgAveragebps = 0, AvgOutPercentUtil = 0, AvgInPercentUtil = 0, AvgPercentUtil = 0, MinTotalBytes = 0, MinTotalPackets = 0, MinAveragebps = 0, MinOutPercentUtil = 0, MinInPercentUtil = 0, MinPercentUtil = 0, MaxTotalBytes = 0, MaxTotalPackets = 0, MaxAveragebps = 0, MaxOutPercentUtil = 0, MaxInPercentUtil = 0, MaxPercentUtil = 0 }); predictionResult.PrintToConsole(); }
public void SetupSentimentPipeline() { _sentimentExample = new SentimentData() { SentimentText = "Not a big fan of this." }; string _sentimentDataPath = Program.GetInvariantCultureDataPath("wikipedia-detox-250-line-data.tsv"); var env = new MLContext(seed: 1, conc: 1); var reader = new TextLoader(env, new TextLoader.Arguments() { Separator = "\t", HasHeader = true, Column = new[] { new TextLoader.Column("Label", DataKind.BL, 0), new TextLoader.Column("SentimentText", DataKind.Text, 1) } }); IDataView data = reader.Read(_sentimentDataPath); var pipeline = new TextFeaturizingEstimator(env, "SentimentText", "Features") .Append(new SdcaBinaryTrainer(env, "Label", "Features", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; })); var model = pipeline.Fit(data); _sentimentModel = model.MakePredictionFunction <SentimentData, SentimentPrediction>(env); }
public void SetupBreastCancerPipeline() { _breastCancerExample = new BreastCancerData() { Features = new[] { 5f, 1f, 1f, 1f, 2f, 1f, 3f, 1f, 1f } }; string _breastCancerDataPath = Program.GetInvariantCultureDataPath("breast-cancer.txt"); var env = new MLContext(seed: 1, conc: 1); var reader = new TextLoader(env, new TextLoader.Arguments() { Separator = "\t", HasHeader = false, Column = new[] { new TextLoader.Column("Label", DataKind.BL, 0), new TextLoader.Column("Features", DataKind.R4, new[] { new TextLoader.Range(1, 9) }) } }); IDataView data = reader.Read(_breastCancerDataPath); var pipeline = new SdcaBinaryTrainer(env, "Label", "Features", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; }); var model = pipeline.Fit(data); _breastCancerModel = model.MakePredictionFunction <BreastCancerData, BreastCancerPrediction>(env); }
public static void ClassifyMessage(PredictionFunction <SpamInput, SpamPrediction> predictor, string message) { var input = new SpamInput { Message = message }; var prediction = predictor.Predict(input); Console.WriteLine("The message '{0}' is {1}", input.Message, prediction.isSpam ? "spam" : "not spam"); }
public ProductDemandForecastController(IOptionsSnapshot <AppSettings> appSettings, PredictionFunction <ProductData, ProductUnitPrediction> productSalesPredFunction ) { this.appSettings = appSettings.Value; // Get injected Product Sales Prediction function this.productSalesPredFunction = productSalesPredFunction; }
public ImageScoringService(string contentRoot, string rootImagesFolder) { _contentRoot = contentRoot; _mlContext = new MLContext(); _modelLocation = Path.Combine(_contentRoot, "model", "model.pb"); _labels = ModelHelpers.ReadLabels(Path.Combine(_contentRoot, "model", "labels.txt")); _imagesFolder = rootImagesFolder; _model = null; }
private static PredictionFunction <SpamInput, SpamPrediction> GetPredictor() { if (_predictor == null) { // Set up the MLContext, which is a catalog of components in ML.NET. var mlContext = new MLContext(); // Create the reader and define which columns from the file should be read. var reader = new TextLoader(mlContext, new TextLoader.Arguments() { Separator = "tab", HasHeader = true, Column = new[] { new TextLoader.Column("Label", DataKind.Text, 0), new TextLoader.Column("Message", DataKind.Text, 1) } }); var data = reader.Read(new MultiFileSource(TrainDataPath)); // Create the estimator which converts the text label to boolean, featurizes the text, and adds a linear trainer. var estimator = mlContext.Transforms.CustomMapping <MyInput, MyOutput>(MyLambda.MyAction, "MyLambda") .Append(mlContext.Transforms.Text.FeaturizeText("Message", "Features")) .Append(mlContext.BinaryClassification.Trainers.StochasticDualCoordinateAscent()); // Evaluate the model using cross-validation. // Cross-validation splits our dataset into 'folds', trains a model on some folds and // evaluates it on the remaining fold. We are using 5 folds so we get back 5 sets of scores. // Let's compute the average AUC, which should be between 0.5 and 1 (higher is better). var cvResults = mlContext.BinaryClassification.CrossValidate(data, estimator, numFolds: 5); var aucs = cvResults.Select(r => r.metrics.Auc); // Now let's train a model on the full dataset to help us get better results var model = estimator.Fit(data); // The dataset we have is skewed, as there are many more non-spam messages than spam messages. // While our model is relatively good at detecting the difference, this skewness leads it to always // say the message is not spam. We deal with this by lowering the threshold of the predictor. In reality, // it is useful to look at the precision-recall curve to identify the best possible threshold. var inPipe = new TransformerChain <ITransformer>(model.Take(model.Count() - 1).ToArray()); var lastTransformer = new BinaryPredictionTransformer <IPredictorProducing <float> >(mlContext, model.LastTransformer.Model, inPipe.GetOutputSchema(data.Schema), model.LastTransformer.FeatureColumn, threshold: 0.15f, thresholdColumn: DefaultColumnNames.Probability); ITransformer[] parts = model.ToArray(); parts[parts.Length - 1] = lastTransformer; var newModel = new TransformerChain <ITransformer>(parts); // Create a PredictionFunction from our model _predictor = newModel.MakePredictionFunction <SpamInput, SpamPrediction>(mlContext); } return(_predictor); }
public CountrySalesForecastController(IOptionsSnapshot <AppSettings> appSettings, PredictionFunction <CountryData, CountrySalesPrediction> countrySalesPredFunction, ILogger <CountrySalesForecastController> logger ) { this.appSettings = appSettings.Value; // Get injected Country Sales Prediction function this.countrySalesPredFunction = countrySalesPredFunction; this.logger = logger; }
private static void PredictSimple(string name, float age, string gender, PredictionFunction <AgeRange, AgeRangePrediction> predictionFunction) { var example = new AgeRange() { Age = age, Name = name, Gender = gender }; var prediction = predictionFunction.Predict(example); Console.WriteLine($"Name: {example.Name}\t Age: {example.Age:00}\t Gender: {example.Gender}\t >> Predicted Label: {prediction.PredictedLabel}"); }
public ITransformer LoadModelFromZipFile(string modelPath) { using (var stream = new FileStream(modelPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { TrainedModel = TransformerChain.LoadFrom(_mlContext, stream); } // Create prediction engine related to the loaded trained model PredictionFunction = TrainedModel.MakePredictionFunction <TObservation, TPrediction>(_mlContext); return(TrainedModel); }
public static void ClassifyMessage(PredictionFunction <Input, Prediction> predictor, string message) { var input = new Input { Message = message }; var prediction = predictor.Predict(input); var output = prediction.IsSpam ? "Spam" : "Not Spam"; Console.WriteLine($"The message '{input.Message}' is '{output}'"); }
private bool LoadModel() { using (var stream = File.OpenRead(_modelName)) { var env = new LocalEnvironment(); ITransformer loadedModel = TransformerChain.LoadFrom(env, stream); _predictionFunction = loadedModel.MakePredictionFunction <PEModelData, PEPrediction>(env); return(true); } }
public ModelScorer(MLContext mlContext, ITransformer trainedModel = null) { _mlContext = mlContext; if (trainedModel != null) { //Keep the trainedModel passed through the constructor TrainedModel = trainedModel; // Create prediction engine related to the passed trained model PredictionFunction = TrainedModel.MakePredictionFunction <TObservation, TPrediction>(_mlContext); } }
/// <summary> /// Use your model to make a prediction /// You can change these numbers to test different predictions /// </summary> /// <typeparam name="TSrc"></typeparam> /// <typeparam name="TDst"></typeparam> /// <param name="dataPath"></param> /// <param name="parameters"></param> /// <param name="inputData"></param> /// <returns></returns> public static TDst Predict <TSrc, TDst>(string dataPath, string[] parameters, TSrc inputData) where TSrc : class where TDst : class, new() { // Create a ML.NET environment MLContext mlContext = new MLContext(); IDataView trainingDataView = mlContext.LoadTrainingData <TSrc>(dataPath, inputData); EstimatorChain <KeyToValueMappingTransformer> learningPipeline = mlContext.GetLearningPipeline(parameters); TransformerChain <KeyToValueMappingTransformer> model = trainingDataView.TrainModel(learningPipeline); PredictionFunction <TSrc, TDst> prediction = model.MakePredictionFunction <TSrc, TDst>(mlContext); TDst result = prediction.Predict(inputData); return(result); }
public static void VisualizeSomePredictions(MLContext mlContext, string modelName, string testDataLocation, PredictionFunction <DemandObservation, DemandPrediction> predFunction, int numberOfPredictions) { //Make a few prediction tests // Make the provided number of predictions and compare with observed data from the test dataset var testData = ReadSampleDataFromCsvFile(testDataLocation, numberOfPredictions); for (int i = 0; i < numberOfPredictions; i++) { //Score var resultprediction = predFunction.Predict(testData[i]); Common.ConsoleHelper.PrintRegressionPredictionVersusObserved(resultprediction.PredictedCount.ToString(), testData[i].Count.ToString()); } }
public TPrediction Predict(TData dataSample) { //Get PredictionEngine object from the Object Pool PredictionFunction <TData, TPrediction> predictionEngine = _predictionEnginePool.GetObject(); //Measure Predict() execution time var watch = System.Diagnostics.Stopwatch.StartNew(); //Predict TPrediction prediction = predictionEngine.Predict(dataSample); //Stop measuring time watch.Stop(); long elapsedMs = watch.ElapsedMilliseconds; //Release used PredictionEngine object into the Object Pool _predictionEnginePool.PutObject(predictionEngine); return(prediction); }
public void SetupIrisPipeline() { _irisExample = new IrisData() { SepalLength = 3.3f, SepalWidth = 1.6f, PetalLength = 0.2f, PetalWidth = 5.1f, }; string _irisDataPath = Program.GetInvariantCultureDataPath("iris.txt"); using (var env = new ConsoleEnvironment(seed: 1, conc: 1, verbose: false, sensitivity: MessageSensitivity.None, outWriter: EmptyWriter.Instance)) { var reader = new TextLoader(env, new TextLoader.Arguments() { Separator = "\t", HasHeader = true, Column = new[] { new TextLoader.Column("Label", DataKind.R4, 0), new TextLoader.Column("SepalLength", DataKind.R4, 1), new TextLoader.Column("SepalWidth", DataKind.R4, 2), new TextLoader.Column("PetalLength", DataKind.R4, 3), new TextLoader.Column("PetalWidth", DataKind.R4, 4), } }); IDataView data = reader.Read(new MultiFileSource(_irisDataPath)); var pipeline = new ConcatEstimator(env, "Features", new[] { "SepalLength", "SepalWidth", "PetalLength", "PetalWidth" }) .Append(new SdcaMultiClassTrainer(env, new SdcaMultiClassTrainer.Arguments { NumThreads = 1, ConvergenceTolerance = 1e-2f }, "Features", "Label")); var model = pipeline.Fit(data); _irisModel = model.MakePredictionFunction <IrisData, IrisPrediction>(env); } }
public void Train(string dest) { using (var env = new ConsoleEnvironment(verbose: false)) { var args = new TextLoader.Arguments() { Separator = ",", HasHeader = true, Column = new TextLoader.Column[] { new TextLoader.Column("Label", DataKind.R4, 0), new TextLoader.Column("Sepal_length", DataKind.R4, 1), new TextLoader.Column("Sepal_width", DataKind.R4, 2), new TextLoader.Column("Petal_length", DataKind.R4, 3), new TextLoader.Column("Petal_width", DataKind.R4, 4), } }; var reader = new TextLoader(env, args); var concat = new ColumnConcatenatingEstimator(env, "Features", "Sepal_length", "Sepal_width", "Petal_length", "Petal_width"); var km = new MulticlassLogisticRegression(env, "Label", "Features"); var pipeline = concat.Append(km); IDataView trainingDataView = reader.Read(new MultiFileSource(_dataset)); var model = pipeline.Fit(trainingDataView); var obs = new IrisObservation() { Sepal_length = 3.3f, Sepal_width = 1.6f, Petal_length = 0.2f, Petal_width = 5.1f, }; _fct = model.MakePredictionFunction <IrisObservation, IrisPrediction>(env); using (var stdest = File.OpenWrite(dest)) model.SaveTo(env, stdest); } }
private void ComparePredictions(PredictionFunction <IrisData, IrisPrediction> model) { IrisPrediction prediction = model.Predict(new IrisData() { SepalLength = 5.1f, SepalWidth = 3.3f, PetalLength = 1.6f, PetalWidth = 0.2f, }); Assert.Equal(1, prediction.PredictedLabels[0], 2); Assert.Equal(0, prediction.PredictedLabels[1], 2); Assert.Equal(0, prediction.PredictedLabels[2], 2); prediction = model.Predict(new IrisData() { SepalLength = 6.4f, SepalWidth = 3.1f, PetalLength = 5.5f, PetalWidth = 2.2f, }); Assert.Equal(0, prediction.PredictedLabels[0], 2); Assert.Equal(0, prediction.PredictedLabels[1], 2); Assert.Equal(1, prediction.PredictedLabels[2], 2); prediction = model.Predict(new IrisData() { SepalLength = 4.4f, SepalWidth = 3.1f, PetalLength = 2.5f, PetalWidth = 1.2f, }); Assert.Equal(.2, prediction.PredictedLabels[0], 1); Assert.Equal(.8, prediction.PredictedLabels[1], 1); Assert.Equal(0, prediction.PredictedLabels[2], 2); }
protected IEnumerable <ImagePredictedLabelWithProbability> PredictDataUsingModel(string testLocation, string imagesFolder, string labelsLocation, PredictionFunction <ImageInputData, ImageNetPrediction> model) { ConsoleWriteHeader("Classificate images"); Console.WriteLine($"Images folder: {imagesFolder}"); Console.WriteLine($"Training file: {testLocation}"); Console.WriteLine($"Labels file: {labelsLocation}"); var labels = ModelHelpers.ReadLabels(labelsLocation); ///////////////////////////////////////////////////////////////////////////////////// // IMAGE 1 // Predict label for "green-office-chair-test.jpg" var image1 = new ImageInputData { ImagePath = imagesFolder + "\\" + "green-office-chair-test.jpg" }; var image1Probabilities = model.Predict(image1).PredictedLabels; //Set a single label as predicted or even none if probabilities were lower than 70% var image1BestLabelPrediction = new ImagePredictedLabelWithProbability() { ImagePath = image1.ImagePath, }; (image1BestLabelPrediction.PredictedLabel, image1BestLabelPrediction.Probability) = GetBestLabel(labels, image1Probabilities); image1BestLabelPrediction.ConsoleWrite(); yield return(image1BestLabelPrediction); ///////////////////////////////////////////////////////////////////////////////////// // IMAGE 2 // Predict label for "high-metal-office-chair.jpg" var image2 = new ImageInputData { ImagePath = imagesFolder + "\\" + "high-metal-office-chair.jpg" }; var image2Probabilities = model.Predict(image2).PredictedLabels; //Set a single label as predicted or even none if probabilities were lower than 70% var image2BestLabelPrediction = new ImagePredictedLabelWithProbability() { ImagePath = image2.ImagePath, }; (image2BestLabelPrediction.PredictedLabel, image2BestLabelPrediction.Probability) = GetBestLabel(labels, image2Probabilities); image2BestLabelPrediction.ConsoleWrite(); yield return(image1BestLabelPrediction); }
protected IEnumerable <ImageNetData> PredictDataUsingModel(string testLocation, string imagesFolder, string labelsLocation, PredictionFunction <ImageNetData, ImageNetPrediction> model) { ConsoleWriteHeader("Classificate images"); Console.WriteLine($"Images folder: {imagesFolder}"); Console.WriteLine($"Training file: {testLocation}"); Console.WriteLine($"Labels file: {labelsLocation}"); var labels = ModelHelpers.ReadLabels(labelsLocation); var testData = ImageNetData.ReadFromCsv(testLocation, imagesFolder); foreach (var sample in testData) { var probs = model.Predict(sample).PredictedLabels; var imageData = new ImageNetDataProbability() { ImagePath = sample.ImagePath, Label = sample.Label }; (imageData.PredictedLabel, imageData.Probability) = GetBestLabel(labels, probs); imageData.ConsoleWrite(); yield return(imageData); } }
public PredictionsController(PredictionFunction <SearchData, FlatPrediction> predictionFn) { _predictionFn = predictionFn; }
public ITransformer Train(IDataView trainingData) { TrainedModel = _trainingPipeline.Fit(trainingData); PredictionFunction = TrainedModel.MakePredictionFunction <DemandObservation, DemandPrediction>(_mlcontext); return(TrainedModel); }
public void Init() { _model = CreatePredictionFunction(); }