ML.net и Python множественная линейная регрессия

Это третий в серии, рассказывающий о различиях в реализации между ML.net и Python для задач машинного обучения. Не волнуйтесь, вы должны быть в состоянии прыгнуть прямо, чтобы прочитать этот пост.

Тем не менее, вот предыдущие посты, если вы хотите посмотреть.

Если вы хотите установить ML.NET и настроить ноутбук .NET, я объясню, как это сделать в этих постах.

Что такое множественная линейная регрессия

Это то же самое, что и простая линейная регрессия, но с гораздо большим количеством переменных.

Кроме того, данные для успешной линейной регрессии должны придерживаться некоторых основных предположений.

Я перечисляю эти предположения в другом Статья Анкет Тем не менее, понимание этого не будет необходимо для сравнения реализации ML.NET и Python. Наши данные можно предположить, чтобы соответствовать требованиям на этот раз Анкет

Данные

Спасибо Super Data Science Team

Этот набор данных и информация о Python взяты из Кирилл Эременко и Хаделин де Понтевз вместе с Super Data Science Team. . Они обеспечивают отличное качество Курс науки о данных на Удеми. Это повторно здесь используется с разрешения.

Эти данные представляют собой кучу разных стартапов. Наша цель – предсказать прибыль стартапа.

Мы можем видеть в качестве независимых переменных, которые у нас есть НИОКР, администрация, маркетинговые расходы и государство, в котором работает стартап. Зависимая переменная – это прибыль.

Множественная линейная регрессия в Python

Попробуйте сами на связующем

Как обычно, мы начинаем с импорта наших библиотек и чтения в данных.

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

dataset = pd.read_csv('50_Startups.csv')
X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, -1].values

Теперь, однако, нам нужно сделать преобразование данных. Столбец состояния не может быть представлен как строка. Вместо этого мы собираемся использовать методы, импортированные из библиотеки Sklearn, чтобы преобразовать его в три столбца, столбец для каждого состояния. Метод, который выполняет большую часть работы здесь, является Onehotencoder . Теперь мы можем представлять эти данные численно.

Вы можете задаться вопросом, почему один столбец со значениями 1, 2 и 3 не используется. Ответ заключается в том, что алгоритм ML затем будет стремиться заказать эти ценности, даже если таким образом нет реального упорядочения состояний. Создание каждого состояния его собственная колонка устраняет эту предвзятость.

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [3])], remainder='passthrough')
X = np.array(ct.fit_transform(X))

Помимо этого небольшого изменения, шаги теперь практически идентичны простой линейной регрессии.

Теперь мы разделились на тренировочные и тестовые наборы.

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

Мы тренируем модель, используя ту же функцию, что и для простой линейной регрессии. Линейная регрессия Функция способна обучать модели для простой и множественной регрессии.

from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)

И мы можем предсказать результаты как нормальные.

y_pred = regressor.predict(X_test)

Давайте посмотрим, каковы были результаты. Вместо того, чтобы составить график данных, мы преобразуем их в два столбца. Первый столбец будет прогнозируемой прибылью, а вторая будет фактической прибылью.

np.set_printoptions(precision=2)
print(np.concatenate((y_pred.reshape(len(y_pred),1), y_test.reshape(len(y_test),1)),1))

Некоторые из прогнозов довольно хороши, в то время как другие просто в порядке. Тем не менее, учитывая небольшую выборку, это довольно хороший результат для модели множественной линейной регрессии. Приятно, что существует несколько дополнительных шагов для обучения этой модели, несмотря на то, что данные гораздо сложнее по сравнению с простой линейной регрессией.

На самом деле, давайте рассчитывать квадратное значение R, так как это будет актуально, когда мы смотрим на ML.NET. Квадратное значение R – это показатель, которую мы можем использовать для расчета точности алгоритма тренера.

from sklearn.metrics import r2_score
print(r2_score(y_test, y_pred))

