Градиентный спуск в Scikit Python

В этом уроке по Python мы узнаем, как Scikit изучает градиентный спуск в Python, а также рассмотрим различные примеры, связанные с градиентным спуском.

• Градиентный спуск является основой машинного обучения и используется при обучении модели. Он также сочетается со всеми алгоритмами и легко понятен.
• Обучение градиентному спуску в Scikit — очень простой и эффективный подход для регрессора и классификатора.
• Он также применялся к крупномасштабным задачам и задачам машинного обучения, а также имеет опыт классификации текста и обработки естественного языка.
• В scikit изучается градиентный спуск, градиент потерь угадывается для каждой выборки за раз, и после этого наша модель обновляется.

В следующем коде мы импортируем некоторые функции для расчета потерь, гипотез, а также расчета градиента.

• hypothesis = num.dot(X, тета) используется для расчета гипотез.
• loss = hypothesis – Y используется для расчета потерь.
• cst = num.sum(loss**2)/(2*a) используется для расчета стоимости.
• theta = theta – alpha * gradient используется для обновления параметра тета.
• Y[i] =(i + смещение) + rand.uniform(0, 2) * дисперсия используется в качестве целевой переменной.
• X,Y = genData(90, 20, 9) используется для генерации 90 точек на основе дисперсий 20 и 10 в качестве небольшого количества шума.
• print (theta) используется для печати значения теты.

import numpy as num
import random as rand


def gradientDescent(X, Y, theta, alpha, a, numIterations):
    Xtrans = X.transpose()
    for i in range(0, numIterations):
        hypothesis = num.dot(X, theta)
        loss = hypothesis - Y
 

        cst = num.sum(loss ** 2) /(2 * a)
        print("Iteration %d | Cost: %f" %(i, cst))
        gradient = num.dot(Xtrans, loss) / a
        theta = theta - alpha * gradient
    return theta


def genData(numPoints, bias, variance):
    X = num.zeros(shape=(numPoints, 3))
    Y = num.zeros(shape=numPoints)
    # basically a straight line
    for i in range(0, numPoints):
        X[i][0] = 2
        X[i][1] = i
        Y[i] =(i + bias) + rand.uniform(0, 2) * variance
    return X, Y
X,Y = genData(90, 20, 9)
a, b = num.shape(X)
numIterations= 10000
alpha = 0.0004
theta = num.ones(b)
theta = gradientDescent(X,Y, theta, alpha,a, numIterations)
print(theta)

Выход:

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

• Линия регрессии
• Классификатор стохастического градиентного спуска
• Ррегрессия стохастического градиентного спуска
• Пакетный градиентный спуск
• Градиентный спуск minibatch
• Градиентный спуск логистической регрессии
• Линейная регрессия (Learning)

Линия регрессии

В этом разделе мы узнаем о том, как Scikit изучает регрессию градиентного спуска в Python.

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

В следующем коде мы импортируем некоторые библиотеки, на основе которых мы прогнозируем наиболее подходящую линию регрессии.

• self.X = X используется для определения метода класса.
• Функция y_pred = self.predict() используется для прогнозирования модели.
• self.a[0] = self.a[0] –(learningrate *((1/b) * np.sum(y_pred – y))) используется для обновления коэффициента модели.
• J =(1/2*b) *(np.sum(y_pred – self.y)**2) используется для расчета стоимости модели.
• f = plt.figure(fig) используется для построения фигуры на графике.
• regr.plot_best_fit(y_pred, «Начальная линия наилучшего соответствия») используется для построения линии наилучшего соответствия.
• plot.plot(range(iterations),costs,color=’r’) используется для проверки уменьшения функции стоимости.
• regr.predict([i for i in range(10)]) используется для прогнозирования с использованием регрессора.

import numpy as num
import matplotlib.pyplot as plot
 
