Machine Learning in .NET: An Introduction to ML.NET

In contemporary software development, Machine Learning (ML) plays a pivotal role, empowering applications to make informed decisions and predictions. Microsoft has seamlessly integrated the prowess of machine learning into the .NET ecosystem through ML.NET. This blog post serves as a guide to delve into the essentials of ML.NET, elucidating its capabilities and showcasing the seamless integration of machine learning within .NET applications. From enhancing decision-making processes to predicting outcomes intelligently, ML.NET empowers developers to harness the transformative potential of machine learning, ushering in a new era of intelligent and data-driven applications within the robust .NET framework.

What is ML.NET?

ML.NET stands as an open-source and cross-platform machine learning framework meticulously crafted by Microsoft. This innovative framework empowers .NET developers by providing a seamless avenue to construct and seamlessly integrate bespoke machine learning models into their applications. The versatility of ML.NET extends across a spectrum of machine learning scenarios, spanning conventional responsibilities like classification and regression to more sophisticated tasks, including anomaly detection and recommendation systems. With its user-friendly design and robust functionality, ML.NET not only simplifies the complexities associated with machine learning integration but also fosters a dynamic environment for developers to explore and implement advanced data-driven solutions within their .NET applications effortlessly.

Use ML.NET when the data is tabular or text, you train offline, and you want to score inside a C# API with no Python process. Use Python when the team already lives in notebooks, you need GPU training, or the model family is outside ML.NET. Sentiment-style samples in this post fit ML.NET. Large language models usually do not.

The intro in the article is broad. ML.NET will not “usher in a new era” by itself. It will fit a model file into a .NET app if the problem is the size of this sample.

Install-Package Microsoft.ML is the core. Some tasks need extra NuGet packages (recommendation, image, time series). Add those when the sample tells you to. Do not assume every algorithm lives in Microsoft.ML alone.

The pipeline snippet in the post is incomplete on purpose (the comment says additional steps). A real sentiment trainer usually needs a label conversion and a trainer like SdcaLogisticRegression or a FastTree. Copy-pasting that fragment and calling Fit will fail or produce nonsense. Follow a full Microsoft sample for the first working train.

Train on a laptop for this class of problem. Save the model. Load it in the API or a worker. Retrain when the data changes. Keep training CSVs out of a public repo.

Let’s start with ML.NET.

Step 1: Install ML.NET Package

To get started with ML.NET, you need to install the Microsoft.ML NuGet package. Open your Visual Studio project and run the following command in the Package Manager Console:

Install-Package Microsoft.ML

This command installs the Microsoft.ML NuGet package, which is the core package for ML.NET. It contains the necessary libraries and dependencies for working with machine learning in .NET applications.

GPU is not required for Microsoft.ML getting-started paths. GPU matters for deep learning, not a small CPU classifier.

Hold out a test set. Check precision and recall per class, not only accuracy. A model that always says positive can look fine on a skewed file. Spot-check mistakes in staging. If a wrong label is expensive, add a human step.

Ship the model with the app or pull it from blob storage at startup so you can swap versions. Do not retrain on the request path. Keep a version number next to each prediction.

MLContext should be created carefully in a web app. The docs discuss singleton vs per-request. Do not new it up on every HTTP call without reading that note.

FeaturizeText is a start for bag-of-words style features. It is not magic understanding. Short, messy user text still needs cleaning (trim, maybe lower case) or the model chases noise.

Normalization and stop-word choices change the model. If two people train on the same CSV with different text options, scores will not match. Write the pipeline down or you cannot reproduce a demo.

Class imbalance: if 90% of rows are “positive,” a dummy model looks smart. Always check the majority baseline before you celebrate accuracy.

Seed the MLContext when you need a repeatable demo. Random trainers plus “it was 82% yesterday” is how trust dies in a meeting.

Step 2: Create a Simple ML.NET Model

Let’s create a basic ML.NET model for sentiment analysis. In this example, we’ll train a model to predict whether a given text has positive or negative sentiment.

using System;
using Microsoft.ML;
using Microsoft.ML.Data;
// Define a data model for training and prediction
public class SentimentData
{
    [LoadColumn(0)] public string Sentiment;
    [LoadColumn(1)] public string Text;
}
public class SentimentPrediction
{
    [ColumnName("PredictedLabel")]
    public string Prediction { get; set; }
}