Оценка для этой регрессии составляет 0,9347068473282515, что довольно хорошо, учитывая, что у нас есть небольшой набор данных. Цель балла Rsquared должен состоять в том, чтобы приблизиться к 1, насколько это возможно. Оценки в.

Множественная линейная регрессия в ml.net

Попробуйте сами на связующем

Сразу же мы начинаем видеть некоторые серьезные различия. Во-первых, эксперимент по обнаружению алгоритма из инструмента командной строки показывает некоторые менее, чем обнадеживающие результаты для предлагаемой модели.

Мы можем получить этот вывод, запустив инструмент командной строки против нашего набора данных с помощью этой команды.

Регрессия MLnet-dataset. \ 50_startups.csv-

Вы можете прочитать больше о инструменте командной строки здесь.

Столбцы не помечены на этом этапе вывода, но они являются algorithmname, Rsquared, Absolute-Loss, потери квадрата, потери среднего уровня, продолжительность, итерация. Вы можете прочитать о том, как интерпретировать эти результаты из Гид Microsoft.

Но здесь мы получаем отрицательные значения для наших Rsquared значений, и другие наши метрики одинаково плохие. Так что все уже не эквивалентно Python. Тем не менее, эксперимент по командной строке по-прежнему сужался до двух лучших алгоритмов обучения, используемых для регрессии.

SDCareGression
FastTreeRession

Кроме того, напомним, что в Python мы использовали Onehotencoder, чтобы преобразовать столбец состояния так, чтобы его было легче использовать алгоритмом обучения. На этом этапе неясно, сделал ли ML.NET такое же преобразование – хотя судя по результатам анализа, он, как это могло бы, не было.

Давайте запустим быстрый и грязный тест, чтобы увидеть, является ли этот столбец причиной наших плохих данных, удалив столбец состояния и снова запустив тест командной строки.

Мы видим улучшение в том, что отрицательные числа меньше, но все же не тот вид вывода, который мы хотели бы.

Это указывает на то, что набор данных либо слишком мал для инструмента командной строки MLNet для создания, либо существует какая-то другая проблема с данными, которые приводят к тому, что эксперимент командной строки MLNet не лучше, чем предположение, поскольку он соблюдает прогнозы на основе на основе на основе на основе на основе на основе на основе на основе на основе на основе на основе на основе на основе на основе прогнозов на основе прогнозов на основе прогнозов на основе прогнозов на основе прогнозов на основе прогнозов на основе прогнозов на основе прогнозов на основе эксперимента. эти данные.

Но давайте прощаем инструмент командной строки и продолжим, чтобы увидеть, лучше ли реализация. В конце концов, мы взяли наш счет RSquared для Python после того, как закончили полную реализацию. Я хотел бы увидеть паритет с ними Python Sklearn Линейная регрессия функция тренера.

Некоторые из этих шагов точно такие же, как простая линейная регрессия, охватываемая в предыдущем сообщении в блоге.

Во -первых, мы загружаем несколько пакетов Nuget и настроим наши операторы. Вы заметите, что я тоже тяну в пакет Nuget для регрессии FastTree – Это потому, что я хочу экспериментировать между тренерами по регрессии, когда мы установим наши наборы тестирования и обучения.

// ML.NET Nuget packages installation
#r "nuget:Microsoft.ML,1.5.0"
#r "nuget:Microsoft.ML.Mkl.Components,1.5.0"
#r "nuget:Microsoft.ML.FastTree,1.5.0"
//Install XPlot package
#r "nuget:XPlot.Plotly,2.0.0"    
using Microsoft.ML;    
using Microsoft.ML.Data;
using Microsoft.ML.Trainers.FastTree;
using XPlot.Plotly;
using System;
using System.Linq;

Во -вторых, мы настроили наши классы для ввода и вывода. Счет Свойство для вывода является прогнозируемой прибылью.

public class ModelInput
{
    [ColumnName("R&D Spend"), LoadColumn(0)]
    public float R_D_Spend { get; set; }