class Linear_Regression:
    def __init__(self, X, y):
        self.X = X
        self.y = y
        self.a = [0, 0]
     
    def update_coeffs(self, learningrate):
        y_pred = self.predict()
        y = self.y
        b = len(y)
        self.a[0] = self.a[0] -(learningrate *((1/b) *
                                np.sum(y_pred - y)))
 
        self.a[1] = self.a[1] -(learningrate *((1/b) *
                                np.sum((y_pred - y) * self.X)))
 
    def predict(self, X=[]):
        y_pred = np.array([])
        if not X: X = self.X
        a = self.a
        for x in X:
            y_pred = np.append(y_pred, a[0] +(a[1] * x))
 
        return y_pred
     
    def get_current_accuracy(self, y_pred):
        t, e = y_pred, self.y
        s = len(y_pred)
        return 1-sum(
            [
                abs(t[i]-e[i])/e[i]
                for i in range(s)
                if e[i] != 0]
        )/s

 
    def compute_cost(self, y_pred):
        b = len(self.y)
        J =(1 / 2*b) *(np.sum(y_pred - self.y)**2)
        return J
 
    def plot_best_fit(self, y_pred, fig):
                f = plt.figure(fig)
                plot.scatter(self.X, self.y, color='r')
                plot.plot(self.X, y_pred, color='y')
                f.show()
 
 
def main():
    X = np.array([i for i in range(11)])
    y = np.array([2*i for i in range(11)])
 
    regr = Linear_Regression(X, y)
 
    iterations = 0
    steps = 90
    learningrate = 0.01
    costs = []
   
    y_pred = regr.predict()
    regr.plot_best_fit(y_pred, 'Initial best fit line')
     
 
    while 1:
        y_pred = regr.predict()
        cst = regr.compute_cost(y_pred)
        costs.append(cst)
        regr.update_coeffs(learningrate)
         
        iterations += 1
        if iterations % steps == 0:
            print(iterations, "epochs elapsed")
            print("current accuracy is :",
                regr.get_current_accuracy(y_pred))
            break
 
    #final best-fit line
    regr.plot_best_fit(y_pred, 'Final Best Fit Line')
 
    h = plot.figure('Verification')
    plot.plot(range(iterations), costs, color='r')
    h.show()
 
    regr.predict([i for i in range(10)])
 
if __name__ == '__main__':
    main()

Выход:

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

Классификатор стохастического градиентного спуска

В этом разделе мы узнаем о том, как Scikit изучает работу классификатора стохастического градиентного спуска в Python.

Scikit изучает классификатор стохастического градиентного спуска — это процесс поиска значения коэффициента функции, который может уменьшить функцию стоимости.

В следующем коде мы импортируем SDGClassifier из sklearn.linear_model, с помощью которого мы сможем легко понять каждый алгоритм.

• x = [[1., 1.], [2., 2.]] используется для хранения обучающей выборки.
• y = [1, 2] используется для хранения целевой выборки.
• classifier.fit(x, y) используется для соответствия классификатору.
• classifier.predict([[3., 3.]]) используется для прогнозирования классификатора.
• classifier.coef_ используется для получения коэффициента классификатора, содержащего параметры модели.

from sklearn.linear_model import SGDClassifier
x = [[1., 1.], [2., 2.]]
y = [1, 2]
classifier = SGDClassifier(loss="hinge", penalty="l2", max_iter=7)
classifier.fit(x, y)
classifier.predict([[3., 3.]])
classifier.coef_

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что коэффициент классификатора выведен на экран.

Ррегрессия стохастического градиентного спуска

В этом разделе мы узнаем о том, как регрессия стохастического градиентного спуска Scikit работает в Python.

Scikit изучает регрессию стохастического градиентного спуска, вычисляет функцию стоимости и поддерживает функцию потерь.

В следующем коде мы импортируем SGCRegressor из sklearn.linear_model, с помощью которого мы сможем рассчитать стоимость функции, а также поддерживать различные функции журнала.

• range = num.random.RandomState(0) используется для создания случайной функции.
• y = range.randn(nsamples) используется для хранения целевой выборки.
• x = range.randn(nsamples, nfeatures) используется для хранения обучающей выборки.
• regressor = make_pipeline(StandardScaler(),SGDRegressor(max_iter=100, tol=1e-3)) Конвейер используется в качестве настройки с функцией подгонки и прогнозирования.
• regressor.fit(x, y) используется для подгонки модели.

import numpy as num
from sklearn.linear_model import SGDRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
nsamples, nfeatures = 12,7
range = num.random.RandomState(0)
y = range.randn(nsamples)
x = range.randn(nsamples, nfeatures)
#Always scale the input.The most convenient way to use a pipeline.
regressor = make_pipeline(StandardScaler(),
                          SGDRegressor(max_iter=100, tol=1e-3))
regressor.fit(x, y)

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что функция регрессора выведена на экран.

Пакетный градиентный спуск

В этом разделе мы узнаем о том, как Scikit изучает пакетный градиентный спуск в Python.

