ML.Net 5 - Prevendo Diabetes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img align=\"Left\" alt=\"Dados_ao_Cubo\" src=\"../shared_content/DADOS-AO-CUBO-Versão-04-1.png\" />\n",
    "<img align=\"right\" alt=\"MLNet\" src=\"../shared_content/EJ3KsfJWsAEtDaZ.png\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Davi Ramos -> Cientista de Dados 👋\n",
    "(davi.info@gmail.com)\n",
    "\n",
    "[![Linkedin Badge](https://img.shields.io/badge/-LinkedIn-blue?style=flat-square&logo=Linkedin&logoColor=white&link=https://www.linkedin.com/in/davi-ramos/)](https://www.linkedin.com/in/davi-ramos/)\n",
    "[![Twitter Badge](https://img.shields.io/badge/-Twitter-1DA1F2?style=flat-square&logo=Twitter&logoColor=white&link=https://twitter.com/Daviinfo/)](https://twitter.com/Daviinfo/)\n",
    "<a href=\"https://github.com/DaviRamos\"><img src=\"https://img.shields.io/github/followers/DaviRamos.svg?label=GitHub&style=social\" alt=\"GitHub\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ML.Net - "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Este exemplo irá criar um modelo de regressão linear para prever os preços das residências utilizando os seus dados de tamanho e Preço."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\r\n",
       "<div>\r\n",
       "    <div id='dotnet-interactive-this-cell-2015.4d205dc19cf943cf8b53514c4f704cc9' style='display: none'>\r\n",
       "        The below script needs to be able to find the current output cell; this is an easy method to get it.\r\n",
       "    </div>\r\n",
       "    <script type='text/javascript'>\r\n",
       "// ensure `require` is available globally\r\n",
       "if (typeof require !== typeof Function || typeof require.config !== typeof Function) {\r\n",
       "    let require_script = document.createElement('script');\r\n",
       "    require_script.setAttribute('src', 'https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.6/require.min.js');\r\n",
       "    require_script.setAttribute('type', 'text/javascript');\r\n",
       "    require_script.onload = function () {\r\n",
       "        loadDotnetInteractiveApi();\r\n",
       "    };\r\n",
       "\r\n",
       "    document.getElementsByTagName('head')[0].appendChild(require_script);\r\n",
       "}\r\n",
       "else {\r\n",
       "    loadDotnetInteractiveApi();\r\n",
       "}\r\n",
       "\r\n",
       "async function probeAddresses(probingAddresses) {\r\n",
       "    function timeout(ms, promise) {\r\n",
       "        return new Promise(function (resolve, reject) {\r\n",
       "            setTimeout(function () {\r\n",
       "                reject(new Error('timeout'))\r\n",
       "            }, ms)\r\n",
       "            promise.then(resolve, reject)\r\n",
       "        })\r\n",
       "    }\r\n",
       "\r\n",
       "    if (Array.isArray(probingAddresses)) {\r\n",
       "        for (let i = 0; i < probingAddresses.length; i++) {\r\n",
       "\r\n",
       "            let rootUrl = probingAddresses[i];\r\n",
       "\r\n",
       "            if (!rootUrl.endsWith('/')) {\r\n",
       "                rootUrl = `${rootUrl}/`;\r\n",
       "            }\r\n",
       "\r\n",
       "            try {\r\n",
       "                let response = await timeout(1000, fetch(`${rootUrl}discovery`, {\r\n",
       "                    method: 'POST',\r\n",
       "                    cache: 'no-cache',\r\n",
       "                    mode: 'cors',\r\n",
       "                    timeout: 1000,\r\n",
       "                    headers: {\r\n",
       "                        'Content-Type': 'text/plain'\r\n",
       "                    },\r\n",
       "                    body: probingAddresses[i]\r\n",
       "                }));\r\n",
       "\r\n",
       "                if (response.status == 200) {\r\n",
       "                    return rootUrl;\r\n",
       "                }\r\n",
       "            }\r\n",
       "            catch (e) { }\r\n",
       "        }\r\n",
       "    }\r\n",
       "}\r\n",
       "\r\n",
       "function loadDotnetInteractiveApi() {\r\n",
       "    probeAddresses([\"http://172.20.78.247:1028/\", \"http://127.0.0.1:1028/\"])\r\n",
       "        .then((root) => {\r\n",
       "            // use probing to find host url and api resources\r\n",
       "            // load interactive helpers and language services\r\n",
       "            let dotnetInteractiveRequire = require.config({\r\n",
       "                context: '2015.4d205dc19cf943cf8b53514c4f704cc9',\r\n",
       "                paths: {\r\n",
       "                    'dotnet-interactive': `${root}resources`\r\n",
       "                }\r\n",
       "            }) || require;\r\n",
       "\r\n",
       "            let dotnetInteractiveExtensionsRequire = require.config({\r\n",
       "                context: '2015.4d205dc19cf943cf8b53514c4f704cc9',\r\n",
       "                paths: {\r\n",
       "                    'dotnet-interactive-extensions': `${root}extensions`\r\n",
       "                }\r\n",
       "            }) || require;\r\n",
       "\r\n",
       "            if (!window.dotnetInteractiveRequire) {\r\n",
       "                window.dotnetInteractiveRequire = dotnetInteractiveRequire;\r\n",
       "            }\r\n",
       "\r\n",
       "            if (!window.dotnetInteractiveExtensionsRequire) {\r\n",
       "                window.dotnetInteractiveExtensionsRequire = dotnetInteractiveExtensionsRequire;\r\n",
       "            }\r\n",
       "\r\n",
       "            window.getExtensionRequire = function(extensionName, extensionCacheBuster) {\r\n",
       "                let paths = {};\r\n",
       "                paths[extensionName] = `${root}extensions/${extensionName}/resources/`;\r\n",
       "                \r\n",
       "                let internalRequire = require.config({\r\n",
       "                    context: extensionCacheBuster,\r\n",
       "                    paths: paths,\r\n",
       "                    urlArgs: `cacheBuster=${extensionCacheBuster}`\r\n",
       "                    }) || require;\r\n",
       "\r\n",
       "                return internalRequire\r\n",
       "            };\r\n",
       "        \r\n",
       "            dotnetInteractiveRequire([\r\n",
       "                    'dotnet-interactive/dotnet-interactive'\r\n",
       "                ],\r\n",
       "                function (dotnet) {\r\n",
       "                    dotnet.init(window);\r\n",
       "                },\r\n",
       "                function (error) {\r\n",
       "                    console.log(error);\r\n",
       "                }\r\n",
       "            );\r\n",
       "        })\r\n",
       "        .catch(error => {console.log(error);});\r\n",
       "    }\r\n",
       "    </script>\r\n",
       "</div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Installed package XPlot.Plotly version 3.0.1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Installed package Microsoft.ML.FastTree version 1.5.2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Installed package Microsoft.ML version 1.5.2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Installed package Microsoft.Data.Analysis version 0.4.0"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "// Instalar os Pacotes do Nuget\n",
    "\n",
    "// ML.NET\n",
    "#r \"nuget:Microsoft.ML\"  \n",
    "\n",
    "// ML.NET FastTree \n",
    "#r \"nuget:Microsoft.ML.FastTree\" \n",
    "   \n",
    "//  DataFrame\n",
    "#r \"nuget:Microsoft.Data.Analysis\"\n",
    "\n",
    "//  XPlot\n",
    "#r \"nuget:XPlot.Plotly\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "using System;\n",
    "using System.Collections.Generic;\n",
    "using System.Diagnostics;\n",
    "using System.Linq;\n",
    "using Microsoft.ML;\n",
    "using Microsoft.ML.Data;\n",
    "using Microsoft.Data.Analysis;\n",
    "using Microsoft.AspNetCore.Html;\n",
    "using Microsoft.ML.Trainers.FastTree;\n",
    "using System.IO;\n",
    "using System.IO.Compression;\n",
    "using System.Net.Http;\n",
    "using System.Globalization;\n",
    "using XPlot.Plotly;\n",
    "\n",
    "using static Microsoft.ML.TrainCatalogBase;\n",
    "using static Microsoft.ML.DataOperationsCatalog;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Caminho dos arquivos\n",
    "string diabetesPath = \"./Diabetes/diabetes.csv\";\n",
    "string modelPath = @\"./Diabetes.zip\";\n",
    "\n",
    "string  ConnectionStrings = @\"Server=tcp:xxx.database.windows.net,1433;Initial Catalog=xxx;Persist Security Info=False;User ID=xxx;Password=xxx;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;\";\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "Unhandled exception",
     "evalue": "System.IO.DirectoryNotFoundException: Could not find a part of the path '/mnt/d/Onderive/Particular/OneDrive/Projetos/ML.Net/DadosCubo_Davi/Diabetes/diabetes.csv'.\n   at Interop.ThrowExceptionForIoErrno(ErrorInfo errorInfo, String path, Boolean isDirectory, Func`2 errorRewriter)\n   at Microsoft.Win32.SafeHandles.SafeFileHandle.Open(String path, OpenFlags flags, Int32 mode)\n   at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options)\n   at System.IO.StreamWriter.ValidateArgsAndOpenPath(String path, Boolean append, Encoding encoding, Int32 bufferSize)\n   at System.IO.StreamWriter..ctor(String path)\n   at System.IO.File.WriteAllText(String path, String contents)\n   at Submission#25.<<Initialize>>d__0.MoveNext()\n--- End of stack trace from previous location where exception was thrown ---\n   at Microsoft.CodeAnalysis.Scripting.ScriptExecutionState.RunSubmissionsAsync[TResult](ImmutableArray`1 precedingExecutors, Func`2 currentExecutor, StrongBox`1 exceptionHolderOpt, Func`2 catchExceptionOpt, CancellationToken cancellationToken)",
     "output_type": "error",
     "traceback": [
      "System.IO.DirectoryNotFoundException: Could not find a part of the path '/mnt/d/Onderive/Particular/OneDrive/Projetos/ML.Net/DadosCubo_Davi/Diabetes/diabetes.csv'.\n   at Interop.ThrowExceptionForIoErrno(ErrorInfo errorInfo, String path, Boolean isDirectory, Func`2 errorRewriter)\n   at Microsoft.Win32.SafeHandles.SafeFileHandle.Open(String path, OpenFlags flags, Int32 mode)\n   at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options)\n   at System.IO.StreamWriter.ValidateArgsAndOpenPath(String path, Boolean append, Encoding encoding, Int32 bufferSize)\n   at System.IO.StreamWriter..ctor(String path)\n   at System.IO.File.WriteAllText(String path, String contents)\n   at Submission#25.<<Initialize>>d__0.MoveNext()\n--- End of stack trace from previous location where exception was thrown ---\n   at Microsoft.CodeAnalysis.Scripting.ScriptExecutionState.RunSubmissionsAsync[TResult](ImmutableArray`1 precedingExecutors, Func`2 currentExecutor, StrongBox`1 exceptionHolderOpt, Func`2 catchExceptionOpt, CancellationToken cancellationToken)",
      "   at Interop.ThrowExceptionForIoErrno(ErrorInfo errorInfo, String path, Boolean isDirectory, Func`2 errorRewriter)",
      "   at Microsoft.Win32.SafeHandles.SafeFileHandle.Open(String path, OpenFlags flags, Int32 mode)",
      "   at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options)",
      "   at System.IO.StreamWriter.ValidateArgsAndOpenPath(String path, Boolean append, Encoding encoding, Int32 bufferSize)",
      "   at System.IO.StreamWriter..ctor(String path)",
      "   at System.IO.File.WriteAllText(String path, String contents)",
      "   at Submission#25.<<Initialize>>d__0.MoveNext()",
      "--- End of stack trace from previous location where exception was thrown ---",
      "   at Microsoft.CodeAnalysis.Scripting.ScriptExecutionState.RunSubmissionsAsync[TResult](ImmutableArray`1 precedingExecutors, Func`2 currentExecutor, StrongBox`1 exceptionHolderOpt, Func`2 catchExceptionOpt, CancellationToken cancellationToken)"
     ]
    }
   ],
   "source": [
    "//Download do Dataset\n",
    "if (!File.Exists(housingPath))\n",
    "{\n",
    "    var contents = new HttpClient()\n",
    "        .GetStringAsync(\"https://www.kaggle.com/saurabh00007/diabetescsv/download/MlgbaDuOXr5nOCKlz2Fn%2Fversions%2Fvv9mZKWiiUiAS9TLG0ss%2Ffiles%2Fdiabetes.csv\").Result;\n",
    "        \n",
    "    File.WriteAllText(diabetesPath, contents);\n",
    "} //  .GetStringAsync(\"https://raw.githubusercontent.com/ageron/handson-ml2/master/datasets/housing/housing.csv\").Result;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Formatador do Dataframe\n",
    "Formatter.Register<DataFrame>((df, writer) =>\n",
    "{\n",
    "    var headers = new List<IHtmlContent>();\n",
    "    headers.Add(th(i(\"index\")));\n",
    "    headers.AddRange(df.Columns.Select(c => (IHtmlContent) th(c.Name)));\n",
    "    var rows = new List<List<IHtmlContent>>();\n",
    "    var take = 10;\n",
    "    for (var i = 0; i < Math.Min(take, df.Rows.Count); i++)\n",
    "    {\n",
    "        var cells = new List<IHtmlContent>();\n",
    "        cells.Add(td(i));\n",
    "        foreach (var obj in df.Rows[i])\n",
    "        {\n",
    "            cells.Add(td(obj));\n",
    "        }\n",
    "        rows.Add(cells);\n",
    "    }\n",
    "\n",
    "    var t = table(\n",
    "        thead(\n",
    "            headers),\n",
    "        tbody(\n",
    "            rows.Select(\n",
    "                r => tr(r))));\n",
    "\n",
    "    writer.Write(t);\n",
    "}, \"text/html\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Análise Exploratória de Dados (EDA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Patient\n",
    "{\n",
    "    [LoadColumn(0)]\n",
    "    public float Id { get; set; }\n",
    "\n",
    "    [LoadColumn(1)]\n",
    "    public float Pregnancies { get; set; }\n",
    "\n",
    "    [LoadColumn(2)]\n",
    "    public float Glucose { get; set; }\n",
    "\n",
    "    [LoadColumn(3)]\n",
    "    public float BloodPressure { get; set; }\n",
    "\n",
    "    [LoadColumn(4)]\n",
    "    public float SkinThickness { get; set; }\n",
    "\n",
    "    [LoadColumn(5)]\n",
    "    public float Insulin { get; set; }\n",
    "\n",
    "    [LoadColumn(6)]\n",
    "    public float BMI { get; set; }\n",
    "\n",
    "    [LoadColumn(7)]\n",
    "    public float DiabetesPedigreeFunction { get; set; }\n",
    "\n",
    "    [LoadColumn(8)]\n",
    "    public float Age { get; set; }\n",
    "\n",
    "    [LoadColumn(9)]\n",
    "    public float Output { get; set; }\n",
    "}\n",
    "\n",
    "public class DiabetesMLPrediction : Patient\n",
    "{\n",
    "    [ColumnName(\"PredictedLabel\")]\n",
    "    public float Prediction { get; set; }\n",
    "\n",
    "    public float Probability { get; set; }\n",
    "\n",
    "    public float[] Score { get; set; }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var context = new MLContext();\n",
    "\n",
    "var loader = context.Data.CreateDatabaseLoader<Patient>();\n",
    "\n",
    "var connectionString = GetDbConnection();\n",
    "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\";\n",
    "var dbSource = new DatabaseSource(SqlClientFactory.Instance, connectionString, sqlCommand);\n",
    "\n",
    "Console.WriteLine(\"Loading data from database...\");\n",
    "\n",
    "var data = loader.Load(dbSource);\n",
    "var set = context.Data.TrainTestSplit(data, testFraction: 0.2);\n",
    "var trainingData = set.TrainSet;\n",
    "var testData = set.TestSet;\n",
    "\n",
    "Console.WriteLine(\"Preparing training operations...\");\n",
    "var pipeline = context.Transforms\n",
    "    .Conversion.MapValueToKey(outputColumnName: \"Label\", inputColumnName: \"Output\")\n",
    "    .Append(context.Transforms.Concatenate(\"Features\", \"Pregnancies\", \"Glucose\", \"BloodPressure\", \"SkinThickness\", \"Insulin\", \"BMI\", \"DiabetesPedigreeFunction\", \"Age\"))\n",
    "    .Append(context.MulticlassClassification.Trainers.OneVersusAll(\n",
    "        context.BinaryClassification.Trainers.AveragedPerceptron(\"Label\", \"Features\", numberOfIterations: 10))\n",
    "    .Append(context.Transforms.Conversion.MapKeyToValue(\"PredictedLabel\")));\n",
    "\n",
    "Console.WriteLine(\"=============== Starting 10 fold cross validation ===============\");\n",
    "var crossValResults = context.MulticlassClassification.CrossValidate(data: trainingData, estimator: pipeline, numberOfFolds: 10, labelColumnName: \"Label\");\n",
    "var metricsInMultipleFolds = crossValResults.Select(r => r.Metrics);\n",
    "var microAccuracyValues = metricsInMultipleFolds.Select(m => m.MicroAccuracy);\n",
    "var microAccuracyAverage = microAccuracyValues.Average();\n",
    "var macroAccuracyValues = metricsInMultipleFolds.Select(m => m.MacroAccuracy);\n",
    "var macroAccuracyAverage = macroAccuracyValues.Average();\n",
    "var logLossValues = metricsInMultipleFolds.Select(m => m.LogLoss);\n",
    "var logLossAverage = logLossValues.Average();\n",
    "var logLossReductionValues = metricsInMultipleFolds.Select(m => m.LogLossReduction);\n",
    "var logLossReductionAverage = logLossReductionValues.Average(); Console.WriteLine($\"*************************************************************************************************************\");\n",
    "Console.WriteLine($\"*       Metrics Multi-class Classification model      \");\n",
    "Console.WriteLine($\"*------------------------------------------------------------------------------------------------------------\");\n",
    "Console.WriteLine($\"*       Average MicroAccuracy:    {microAccuracyAverage:0.###} \");\n",
    "Console.WriteLine($\"*       Average MacroAccuracy:    {macroAccuracyAverage:0.###} \");\n",
    "Console.WriteLine($\"*       Average LogLoss:          {logLossAverage:#.###} \");\n",
    "Console.WriteLine($\"*       Average LogLossReduction: {logLossReductionAverage:#.###} \");\n",
    "Console.WriteLine($\"*************************************************************************************************************\");\n",
    "\n",
    "//Now we need to train the model using below code    \n",
    "Console.WriteLine($\"Training process is starting. {DateTime.Now.ToLongTimeString()}\");\n",
    "var model = pipeline.Fit(trainingData);\n",
    "Console.WriteLine($\"Training process has finished. {DateTime.Now.ToLongTimeString()}\");\n",
    "\n",
    "//\n",
    "\n",
    "var testPatients = context.Data.CreateEnumerable<Patient>(testData, reuseRowObject: true);\n",
    "Console.WriteLine($\"Test Set: {testPatients.Count()} patients\");\n",
    "\n",
    "var predictionEngine = context.Model.CreatePredictionEngine<Patient, DiabetesMLPrediction>(model);\n",
    "\n",
    "var patient = new Patient()\n",
    "{\n",
    "    Age = 50,\n",
    "    BloodPressure = 72,\n",
    "    BMI = 33.6f,\n",
    "    DiabetesPedigreeFunction = 0.627f,\n",
    "    Glucose = 148,\n",
    "    Insulin = 0,\n",
    "    Pregnancies = 6,\n",
    "    SkinThickness = 35,\n",
    "    Id = 0,\n",
    "    Output = 0\n",
    "};\n",
    "\n",
    "var prediction = predictionEngine.Predict(patient);\n",
    "Console.WriteLine($\"Diabetes? {prediction.Output} | Prediction: {(Convert.ToBoolean(prediction.Prediction) ? \"Yes\" : \"No\")} | Probability: {prediction.Probability} \");\n",
    "\n",
    "Console.WriteLine(\"Saving the model\");\n",
    "context.Model.Save(model, trainingData.Schema, \"MLModel.zip\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Criar o MLContext para ser compartilhado entre os objetos de fluxo de trabalho de criação do modelo\n",
    "// Definir uma semente aleatória para resultados repetíveis/determinísticos nos vários treinamentos.\n",
    "MLContext mlContext = new MLContext(seed: 1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Métricas de Avalição do Modelo\n",
    "public static void PrintRegressionMetrics(RegressionMetrics metrics)\n",
    "{\n",
    "    Console.WriteLine($\"*************************************************\");\n",
    "    Console.WriteLine($\"*       Metrics for Regression model      \");\n",
    "    Console.WriteLine($\"*------------------------------------------------\");\n",
    "    Console.WriteLine($\"*       LossFn:        {metrics.LossFunction:0.##}\");\n",
    "    Console.WriteLine($\"*       R2 Score:      {metrics.RSquared:0.##}\");\n",
    "    Console.WriteLine($\"*       Absolute loss: {metrics.MeanAbsoluteError:#.##}\");\n",
    "    Console.WriteLine($\"*       Squared loss:  {metrics.MeanSquaredError:#.##}\");\n",
    "    Console.WriteLine($\"*       RMS loss:      {metrics.RootMeanSquaredError:#.##}\");\n",
    "    Console.WriteLine($\"*       RMS loss:      {metrics.RootMeanSquaredError:#.##}\");\n",
    "    Console.WriteLine($\"*************************************************\");\n",
    "}\n",
    "\n",
    "public static void PrintRegressionFoldsAverageMetrics(IEnumerable<TrainCatalogBase.CrossValidationResult<RegressionMetrics>> crossValidationResults)\n",
    "{\n",
    "    var L1 = crossValidationResults.Select(r => r.Metrics.MeanAbsoluteError);\n",
    "    var L2 = crossValidationResults.Select(r => r.Metrics.MeanSquaredError);\n",
    "    var RMS = crossValidationResults.Select(r => r.Metrics.RootMeanSquaredError);\n",
    "    var lossFunction = crossValidationResults.Select(r => r.Metrics.LossFunction);\n",
    "    var R2 = crossValidationResults.Select(r => r.Metrics.RSquared);\n",
    "    \n",
    "    Console.WriteLine($\"*************************************************************************************************************\");\n",
    "    Console.WriteLine($\"*       Metrics for Regression model      \");\n",
    "    Console.WriteLine($\"*------------------------------------------------------------------------------------------------------------\");\n",
    "    Console.WriteLine($\"*       Average L1 Loss:       {L1.Average():0.###} \");\n",
    "    Console.WriteLine($\"*       Average L2 Loss:       {L2.Average():0.###}  \");\n",
    "    Console.WriteLine($\"*       Average RMS:           {RMS.Average():0.###}  \");\n",
    "    Console.WriteLine($\"*       Average Loss Function: {lossFunction.Average():0.###}  \");\n",
    "    Console.WriteLine($\"*       Average R-squared:     {R2.Average():0.###}  \");    \n",
    "    Console.WriteLine($\"*************************************************************************************************************\");\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [],
   "source": [
    "private static IDataView trainingDataView;\n",
    "private static IDataView testingDataView;\n",
    "\n",
    "//Configuração do carregamento de dados         \n",
    "IDataView fullData = mlContext.Data.LoadFromTextFile<ModelInput>(path: housingPath, hasHeader: true, \n",
    "                                                                         separatorChar: ',', allowQuoting: true, allowSparse: false);\n",
    "\n",
    "// Divide o conjunto de dados em duas partes: TrainingDataset (80%) e TestDataset (20%)\n",
    "DataOperationsCatalog.TrainTestData trainTestData = mlContext.Data.TrainTestSplit(fullData, testFraction: 0.2);\n",
    "trainingDataView = trainTestData.TrainSet;\n",
    "testingDataView = trainTestData.TestSet;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "(3,27): warning CS1701: Assuming assembly reference 'Microsoft.AspNetCore.Html.Abstractions, Version=2.2.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60' used by 'Microsoft.DotNet.Interactive.Formatting' matches identity 'Microsoft.AspNetCore.Html.Abstractions, Version=3.1.7.0, Culture=neutral, PublicKeyToken=adb9793829ddae60' of 'Microsoft.AspNetCore.Html.Abstractions', you may need to supply runtime policy\n",
      "\n"
     ]
    }
   ],
   "source": [
    "// Criar e treinar o modelo\n",
    "// Configuração do processo de Pipeline de transformação de dados \n",
    "var dataProcessPipeline = mlContext.Transforms.Categorical.OneHotEncoding(new[] \n",
    "                                                { new InputOutputColumnPair(\"Ocean_proximity\", \"Ocean_proximity\") })\n",
    "                                                  .Append(mlContext.Transforms.Concatenate(\"Features\", new[] { \"Ocean_proximity\", \n",
    "                                                                                        \"Longitude\", \"Latitude\", \"Housing_median_age\", \n",
    "                                                                                        \"Total_rooms\", \"Total_bedrooms\", \"Population\", \n",
    "                                                                                                        \"Households\", \"Median_income\" })\n",
    "                                                 .AppendCacheCheckpoint(mlContext));\n",
    "// Definir o algoritmo de treinamento\n",
    "var trainer = mlContext.Regression.Trainers.Sdca(labelColumnName: \"Label\", featureColumnName: \"Features\");\n",
    "\n",
    "var trainingPipeline = dataProcessPipeline.Append(trainer);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============== Treinando o modelo ===============\n",
      "=============== Fim do Processo de Treinamento ===============\n"
     ]
    }
   ],
   "source": [
    "Console.WriteLine(\"=============== Treinando o modelo ===============\");\n",
    "\n",
    "var model = trainingPipeline.Fit(trainingDataView);\n",
    "\n",
    "Console.WriteLine(\"=============== Fim do Processo de Treinamento ===============\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===== Avaliando a acurácia do modelo com dados de teste =====\n",
      "*************************************************\n",
      "*       Metrics for Regression model      \n",
      "*------------------------------------------------\n",
      "*       LossFn:        8451832124.8\n",
      "*       R2 Score:      0.37\n",
      "*       Absolute loss: 67978.71\n",
      "*       Squared loss:  8451832146.09\n",
      "*       RMS loss:      91933.85\n",
      "*       RMS loss:      91933.85\n",
      "*************************************************\n"
     ]
    }
   ],
   "source": [
    "// Avalie a precisão do modelo\n",
    "IDataView predictions = model.Transform(testingDataView);\n",
    "Console.WriteLine(\"===== Avaliando a acurácia do modelo com dados de teste =====\");\n",
    "var metrics = mlContext.Regression.Evaluate(data:predictions, labelColumnName:\"Label\", scoreColumnName: \"Score\"); \n",
    "PrintRegressionMetrics(metrics);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============== Salvando o modelo  ===============\n",
      "O Modelo foi salvo em ./HouseModelv2.zip\n"
     ]
    }
   ],
   "source": [
    "// Salvar/persistir o modelo treinado em um arquivo .ZIP\n",
    "Console.WriteLine($\"=============== Salvando o modelo  ===============\");\n",
    "mlContext.Model.Save(model, trainingDataView.Schema, modelPath); \n",
    "Console.WriteLine(\"O Modelo foi salvo em {0}\", modelPath);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============== Previsão para um único caso  ===============\n"
     ]
    }
   ],
   "source": [
    "Console.WriteLine(\"=============== Previsão para um único caso  ===============\");\n",
    "\n",
    "ModelInput sampleData = new ModelInput()\n",
    "{\n",
    "    Longitude = -122.23F,\n",
    "    Latitude = 37.88F,\n",
    "    Housing_median_age = 41F,\n",
    "    Total_rooms = 880F,\n",
    "    Total_bedrooms = 129F,\n",
    "    Population = 322F,\n",
    "    Households = 126F,\n",
    "    Median_income = 8.3252F,\n",
    "    Ocean_proximity = @\"NEAR BAY\",\n",
    "};"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Usando o modelo para fazer predição única - Comparando o valor atual de Median_house_value com o valor previsto de para os dados de amostra de Median_house_value ... \n",
      " \n",
      "\n",
      "Longitude: -122.23\n",
      "Latitude: 37.88\n",
      "Housing_median_age: 41\n",
      "Total_rooms: 880\n",
      "Total_bedrooms: 129\n",
      "Population: 322\n",
      "Households: 126\n",
      "Median_income: 8.3252\n",
      "Ocean_proximity: NEAR BAY\n",
      "\n",
      " \n",
      "O Preço previsto para este tamanho é: 308464.28 \n",
      " \n",
      "\n",
      "=============== Fim do processo ===============\n"
     ]
    }
   ],
   "source": [
    "ITransformer model = mlContext.Model.Load(modelPath, out var modelInputSchema);\n",
    "// Criar um mecanismo de predição relacionado ao modelo treinado carregado\n",
    "var predEngine = mlContext.Model.CreatePredictionEngine <ModelInput, ModelOutput>(model);\n",
    "\n",
    "//Score\n",
    "var resultprediction = predEngine.Predict (sampleData);\n",
    "\n",
    "Console.WriteLine(\"Usando o modelo para fazer predição única - Comparando o valor atual de Median_house_value com o valor previsto de para os dados de amostra de Median_house_value ... \\n \\n\");\n",
    "Console.WriteLine($\"Longitude: {sampleData.Longitude}\");\n",
    "Console.WriteLine($\"Latitude: {sampleData.Latitude}\");\n",
    "Console.WriteLine($\"Housing_median_age: {sampleData.Housing_median_age}\");\n",
    "Console.WriteLine($\"Total_rooms: {sampleData.Total_rooms}\");\n",
    "Console.WriteLine($\"Total_bedrooms: {sampleData.Total_bedrooms}\");\n",
    "Console.WriteLine($\"Population: {sampleData.Population}\");\n",
    "Console.WriteLine($\"Households: {sampleData.Households}\");\n",
    "Console.WriteLine($\"Median_income: {sampleData.Median_income}\");\n",
    "Console.WriteLine($\"Ocean_proximity: {sampleData.Ocean_proximity}\");\n",
    "Console.WriteLine ($\"\\n \\nO Preço previsto para este tamanho é: {resultprediction.Score} \\n \\n\");\n",
    "Console.WriteLine (\"=============== Fim do processo ===============\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fluxo de trabalho de código\n",
    "\n",
    "Neste Artigo  percorremos todas as etapas abaixo\n",
    "<ul>\n",
    "   <li>Coletar e carregar dados de treinamento em um objeto IDataView</li>\n",
    "   <li>Especifique um pipeline de operações para extrair recursos e aplicar um algoritmo de aprendizado de máquina</li>\n",
    "   <li>Treinar um modelo chamando Fit() no pipeline</li>\n",
    "   <li>Avaliar o modelo e iterar para melhorar</li>\n",
    "   <li>Salvar o modelo em um formato binário para uso em um aplicativo</li>\n",
    "   <li>Carregar o modelo de volta para um objeto ITransformer</li>\n",
    "   <li>Fazer previsões chamando CreatePredictionEngine.Predict()</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Fluxo](../shared_content/mldotnet-annotated-workflow.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Em nosso próximo artigo veremos como implantar o modelo criado numa api Web para consumo por outra aplicações."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".NET (C#)",
   "language": "C#",
   "name": ".net-csharp"
  },
  "language_info": {
   "file_extension": ".cs",
   "mimetype": "text/x-csharp",
   "name": "C#",
   "pygments_lexer": "csharp",
   "version": "8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}