    [ColumnName("Administration"), LoadColumn(1)]
    public float Administration { get; set; }

    [ColumnName("Marketing Spend"), LoadColumn(2)]
    public float Marketing_Spend { get; set; }

    [ColumnName("State"), LoadColumn(3)]
    public string State { get; set; }

    [ColumnName("Profit"), LoadColumn(4)]
    public float Profit { get; set; }

}

public class ModelOutput
{
    public float Score { get; set; }
}

В -третьих, мы создаем экземпляр MLContext и читаем в .csv Файл для создания наших наборов тестирования и обучения.

var mlContext = new MLContext(seed: 1);

IDataView trainingDataView = mlContext.Data.LoadFromTextFile(
    path: @"./50_Startups.csv",
    hasHeader: true,
    separatorChar: ',',
    allowQuoting: true,
    allowSparse: false);

var split = mlContext.Data.TrainTestSplit(trainingDataView, testFraction: 0.2);

Эти первые три шага не сильно меняются помимо свойств в моделях. Но теперь мы начинаем видеть некоторые интересные различия.

var dataProcessPipeline = mlContext.Transforms.Categorical.OneHotEncoding(new[] { new InputOutputColumnPair("State", "State") })
                                      .Append(mlContext.Transforms.Concatenate("Features", new[] { "State", "R&D Spend", "Administration", "Marketing Spend" }));

Ах! Как и Python, мы используем инструмент под названием Onehotencoding Анкет Кроме того, так же, как Python он преобразует кодированные столбцы в несколько столбцов. Однако, в отличие от Python, сложнее проверить данные, чтобы увидеть, что они сделали.

Небольшое обсуждение Onehotencoding в ml.net

Microsoft предоставляет способ осматривать преобразованные данные, которые они проходят в своем Обсуждение функции OneHotencoding.

Задолго до этого вы должны преобразовать свою модель обратно в DataView, используя метод преобразования. Затем вы можете использовать MLCONTEXT для преобразования IdataView в Ienumerable и осмотреть его, как вы могли бы.

Вот полезный пример из документации Microsoft.

var mlContext = new MLContext();

// Create a small dataset as an IEnumerable.
var samples = new[]
{
    new DataPoint {Education = "0-5yrs", ZipCode = "98005"},
    new DataPoint {Education = "0-5yrs", ZipCode = "98052"},
    new DataPoint {Education = "6-11yrs", ZipCode = "98005"},
    new DataPoint {Education = "6-11yrs", ZipCode = "98052"},
    new DataPoint {Education = "11-15yrs", ZipCode = "98005"}
};

// Convert training data to IDataView.
IDataView data = mlContext.Data.LoadFromEnumerable(samples);

// Multi column example: A pipeline for one hot encoding two columns
// 'Education' and 'ZipCode'.
var multiColumnKeyPipeline =
    mlContext.Transforms.Categorical.OneHotEncoding(
        new[]
        {
            new InputOutputColumnPair("Education"),
            new InputOutputColumnPair("ZipCode")
        });

// Fit and Transform data.
IDataView transformedData =
    multiColumnKeyPipeline.Fit(data).Transform(data);

var convertedData =
    mlContext.Data.CreateEnumerable(transformedData,
        true);

Console.WriteLine(
    "One Hot Encoding of two columns 'Education' and 'ZipCode'.");

// One Hot Encoding of two columns 'Education' and 'ZipCode'.

foreach (TransformedData item in convertedData)
    Console.WriteLine("{0}\t\t\t{1}", string.Join(" ", item.Education),
        string.Join(" ", item.ZipCode));

// 1 0 0 1 0
// 1 0 0 0 1
// 0 1 0 1 0
// 0 1 0 0 1
// 0 0 1 1 0

Для просмотра этих данных в C#гораздо больше работы, но есть и мало причин, по которым вы хотите осмотреть эти данные в сценарии производства.

