SQL सर्वर, ML.NET और C# के साथ मशीन लर्निंग मॉडल बनाना

यह लेख मैथ्यू डी. ग्रोव्स की चौथी वार्षिक सी# एडवेंट कैलेंडर पहल का हिस्सा है। आपको समुदाय के सदस्यों और विशेषज्ञों द्वारा प्रतिदिन प्रकाशित अन्य उपयोगी लेख और ट्यूटोरियल मिलेंगे, इसलिए इसे हर दिन देखना सुनिश्चित करें।

ML.NET एक मुफ़्त, खुला स्रोत और क्रॉस-प्लेटफ़ॉर्म मशीन लर्निंग फ्रेमवर्क है जिसे .NET डेवलपर्स के लिए डिज़ाइन किया गया है। ML.NET आपको .NET डेवलपर के रूप में आपके पास पहले से मौजूद सभी ज्ञान, कौशल, कोड और पुस्तकालयों का पुन:उपयोग करने देता है ताकि आप आसानी से अपने वेब, मोबाइल, डेस्कटॉप, गेम और IoT ऐप्स में मशीन लर्निंग को एकीकृत कर सकें।

आप अपने निपटान में 40 से अधिक प्रशिक्षकों (कार्य-आधारित एमएल एल्गोरिदम) के साथ वर्गीकरण, प्रतिगमन, समय श्रृंखला और यहां तक ​​कि कंप्यूटर दृष्टि (गहरी शिक्षा, छवि वर्गीकरण) परिदृश्यों के लिए इसे लागू कर सकते हैं।

संस्करण 1.4-पूर्वावलोकन के बाद से, DatabaseLoader वर्ग समर्थित है, जिसका अर्थ है कि अब हम SQL सर्वर, Oracle, PostgreSQL, SQLite, और अन्य सहित रिलेशनल डेटाबेस के विरुद्ध सीधे मॉडल को प्रशिक्षित और निर्माण कर सकते हैं।

इस उदाहरण के लिए, मैं एक मॉडल बनाने जा रहा हूं जो यह पहचानने में मदद करता है कि क्या एक महिला अन्य रोगियों के ऐतिहासिक डेटा के आधार पर मधुमेह विकसित कर सकती है। मैं एक कागल डेटासेट का उपयोग कर रहा हूं जिसे आप यहां से डाउनलोड कर सकते हैं।

उसके बाद, एक रोगी बनाएं जानकारी संग्रहीत करने के लिए तालिका। केवल एक असली . का उपयोग करने की आवश्यकता है संख्यात्मक क्षेत्रों के लिए डेटा प्रकार, क्योंकि ML.NET केवल इस प्रकार को समझेगा। एक अन्य विकल्प यह है कि जब आप डेटा को पुनः प्राप्त करते हैं और फ़ील्ड को वास्तविक फ्लाई पर में परिवर्तित करते हैं, तो एक CAST ऑपरेशन करें। .

CREATE TABLE Patient(
  Id int identity(1,1) primary key,
  Pregnancies real not null,
  Glucose real not null,
  BloodPressure real not null,
  SkinThickness real not null,
  Insulin real not null,
  BMI real not null,
  DiabetesPedigreeFunction real not null,
  Age real not null,
  Output varchar(1) not null
)

और निश्चित रूप से, आपको सीएसवी फ़ाइल के सभी डेटा को तालिका में सम्मिलित करना होगा .

अब, कुछ कोड लिखते हैं!

चरण 1. एक नया C# कंसोल एप्लिकेशन प्रोजेक्ट बनाएं:

चरण 2. अपने प्रोजेक्ट में निम्नलिखित Nuget पैकेज जोड़ें:

• माइक्रोसॉफ्ट.एमएल
• System.Data.SqlClient
• Microsoft.Extensions.कॉन्फ़िगरेशन
• Microsoft.Extensions.Configuration.Json
• Microsoft.Extensions.Configuration.FileExtensions

चरण 3. अपने प्रोजेक्ट में ऐप सेटिंग फ़ाइल जोड़ें।

इस फ़ाइल में, एक ConnectionStrings जोड़ें DbConnection . के साथ संग्रह तत्व। मूल्य, निश्चित रूप से, उस डेटाबेस से कनेक्शन स्ट्रिंग है जहां आपका डेटा रहता है।

उदाहरण के लिए, मैं एक Azure SQL डेटाबेस से कनेक्ट होऊंगा :

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "ConnectionStrings": {
    "DbConnection": "Server=tcp:myserver.database.windows.net,1433;Initial Catalog=mydatabase;Persist Security Info=False;User ID=myadmin;Password=MYadm1n;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
  }
}

नोट:आउटपुट निर्देशिका में कॉपी करें सेट करें इस फ़ाइल के लिए संपत्ति, अन्यथा इसे बाद में कार्यक्रम द्वारा नहीं पढ़ा जाएगा।