• Градиентный спуск — это процесс, в котором учитывается значение параметра функции, которое минимизирует стоимость функции.
• При пакетном градиентном спуске на каждом этапе расчета градиента используется весь набор данных. Он также легко создает обновления внутри модели.

В следующем коде мы импортируем make_reгрессию из sklearn.datasets, с помощью которого работает пакетный градиентный спуск.

• s = X.shape[0] используется как количество выборок.
• потеря = гипотеза – Y используется для расчета потерь.
• J = num.sum(loss ** 2) /(2 * s) используется для расчета стоимости.
• theta = theta – alpha * gradient используется для обновления модели.
• X = num.c_[ num.ones(s), X] используется для вставки значений в столбцы.
• Y_predict = theta[0] + theta[1]*X используется для прогнозирования значений.
• pylab.plot(X[:,1],Y,’r’) используется для построения графика.

import numpy as num
import random as rand
from sklearn.datasets import make_regression 
import pylab
from scipy import stats

def gradient_descent_2(alpha, X, Y, numIterations):
    s = X.shape[0]
    theta = num.ones(2)
    X_transpose = X.transpose()
    for iter in range(0, numIterations):
        hypothesis = num.dot(X, theta)
        loss = hypothesis - Y
        J = num.sum(loss ** 2) /(2 * s)  
        print("iter %s | J: %.3f" %(iter, J))    
        gradient = np.dot(X_transpose, loss) / s         
        theta = theta - alpha * gradient  
    return theta

if __name__ == '__main__':

    X, Y = make_regression(n_samples=100, n_features=1, n_informative=1, 
                        random_state=0, noise=35) 
    s, q = num.shape(X)
    X = num.c_[ num.ones(s), X] # insert column
    alpha = 0.01 # learning rate
    theta = gradient_descent_2(alpha, X, Y, 1000)

    for i in range(X.shape[1]):
        Y_predict = theta[0] + theta[1]*X 
    pylab.plot(X[:,1],Y,'r')
    pylab.plot(X,Y_predict,'b-')
    pylab.show()

Выход:

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

Градиентный спуск minibatch

В этом разделе мы узнаем о том, как Scikit изучает работу мини-пакетного градиентного спуска в Python.

• Scikit изучает мини-пакетный градиентный спуск — это альтернатива градиентному спуску. Он разбивает большой набор данных на небольшие пакеты и вычисляет ошибку модели.
• Мини-пакетный градиентный спуск позволяет легко и быстро обновлять параметры. Если партия большая, менее шумно обновлять модель.

В следующем коде мы импортируем несколько библиотек, из которых сможем построить мини-график градиентного спуска.

• data = num.random.multivariate_normal(mean, cov, 8000) используется для создания данных.
• plot.scatter(data[:600, 0], data[:600, 1], маркер = ‘.’) используется для построения графика или визуализации данных.
• data = num.hstack((num.ones((data.shape[0], 2)), data)) используется для укладки последовательности входного массива по столбцам.
• X_train = data[:split, :-1] используется для разделения набора данных на данные поезда.
• X_test = data[split:, :-1] используется для разделения набора данных на тестовые данные.
• print(«Количество обучающего набора = % d»%(X_train.shape[0])) используется для печати номера обучающего набора данных.
• print(«Количество набора тестовых данных = % d»%(X_test.shape[0])) используется для печати номера набора тестовых данных.

import numpy as num
import matplotlib.pyplot as plot
  

mean = num.array([6.0, 7.0])
cov = num.array([[2.0, 0.97], [0.97, 1.3]])
data = num.random.multivariate_normal(mean, cov, 8000)
  

plot.scatter(data[:600, 0], data[:600, 1], marker = '.')
plot.show()
  

data = num.hstack((num.ones((data.shape[0], 2)), data))
  
split_factor = 0.95
split = int(split_factor * data.shape[0])
  
X_train = data[:split, :-1]
y_train = data[:split, -1].reshape((-1, 1))
X_test = data[split:, :-1]
y_test = data[split:, -1].reshape((-1, 1))
  
print("Number of training set = % d"%(X_train.shape[0]))
print("Number of testing set = % d"%(X_test.shape[0]))

Выход:

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

Градиентный спуск логистической регрессии

В этом разделе мы узнаем о том, как Scikit изучает градиентный спуск логистической регрессии в Python.

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

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