Также хорошо, что они включают в себя пример, такой как ZipCode. Думая о том, как это Onehotencoding Работы и Zipcodes – вы можете представить колонку с сотнями уникальных Zipcodes. Это означает, что Одна горячая кодировка генерирует сотни столбцов, по одному для каждого почтового индекса?

Да. Это было бы. Тем не менее, вы можете настроить преобразование, чтобы вместо этого сгенерировать кодированный ключ столбец, который будет кодировать данные в один столбец (и, следовательно, принять недостатки этого преобразования, потенциально менее точную модель).

В случае ZipCode, когда есть сотни уникальных записей, зачем вам включить эти данные? Может ли вам быть лучше без этого? Или вы не могли бы превратить его в нечто менее гранулированное, например, штат, провинция, графство, Шир или что у вас есть.

ML.NET и Python предоставляют замечательные инструменты для обработки данных, таких как этот, но в конечном итоге мы все еще должны принимать разумные решения о каждой точке данных.

Давайте перейдем к обучению нашей модели!

Я несколько раз запускал инструмент командной строки MLNet, и, в конечном счете, у тренера Fasttree регрессии постоянно был наименее худший результат RSQUERD. Он достиг Rsquared Parp в -800. Безумный, но все же лучше, чем раньше. В сгенерированном проекте мы видим, как добавляется регрессионный тренер.

var trainer = mlContext.Regression.Trainers.FastTree(new FastTreeRegressionTrainer.Options() { NumberOfLeaves = 2, MinimumExampleCountPerLeaf = 10, NumberOfTrees = 100, LearningRate = 0.06297909f, Shrinkage = 0.0986204f, LabelColumnName = "Profit", FeatureColumnName = "Features" });

var trainingPipeline = dataProcessPipeline.Append(trainer);

Затем мы можем тренировать нашу модель.

var trainingPipeline = dataProcessPipeline.Append(trainer);

И теперь мы можем выполнить оценку тренера. Что сейчас за счет Rsquared? Имейте в виду, Rsquard – не единственный показатель, который мы можем оценить, но он все еще действительно хороший для определения точности.

Итак, давайте посмотрим. Вот код для создания анализа.

Console.WriteLine("=============== Cross-validating to get model's accuracy metrics ===============");
var crossValidationResults = mlContext.Regression.CrossValidate(split.TrainSet, trainingPipeline, numberOfFolds: 5, labelColumnName: "Profit");
var L1 = crossValidationResults.Select(r => r.Metrics.MeanAbsoluteError);
var L2 = crossValidationResults.Select(r => r.Metrics.MeanSquaredError);
var RMS = crossValidationResults.Select(r => r.Metrics.RootMeanSquaredError);
var lossFunction = crossValidationResults.Select(r => r.Metrics.LossFunction);
var R2 = crossValidationResults.Select(r => r.Metrics.RSquared);

