{"id":49296,"date":"2023-11-27T16:00:00","date_gmt":"2023-11-28T00:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/dotnet\/?p=49296"},"modified":"2024-01-12T11:30:28","modified_gmt":"2024-01-12T19:30:28","slug":"announcing-ml-net-3-0","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/announcing-ml-net-3-0\/","title":{"rendered":"Announcing ML.NET 3.0"},"content":{"rendered":"

ML.NET<\/a> is an open-source, cross-platform machine learning framework for .NET developers that enables integration of custom machine learning models into .NET applications. ML.NET version 3.0<\/a> is now released, with lots of new features and enhancements!<\/p>\n

Deep Learning scenarios were substantially expanded in this release with new capabilities in Object Detection, Named Entity Recognition, and Question Answering. That’s all possible because of integrations and interoperability with TorchSharp and ONNX models. We’ve also updated our integration with LightGBM to the latest version.<\/p>\n

Data processing scenarios are greatly improved with a long list of enhancements and bug fixes to DataFrame<\/code>, as well as new IDataView<\/code> interoperability features. The important steps of loading, inspecting, transforming, and visualizing your data are much more powerful.<\/p>\n

While this post highlights several aspects of the ML.NET 3.0 release, the full list of updates is available in the release notes<\/a>.<\/p>\n

Deep Learning<\/h2>\n

Over the past year, we’ve all witnessed an acceleration of growth in deep learning scenarios and capabilities. With ML.NET 3.0, you can leverage many of these advancements within your .NET applications.<\/p>\n

Object Detection<\/h3>\n

Object detection is a computer vision problem. While closely related to image classification, object detection performs image classification at a more granular scale. Object detection both locates and categorizes entities within images. It’s best to use object detection when images contain multiple objects of different types.<\/p>\n

We announced Object Detection in ML.NET Model Builder<\/a> earlier this year. Those capabilities are built on top of the TorchSharp-powered Object Detection APIs introduced in ML.NET 3.0 (PR #6605<\/a>).<\/p>\n

Under the covers, the Object Detection API leverages some of the latest techniques from Microsoft Research and is backed by a Transformer-based neural network architecture built with TorchSharp. For more details on the underlying model, see the Searching the Space of Vision Transformer<\/a> paper.<\/p>\n

Object Detection is included in the Microsoft.ML.TorchSharp 3.0.0 package<\/a> within the Microsoft.ML.TorchSharp<\/code> and Microsoft.ML.TorchSharp.AutoFormerV2<\/code> namespaces. Read the Object Detection in ML.NET Model Builder<\/a> blog post for an in-depth look.<\/p>\n

var chain = new EstimatorChain<ITransformer>();\r\n\r\nvar filteredPipeline = chain. Append(\r\n        mlContext.Transforms.Text.TokenizeIntoWords(labelColumnName, separators: [',']),\r\n        TransformerScope.Training\r\n    )\r\n    .Append(\r\n        mlContext.Transforms.Conversion.MapValueToKey(labelColumnName),\r\n        TransformerScope.Training\r\n    )\r\n    .Append(\r\n        mlContext.Transforms.Text.TokenizeIntoWords(boundingBoxColumnName, separators: [',']),\r\n        TransformerScope.Training\r\n    )\r\n    .Append(\r\n        mlContext.Transforms.Conversion.ConvertType(boundingBoxColumnName),\r\n        TransformerScope.Training\r\n    )\r\n    .Append(mlContext.Transforms.LoadImages(\"Image\", imageFolder, \"ImagePath\"))\r\n    .Append(\r\n        mlContext.MulticlassClassification.Trainers.ObjectDetection(\r\n            labelColumnName, predictedLabelColumnName, scoreColumnName,\r\n            boundingBoxColumnName, predictedBoundingBoxColumnName,\r\n            imageColumnName, maxEpoch\r\n        )\r\n    )\r\n    .Append(mlContext.Transforms.Conversion.MapKeyToValue(predictedLabelColumnName));\r\n\r\nvar options = new ObjectDetectionTrainer.Options()\r\n{\r\n    LabelColumnName = labelColumnName,\r\n    BoundingBoxColumnName = boundingBoxColumnName,\r\n    ScoreThreshold = .5,\r\n    MaxEpoch = maxEpoch,\r\n    LogEveryNStep = 1,\r\n};\r\n\r\nvar pipeline = mlContext.Transforms.Text.TokenizeIntoWords(labelColumnName, separators: [','])\r\n    .Append(mlContext.Transforms.Conversion.MapValueToKey(labelColumnName))\r\n    .Append(mlContext.Transforms.Text.TokenizeIntoWords(boundingBoxColumnName, separators: [',']))\r\n    .Append(mlContext.Transforms.Conversion.ConvertType(boundingBoxColumnName))\r\n    .Append(mlContext.Transforms.LoadImages(\"Image\", imageFolder, \"ImagePath\"))\r\n    .Append(mlContext.MulticlassClassification.Trainers.ObjectDetection(options))\r\n    .Append(mlContext.Transforms.Conversion.MapKeyToValue(predictedLabelColumnName));\r\n\r\nvar model = pipeline.Fit(data);\r\nvar idv = model.Transform(data);\r\n\r\nvar metrics = ML.MulticlassClassification.EvaluateObjectDetection(\r\n    idv, idv.Schema[2], idv.Schema[boundingBoxColumnName], idv.Schema[predictedLabelColumnName],\r\n    idv.Schema[predictedBoundingBoxColumnName], idv.Schema[scoreColumnName]\r\n);<\/code><\/pre>\n
Named Entity Recognition and Question Answering<\/h3>\n
Natural Language Processing is one of the most common ML needs in software. Two of the most substantial areas of advancement in NLP have been Question Answering (QA) and Named Entity Recognition (NER). Both of these scenarios are unlocked in ML.NET 3.0 by building on top of the existing TorchSharp RoBERTa text classification features introduced in ML.NET 2.0.<\/p>\n
Both the NER and QA trainers are included in the Microsoft.ML.TorchSharp 3.0.0 package<\/a> and the Microsoft.ML.TorchSharp<\/code> namespace.<\/p>\n
\/\/ QA trainer\r\nvar chain = new EstimatorChain<ITransformer>();\r\nvar estimatorQA = chain.Append(mlContext.MulticlassClassification.Trainers.QuestionAnswer(\r\n    contextColumnName, questionColumnName, trainingAnswerColumnName,\r\n    answerIndexColumnName, predictedAnswerColumnName, scoreColumnName,\r\n    topK, batchSize, maxEpochs, architecture, validationSet\r\n));\r\n\r\n\/\/ NER trainer\r\nvar estimatorNER = chain.Append(mlContext.Transforms.Conversion.MapValueToKey(\"Label\", keyData))\r\n    .Append(mlContext.MulticlassClassification.Trainers.NameEntityRecognition(\r\n        labelColumnName, outputColumnName, sentence1ColumnName,\r\n        batchSize, maxEpochs, architecture, validationSet\r\n    ))\r\n    .Append(mlContext.Transforms.Conversion.MapKeyToValue(outputColumn));<\/code><\/pre>\n
Intel oneDAL Training Acceleration<\/h2>\n
Shortly after we released ML.NET 2.0, we announced training hardware acceleration powered by Intel oneDAL as part of the first preview of ML.NET 3.0. Intel oneDAL (Intel oneAPI Data Analytics Library<\/a>) is a library that helps speed up data analysis by providing highly optimized algorithmic building blocks for all stages of the data analytics and machine learning process. Intel oneDAL makes use of the SIMD extensions in 64-bit architectures, which are featured in Intel and AMD CPUs.<\/p>\n
Refer back to the Accelerate ML.NET training with Intel oneDAL<\/a> blog post for more on this feature set.<\/p>\n
Automated Machine Learning (AutoML)<\/h2>\n
Automated Machine Learning (AutoML) automates the process of applying machine learning to data. AutoML powers experiences like those found in Model Builder and the ML.NET CLI.<\/p>\n
With ML.NET 3.0, the AutoML experience gained several new capabilities. The AutoML Sweeper now supports Sentence Similarity, Question Answering, and Object Detection. Community member Antti “Andy” T\u00f6rr\u00f6nen (@torronen)<\/a> implemented a sampling key column name (SamplingKeyColumnName<\/code>) that can be used with SetDataset<\/code> to more easily set the sampling key name. The AutoZero<\/code> tuner can now be used in BinaryClassification<\/code> experiments. The maximum number of models used for an experiment can be specified through ExperimentSettings.MaxModel<\/code>.<\/p>\n
Thanks to community member Andras Fuchs (@andrasfuchs)<\/a>, continuous resource monitoring is available through AutoML.IMonitor<\/code>. This allows monitoring of memory demand, virtual memory usage, and remaining disk space. With that monitoring, long-running experiments can be controlled through a custom IMonitor<\/code> implementation to avoid crashes and failed trials.<\/p>\n
DataFrame<\/h2>\n
This release includes a long list of notable updates to DataFrame<\/code>, many of which were completed by a community member, Aleksei Smirnov (@asmirnov82)<\/a>. We appreciate Aleksei’s contributions and we’re sure you will too!<\/p>\n
To enable more IDataView<\/code> <-> DataFrame<\/code> conversions, support for both String<\/code> and VBuffer<\/code> column types have been added. String<\/code> values are handled as ReadOnlyMemory<char><\/code> , and the VBufferDataFrameColumn<T><\/code> column type supports all backing primitives. Columns can now store more than 2 Gb of data as well, with the previous limitation being removed. Apache Arrow Date64<\/code> column data is recognized now too.<\/p>\n
Data loading scenarios for DataFrame<\/code> are expanded in ML.NET 3.0. Data can now be imported from and exported to SQL databases thanks to community member, Andrei Faber (@andrei-faber)<\/a>. This is accomplished using ADO.NET, which supports a large number of SQL-compatible databases. As part of this implementation, it also became possible to load data from any IEnumerable<\/code> collection and export data to System.Data.DataTable<\/code>. Data from one DataFrame<\/code> can now be appended into another DataFrame<\/code> when their column names match, relaxing a previous constraint on column ordering. Comma-separated data loaded through DataFrame.LoadCsv<\/code> can now handle duplicate column names too, with the option to rename duplicate columns.<\/p>\n
There were many other enhancements and fixes to DataFrame<\/code> too. Arithmetic performance was improved in column cloning and binary comparison scenarios. Null value handling was improved while performing arithmetic operations, requiring fewer steps of transforming and cleaning data. There were even debugger improvements that produce more readable output for columns with long names.<\/p>\n
Tensor Primitives Integration<\/h2>\n
Tensor Primitives is short for System.Numerics.Tensors.TensorPrimitives<\/code>, a new set of APIs that introduce support for tensor operations. As part of .NET 8, our team released a new System.Numerics.Tensors<\/a> package that introduced Tensor Primitives. The Tensor Primitives APIs are the next step in the evolution of Numerics for AI in .NET, building on the momentum of hardware intrinsics and Generic Math.<\/p>\n
While the integration with Tensor Primitives is purely an implementation detail that doesn’t affect the public surface area of ML.NET, it brings some notable performance improvements. The following benchmark results illustrate the gains while targeting .NET 8.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Method<\/th>\narrayLength<\/th>\nMean – Original<\/th>\nMean – New<\/th>\n% Faster<\/th>\n<\/tr>\n<\/thead>\n
AddScalarU<\/td>\n512<\/td>\n25.30 ns<\/td>\n20.32 ns<\/td>\n25%<\/td>\n<\/tr>\n
Scale<\/td>\n512<\/td>\n19.91 ns<\/td>\n19.29 ns<\/td>\n3%<\/td>\n<\/tr>\n
ScaleSrcU<\/td>\n512<\/td>\n27.58 ns<\/td>\n20.74 ns<\/td>\n33%<\/td>\n<\/tr>\n
ScaleAddU<\/td>\n512<\/td>\n28.46 ns<\/td>\n29.05 ns<\/td>\n—<\/td>\n<\/tr>\n
AddScaleU<\/td>\n512<\/td>\n29.74 ns<\/td>\n28.59 ns<\/td>\n4%<\/td>\n<\/tr>\n
AddScaleSU<\/td>\n512<\/td>\n345.92 ns<\/td>\n327.68 ns<\/td>\n6%<\/td>\n<\/tr>\n
AddScaleCopyU<\/td>\n512<\/td>\n34.01 ns<\/td>\n27.03 ns<\/td>\n26%<\/td>\n<\/tr>\n
AddU<\/td>\n512<\/td>\n29.80 ns<\/td>\n26.71 ns<\/td>\n12%<\/td>\n<\/tr>\n
AddSU<\/td>\n512<\/td>\n325.32 ns<\/td>\n349.46 ns<\/td>\n—<\/td>\n<\/tr>\n
MulElementWiseU<\/td>\n512<\/td>\n33.92 ns<\/td>\n27.29 ns<\/td>\n24%<\/td>\n<\/tr>\n
Sum<\/td>\n512<\/td>\n36.57 ns<\/td>\n34.34 ns<\/td>\n6%<\/td>\n<\/tr>\n
SumSqU<\/td>\n512<\/td>\n37.50 ns<\/td>\n39.34 ns<\/td>\n-5%<\/td>\n<\/tr>\n
SumSqDiffU<\/td>\n512<\/td>\n41.23 ns<\/td>\n43.38 ns<\/td>\n—<\/td>\n<\/tr>\n
SumAbsU<\/td>\n512<\/td>\n43.74 ns<\/td>\n39.27 ns<\/td>\n11%<\/td>\n<\/tr>\n
SumAbsDiffU<\/td>\n512<\/td>\n47.23 ns<\/td>\n37.48 ns<\/td>\n26%<\/td>\n<\/tr>\n
MaxAbsU<\/td>\n512<\/td>\n42.30 ns<\/td>\n43.26 ns<\/td>\n—<\/td>\n<\/tr>\n
MaxAbsDiffU<\/td>\n512<\/td>\n46.94 ns<\/td>\n47.73 ns<\/td>\n—<\/td>\n<\/tr>\n
DotU<\/td>\n512<\/td>\n50.34 ns<\/td>\n43.20 ns<\/td>\n17%<\/td>\n<\/tr>\n
DotSU<\/td>\n512<\/td>\n212.19 ns<\/td>\n213.18 ns<\/td>\n—<\/td>\n<\/tr>\n
Dist2<\/td>\n512<\/td>\n55.48 ns<\/td>\n47.43 ns<\/td>\n17%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
More details and the .NET Framework benchmark results are included in the dotnet\/machinelearning#6875<\/a> pull request that introduced this integration.<\/p>\n
Beyond these performance gains, we also used this integration opportunity as a means for testing the API shape, usability, functionality, and correctness of the TensorPrimitives<\/code> APIs. Proving that the APIs could satisfy the ML.NET scenarios was a valuable step toward bringing the System.Numerics.Tensors package out of preview with a stable 8.0.0 version.<\/p>\n
What’s Next<\/h2>\n
With the .NET 8 and ML.NET 3.0 releases completed, we are working on our plans for .NET 9 and ML.NET 4.0. Much sooner than that though, you can expect Model Builder and the ML.NET CLI to be updated to consume the ML.NET 3.0 release.<\/p>\n
We know we will continue expanding deep learning scenarios and integrations, and we know we will keep making enhancements to DataFrame. We will keep expanding the APIs available in System.Numerics.Tensors and integrating them into ML.NET. Stay tuned for more detailed ML.NET 4.0 plans.<\/p>\n
Get started and resources<\/h2>\n
Learn more about ML.NET, Model Builder, and the ML.NET CLI at Microsoft Learn<\/a>.<\/p>\n
If you run into any issues, feature requests, or feedback, please file an issue in the ML.NET repo<\/a>.<\/p>\n
Join the ML.NET Community Discord<\/a> or #machine-learning channel on the .NET Development Discord<\/a>.<\/p>\n
Tune in to the Machine Learning .NET Community Standup<\/a> every other Wednesday at 10am Pacific Time.<\/p>\n","protected":false},"excerpt":{"rendered":"
Announcing ML.NET 3.0, with improvements for deep learning, DataFrame, performance, and more!<\/p>\n","protected":false},"author":4267,"featured_media":49297,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[685,328,688,691],"tags":[],"class_list":["post-49296","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dotnet","category-aiml","category-machine-learning","category-ml-dotnet"],"acf":[],"blog_post_summary":"
Announcing ML.NET 3.0, with improvements for deep learning, DataFrame, performance, and more!<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/49296","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/4267"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=49296"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/49296\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/49297"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=49296"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=49296"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=49296"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}