• data = pds.read_csv(“dataa.csv”) используется для загрузки набора данных.
• plot.scatter(data[‘Age’], data[‘Purchased’]) используется для построения графика или визуализации набора данных.
• X_train, X_test, y_train, y_test = train_test_split(data[‘Age’], data[‘Purchased’], test_size=0,20) используется для разделения набора данных на набор поездов и набор тестов.
• y_pred = предсказать(X, b1, b2) используется для прогнозирования модели.
• d_b1 = -2 * sum((Y – y_pred) * y_pred *(1 – y_pred)) используется для получения потерь по отношению к b1.
• d_b2 = -2 * sum(X *(Y – y_pred) * y_pred *(1 – y_pred)) используется для расчета потерь по отношению к b2.
• b0, b1 = логистическая_регрессия(X_train, y_train) используется для обучения модели.
• y_pred = Predict(X_test_norm, b0, b1) используется для прогнозирования.
• plot.scatter(X_test, y_pred, c=»red») используется для построения графика.
• print(f»Accuracy = {accuracy / len(y_pred)}») используется для печати точности.

import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from math import exp
plot.rcParams["figure.figsize"] =(12, 8)

data = pds.read_csv("dataa.csv")
data.head()

plot.scatter(data['Age'], data['Purchased'])
plot.show()

X_train, X_test, y_train, y_test = train_test_split(data['Age'], data['Purchased'], test_size=0.20)

def normalize(X):
    return X - X.mean()

# Method to make predictions
def predict(X, b1, b2):
    return num.array([1 /(1 + exp(-1*b1 + -1*b2*x)) for x in X])

def logistic_regression(X, Y):

    X = normalize(X)

    # Initializing variables
    b1 = 0
    b2 = 0
    l = 0.001
    epochs = 350

    for epoch in range(epochs):
        y_pred = predict(X, b1, b2)
        d_b1 = -2 * sum((Y - y_pred) * y_pred *(1 - y_pred))  
        d_b2 = -2 * sum(X *(Y - y_pred) * y_pred *(1 - y_pred))  
        # Update b1 and b2
        b1 = b1 - l * d_b1
        b2 = b2 - l * d_b2
    
    return b0, b1
b0, b1 = logistic_regression(X_train, y_train)

X_test_norm = normalize(X_test)
y_pred = predict(X_test_norm, b0, b1)
y_pred = [1 if p >= 0.7 else 0 for p in y_pred]

plot.clf()
plot.scatter(X_test, y_test)
plot.scatter(X_test, y_pred, c="red")
plot.show()

accuracy = 0
for i in range(len(y_pred)):
    if y_pred[i] == y_test.iloc[i]:
        accuracy += 1
print(f"Accuracy = {accuracy / len(y_pred)}")

Выход:

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

Линейная регрессия (Learning)

В этом разделе мы узнаем о том, как линейная регрессия градиентной регрессии scikit Learning работает в Python.

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

В следующем коде мы импортируем numpy как num, чтобы найти модель градиентного спуска линейной регрессии.

• a = 0 — это точка пересечения линии.
• m = 7 – наклон линии.
• num.random.seed(45) используется для генерации случайных чисел.
• classifier.fit_model(x, y) используется для соответствия модели.
• plot.plot(x, classifier.predict_model(x)) используется для построения графика.
• plot.title(«Линейная регрессия градиентного спуска») используется для присвоения заголовка графику.

import numpy as num

class GradientDescentLinearRegression:
    def __init__(self, learning_rate=0.02, iterations=1000):
        self.learning_rate, self.iterations = learning_rate, iterations
    
    def fit_model(self, x, y):
        a = 0
        m = 7
        n = x.shape[0]
        for _ in range(self.iterations):
            a_gradient = -2 * num.sum(y - m*x + a) / n
            m_gradient = -2 * num.sum(x*(y -(m*x + a))) / n
            a = a +(self.learning_rate * a_gradient)
            m = m -(self.learning_rate * m_gradient)
        self.m, self.a = m, a
        
    def predict_model(self, X):
        return self.m*X + self.a
num.random.seed(45)
x = num.array(sorted(list(range(5))*20)) + num.random.normal(size=100, scale=0.10)
y = num.array(sorted(list(range(5))*20)) + num.random.normal(size=100, scale=0.20)

classifier = GradientDescentLinearRegression()
classifier.fit_model(x, y)

import matplotlib.pyplot as polt

plot.scatter(x, y, color='red')
plot.plot(x, classifier.predict_model(x))
plot.title("Gradient Descent Linear Regression")

Выход:

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