Console.WriteLine($" *************************************************************************************************************");
Console.WriteLine($"* Metrics for Regression model ");
Console.WriteLine($"*------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"* Average L1 Loss: {L1.Average():0.###} ");
Console.WriteLine($"* Average L2 Loss: {L2.Average():0.###} ");
Console.WriteLine($"* Average RMS: {RMS.Average():0.###} ");
Console.WriteLine($"* Average Loss Function: {lossFunction.Average():0.###} ");
Console.WriteLine($"* Average R-squared: {R2.Average():0.###} ");
Console.WriteLine($" *************************************************************************************************************");

И вот результат.

Эти метрики по -прежнему действительно ужасны. Если вы на самом деле делаете прогнозы на тестовом наборе, вы увидите, что на данный момент он не лучше, чем дикое предположение. Это даже не близко к фактической прибыли.

Однако мы видим что -то обнадеживающее. Фактическая реализация действительно улучшает оценку. Rsquared теперь всего -2,853.

Кажется, в определенный момент мы не можем доверять нашим экспериментам по командной строке MLNet.

После некоторых ручных экспериментов с некоторыми тренерами по регрессии я смог это генерировать:

var dataProcessPipeline = mlContext.Transforms.Categorical.OneHotEncoding(new[] { new InputOutputColumnPair("State", "State") })
                                      .Append(mlContext.Transforms.Concatenate("Features", new[] { "State", "R&D Spend", "Administration", "Marketing Spend" }));

var trainer = mlContext.Regression.Trainers.Ols(labelColumnName: "Profit", featureColumnName: "Features");
var trainingPipeline = dataProcessPipeline.Append(trainer);

Это верно, старый добрый OLS Тренер по регрессии снова вернулся. Он отлично подходит для простой линейной регрессии и продолжает работать достаточно хорошо для примера множественной линейной регрессии.

Он оценил это:

У нас есть Rsquared, составленный 0,909! Это более или менее нормально Наверное! Это все еще не так хорошо, как rsquared от Линейная регрессия Алгоритм от Sklearn, но мы намного ближе.

Теперь, если вы сравниваете прогнозируемую прибыль с фактической прибылью, как это –

var predEngine = mlContext.Model.CreatePredictionEngine(model);
var testSet = mlContext.Data.CreateEnumerable(split.TestSet, reuseRowObject:false);
foreach (var ts in testSet) 
{
    var testInput = new ModelInput() 
    {
        State = ts.State,
        Marketing_Spend = ts.Marketing_Spend,
        R_D_Spend = ts.R_D_Spend,
        Administration = ts.Administration,
        Profit = 0.0F
    };
    var prediction = predEngine.Predict(testInput).Score;
    var actual = ts.Profit;
    Console.WriteLine($"Prediction: {prediction}, Actual: {actual}");
}

Мы видим это –

Неплохо! Довольно близко в некоторых случаях! Это довольно справедливый прогноз потенциальной прибыли.

Мысли

Было бы легко и, возможно, точно, полагать, что Python – лучший инструмент для этой задачи.

Это вводит в заблуждение, потому что шаги Python поступают из курса Udemy. Данные и процесс были адаптированы, чтобы хорошо работать с этой экосистемой.

Что мы на самом деле здесь видим?

ML.NET все еще может использовать эти данные и создавать прогнозы, которые были сопоставимы с прогнозами Python. Кроме того, инструмент с ML.NET поставил меня на путь, по которому я мог бы выяснить для себя, какой алгоритм обучения использовать. Инструмент командной строки не передал мне ответы сразу же, как это было с простой линейной регрессией – но он поставил меня на путь, чтобы понять это.

Тем не менее, простота и простота использования от Python не может быть опровергнута. В Sklearn’s Python мы не охотимся на алгоритм обучения линейной регрессии, есть только один: LinearRegression () Анкет Параметры для этой функции задокументированы и интуитивно понятны.

С ML.NET мне напоминают об игре -карликовой крепости. Крепость карлика хорошо известна своей крутой кривой обучения, но многие игроки находят процесс обучения веселым и полезным. Значение есть, скрыто при пробной и ошибках. Успех достигнут после серии веселых испытаний и неудач.

Также с ML.net мы также уходим с более глубоким пониманием того, что происходит под капюшоном. Поскольку мы продолжаем использовать его, мы видим возможности для настройки и изменения процесса для получения лучших результатов.

Библиотеки Python сначала передают нам успех и позволяют нам глубоко учиться позже.

С точки зрения бизнеса Python – явный фаворит, по крайней мере, в краткосрочной перспективе. Ценность бизнеса будет успешными прогнозами из процесса, созданного как можно дешевле. Тем не менее, в долгосрочной перспективе бизнес выиграет от безопасности типа и получению более легкого обслуживания.

Мы посмотрим, как ML.net работает рядом с Python в моем следующем посте, который будет смотреть на полиномиальную регрессию.

Оригинал: “https://dev.to/robotoptimist/ml-net-and-python-multiple-linear-regression-1gpp”