चरण 4 एक मॉडल जोड़ें आपकी परियोजना के लिए फ़ोल्डर। अंदर, रोगी . नामक एक नई कक्षा बनाएं , जिसमें कई गुण शामिल हैं जो तालिका संरचना से मेल खाते हैं। साथ ही, प्रत्येक प्रॉपर्टी को LoadColumnAttribute . से सजाया गया है एक शून्य-आधारित अनुक्रमणिका के साथ जो उस स्तंभ का प्रतिनिधित्व करता है जिसे डेटाबेस तालिका से मैप किया जाएगा।

using Microsoft.ML.Data;

namespace DiabetesPrediction.Models
{
    public class Patient
    {
        [LoadColumn(0)]
        public float Id { get; set; }

        [LoadColumn(1)]
        public float Pregnancies { get; set; }

        [LoadColumn(2)]
        public float Glucose { get; set; }

        [LoadColumn(3)]
        public float BloodPressure { get; set; }

        [LoadColumn(4)]
        public float SkinThickness { get; set; }

        [LoadColumn(5)]
        public float Insulin { get; set; }

        [LoadColumn(6)]
        public float BMI { get; set; }

        [LoadColumn(7)]
        public float DiabetesPedigreeFunction { get; set; }

        [LoadColumn(8)]
        public float Age { get; set; }

        [LoadColumn(9)]
        public float Output { get; set; }
    }
}

चरण 5. एक DiabetesMLPrediction जोड़ें वर्ग जो रोगी से विरासत में मिला है और इसमें अतिरिक्त गुण शामिल हैं। भविष्यवाणी डेटा दिखाने के लिए, मशीन लर्निंग मॉडल के निर्माण के बाद इसका उपयोग किया जाएगा:

using Microsoft.ML.Data;

namespace DiabetesPrediction.Models
{
    public class DiabetesMLPrediction : Patient
    {
        [ColumnName("PredictedLabel")]
        public float Prediction { get; set; }

        public float Probability { get; set; }

        public float[] Score { get; set; }
    }
}

चरण 6. Program.cs . में फ़ाइल:

ए। इन नामस्थानों को जोड़ें:

using System;
using System.IO;
using System.Linq;
using System.Data.SqlClient;

using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.Extensions.Configuration;

using DiabetesPrediction.Models;

बी। कक्षा के अंदर, एक GetDbConnection जोड़ें विधि जो कनेक्शन स्ट्रिंग को appsettings.json . से निकालती है फ़ाइल:

private static string GetDbConnection()
{
   var builder = new ConfigurationBuilder()
      .SetBasePath(Directory.GetCurrentDirectory())
      .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

   return builder.Build().GetConnectionString("DbConnection");
}

सी। मुख्य विधि में:

• MLContext इंस्टेंस बनाएं
• रोगी वर्ग के आधार पर डेटाबेस लोडर इंस्टेंस बनाएं
• GetDbConnection विधि को कॉल करें
• एक SQL कथन तैयार करें जो सभी डेटा को पढ़ता है (और आईडी को वास्तविक फ़ील्ड में परिवर्तित करता है)
• एक डेटाबेस स्रोत इंस्टेंस तैयार करें जो कनेक्शन स्ट्रिंग और स्टेटमेंट का उपयोग करता है।

var context = new MLContext();

var loader = context.Data.CreateDatabaseLoader<Patient>();

var connectionString = GetDbConnection();

var sqlCommand = "Select CAST(Id as REAL) as Id, Pregnancies, Glucose, BloodPressure, SkinThickness, Insulin, BMI, DiabetesPedigreeFunction, Age, CAST(Output as REAL) as Output From Patient";

var dbSource = new DatabaseSource(SqlClientFactory.Instance, connectionString, sqlCommand);

• तालिका से डेटा को IDataView ऑब्जेक्ट में लोड करें और इसे दो अन्य IDataViews में विभाजित करें, एक प्रशिक्षण के लिए और दूसरा मूल्यांकन के लिए:

Console.WriteLine("Loading data from database...");
var data = loader.Load(dbSource);

var set = context.Data.TrainTestSplit(data, testFraction: 0.2);
var trainingData = set.TrainSet;
var testData = set.TestSet;

• एक प्रशिक्षण पाइपलाइन तैयार करके एक ITransformer बनाएं जो एक बाइनरी क्लासिफिकेशन मशीन लर्निंग मॉडल बनाएगा। उस कॉलम को निर्दिष्ट करें जिसका पूर्वानुमान लगाया जाएगा (आउटपुट):

Console.WriteLine("Preparing training operations...");
var pipeline = context.Transforms
       .Conversion.MapValueToKey(outputColumnName: "Label", inputColumnName: "Output")
       .Append(context.Transforms.Concatenate("Features", "Pregnancies", "Glucose", "BloodPressure", "SkinThickness", "Insulin", "BMI", "DiabetesPedigreeFunction", "Age"))
       .Append(context.MulticlassClassification.Trainers.OneVersusAll(context.BinaryClassification.Trainers.AveragedPerceptron("Label", "Features", numberOfIterations: 10))
       .Append(context.Transforms.Conversion.MapKeyToValue("PredictedLabel")));