• We define two classes, SentimentData and SentimentPrediction. The SentimentData class represents the data used for training the model, and the SentimentPrediction class represents the output prediction.
• The LoadColumn attribute is used to specify the column indices when loading data from a CSV file. In this example, the Sentiment column is at index 0, and the Text column is at index 1.

class Program
{
    static void Main()
    {
        // Create a new MLContext
        var mlContext = new MLContext();
        // Load data
        var data = mlContext.Data.LoadFromTextFile<SentimentData>("sentiment_data.csv", separatorChar: ',');
        // Define the pipeline
        var pipeline = mlContext.Transforms.Text.FeaturizeText("Features", "Text")
            .Append(mlContext.Transforms.CopyColumns("Label", "Sentiment"))
            // ... (additional pipeline steps)
            .Append(mlContext.Transforms.Conversion.MapKeyToValue("Features"));
        // Train the model
        var model = pipeline.Fit(data);
        // Make a prediction
        var predictionEngine = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
        var prediction = predictionEngine.Predict(new SentimentData { Text = "ML.NET is fantastic!" });
        // Display the prediction
        Console.WriteLine($"Predicted Sentiment: {prediction.Prediction}");
    }
}

• We create an MLContext, which is the primary entry point for working with ML.NET.
• The code loads data from a CSV file. (assume the file named “sentiment_data.csv” and uses a comma as the separator).
• The code defines a pipeline to transform and preprocess the data. The example pipeline includes steps like featuring text, copying columns, normalizing text, tokenizing words, and more.
• The model is trained using the Fit method, which takes the data and the defined pipeline.
• The code executes a prediction by employing a prediction engine created from the trained model and displays the result.

This example provides a simplified overview of creating a sentiment analysis model with ML.NET. Additional pipeline steps and customization may be necessary, depending on the specific task at hand.

Cross-validation is how you stop a lucky train/test split. One holdout is fine for a blog. For a go-live number, use more than one fold or at least two different splits.

Feature contribution (which words pushed the score) helps a human sanity-check. If the model loves a customer id that leaked into the text, you have a bug, not a genius.

If the CSV encoding or separator is wrong, LoadFromTextFile fails in ways that look like trainer bugs. Open the file. Confirm the header matches LoadColumn indexes. The sample uses 0 and 1. Off-by-one here wastes a day.

hasHeader in LoadFromTextFile matters. If the file has a header and you did not say so, your first row becomes data and types break. If you said hasHeader and there is none, you drop a real row.

IDataView is lazy. Fit is where work happens. A pipeline that “runs” in a second and a trainer that runs for ten minutes is normal. Do not assume the app is hung until you have waited and watched CPU.

Save the model with mlContext.Model.Save and load with Load. Schema must match. If you change SentimentData fields and forget to retrain, load fails or predictions are junk.

For a web API, create the PredictionEngine pool the way the docs recommend for thread safety. A static engine on a busy site can surprise you.

This sample is binary-ish sentiment as strings. If your labels are numbers, the trainer and the metrics change. Read the task type before you copy a trainer from another tutorial.

Image and recommendation tasks need extra packages and more data than this sentiment file. Do not promise those from this sample. Point at Microsoft’s task-specific samples.

When you expose a predict API, rate-limit it. A public demo that scores free text will get abused. Auth on the endpoint is not optional if it is on the internet.

Data drift: last year’s tickets do not look like this year’s. Schedule a retrain when precision drops, not when someone remembers.

ONNX is an option if you train elsewhere and only score in .NET. ML.NET can consume some ONNX models. That is a different path than Fit() in this tutorial. Use it when the data science team is not a C# team.

Logging predictions (input hash, score, model version) lets you explain a complaint next month. Do not log raw personal text to a public blob.

A calibration check on a new batch of labels is cheaper than a rewrite. If the world changed, retrain. If the pipeline has a bug, fix the pipeline. Do not keep stacking trainers on a dirty CSV.

Conclusion

ML.NET brings the power of machine learning to .NET developers, enabling them to build and deploy custom machine learning models seamlessly. Whether you’re working on sentiment analysis, image classification, or regression tasks, ML.NET provides a user-friendly and extensible framework for incorporating machine learning into your applications. Dive into the world of ML.NET, explore its capabilities, and unleash the potential of machine learning in your .NET projects!