• अब, प्रशिक्षण डेटासेट को 10 तहों में विभाजित करें। प्रशिक्षण में 9 फोल्ड का उपयोग किया जाता है और शेष फोल्ड का उपयोग परीक्षण के लिए किया जाता है। यह प्रक्रिया ट्रेन और परीक्षण डेटासेट को बदलते हुए 10 बार दोहराई जाती है। इस प्रक्रिया को 10-गुना क्रॉस सत्यापन के रूप में जाना जाता है (बेशक, आप संख्या बदल सकते हैं)। मीट्रिक भी प्रदर्शित होते हैं:

Console.WriteLine("=============== Starting 10 fold cross validation ===============");
var crossValResults = context.MulticlassClassification.CrossValidate(data: trainingData, estimator: pipeline, numberOfFolds: 10, labelColumnName: "Label");
var metricsInMultipleFolds = crossValResults.Select(r => r.Metrics);
var microAccuracyValues = metricsInMultipleFolds.Select(m => m.MicroAccuracy);
var microAccuracyAverage = microAccuracyValues.Average();
var macroAccuracyValues = metricsInMultipleFolds.Select(m => m.MacroAccuracy);
var macroAccuracyAverage = macroAccuracyValues.Average();
var logLossValues = metricsInMultipleFolds.Select(m => m.LogLoss);
var logLossAverage = logLossValues.Average();
var logLossReductionValues = metricsInMultipleFolds.Select(m => m.LogLossReduction);
var logLossReductionAverage = logLossReductionValues.Average(); Console.WriteLine($"*************************************************************************************************************");

Console.WriteLine($"*       Metrics Multi-class Classification model      ");
Console.WriteLine($"*------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"*       Average MicroAccuracy:   {microAccuracyAverage:0.###} ");
Console.WriteLine($"*       Average MacroAccuracy:    {macroAccuracyAverage:0.###} ");
Console.WriteLine($"*       Average LogLoss:          {logLossAverage:#.###} ");
Console.WriteLine($"*       Average LogLossReduction: {logLossReductionAverage:#.###} ");
Console.WriteLine($"*************************************************************************************************************");

• अगला, आप फ़िट विधि को कॉल करके मॉडल को प्रशिक्षित कर सकते हैं:

Console.WriteLine($"Training process is starting. {DateTime.Now.ToLongTimeString()}");
var model = pipeline.Fit(trainingData);
Console.WriteLine($"Training process has finished. {DateTime.Now.ToLongTimeString()}");

इस प्रक्रिया में कुछ समय लगता है।

• मॉडल बनने के बाद, आप PredictionEngine बनाकर और पेशेंट ऑब्जेक्ट को Prediction विधि में पास करके भविष्यवाणी करना शुरू कर सकते हैं:

var predictionEngine = context.Model.CreatePredictionEngine<Patient, DiabetesMLPrediction>(model);

var patient = new Patient()
{
  Age = 42,
  BloodPressure = 81,
  BMI = 30.1f,
  DiabetesPedigreeFunction = 0.987f,
  Glucose = 120,
  Insulin = 100,
  Pregnancies = 1,
  SkinThickness = 26,
  Id = 0,
  Output = 0
};

var prediction = predictionEngine.Predict(patient);
Console.WriteLine($"Diabetes? {prediction.Output} | Prediction: {(Convert.ToBoolean(prediction.Prediction) ? "Yes" : "No")} | Probability: {prediction.Probability} ");

• आखिरकार, आप मॉडल को अन्य प्रोजेक्ट्स (वेब ​​एपी, एज़्योर फ़ंक्शंस, आदि) में उपयोग करने के लिए सहेज सकते हैं

Console.WriteLine("Saving the model");
context.Model.Save(model, trainingData.Schema, "MLModel.zip");

चरण 7. प्रोग्राम चलाएं, आपको परिणाम मिलेंगे और कुछ पूर्वानुमानों के लिए एक एमएल मॉडल तैयार होगा:

कोड GitHub पर उपलब्ध है।

मुझे उम्मीद है कि यह ब्लॉग पोस्ट आपके लिए दिलचस्प और उपयोगी थी। मैं आपको Xamarin, Azure, और .NET पारिस्थितिकी तंत्र के बारे में अधिक तकनीकी पोस्ट के लिए मेरे ब्लॉग पर आने के लिए आमंत्रित करता हूं . मैं स्पेनिश भाषा में लिखता हूँ =)

आपके समय के लिए धन्यवाद, और बाकी C# एडवेंट कैलेंडर प्रकाशनों का आनंद लें!

फिर मिलते हैं,
लुइस