Scikit Learning Nonlinear (нелинейные процессы) в Python

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

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

  • x = num.sort(5 * num.random.rand(42, 1), axis=0) используется для генерации тех же данных.
  • y[::5] += 3 *(0,5 – num.random.rand(9)) используется для добавления шума к целям.
  • svrrbf = SVR(kernel=»rbf», C=100, gamma=0,1, epsilon=0,1) используется в регрессионной модели.
  • lw = 2 используется для просмотра результата.
  • fig, axes =plot.subplots(nrows=1, ncols=3, figsize=(15, 10),sharey=True) используется для построения фигуры и оси на экране.
  • axes[ix].plot(x,svr.fit(x,y).predict(x),color=model_color[ix],lw=lw,label{}model».format(kernel_label[ix]),) используется для построения оси на экране.
  • axes[ix].scatter(x[svr.support_],y[svr.support_],facecolor=”none”,edgecolor=model_color[ix],s=50,label=”{} поддерживающие векторы”.format(kernel_label [ix]),) используется для построения диаграммы рассеяния на экране.
  • fig.text(0.5, 0.04, «data», ha=»center», va=»center») используется для преобразования текста в рисунок.
import numpy as num
from sklearn.svm import SVR
import matplotlib.pyplot as plot

x = num.sort(5 * num.random.rand(42, 1), axis=0)
y = num.sin(x).ravel()
y[::5] += 3 *(0.5 - num.random.rand(9))

svrrbf = SVR(kernel="rbf", C=100, gamma=0.1, epsilon=0.1)

lw = 2

svrs = [svrrbf]
kernel_label = ["RBF"]
model_color = ["m"]

fig, axes = plot.subplots(nrows=1, ncols=3, figsize=(15, 10), sharey=True)
for ix, svr in enumerate(svrs):
    axes[ix].plot(
        x,
        svr.fit(x, y).predict(x),
        color=model_color[ix],
        lw=lw,
        label="{} model".format(kernel_label[ix]),
    )
    axes[ix].scatter(
        x[svr.support_],
        y[svr.support_],
        facecolor="none",
        edgecolor=model_color[ix],
        s=50,
        label="{} support vectors".format(kernel_label[ix]),
    )
    axes[ix].scatter(
        x[num.setdiff1d(num.arange(len(x)), svr.support_)],
        y[num.setdiff1d(num.arange(len(x)), svr.support_)],
        facecolor="none",
        edgecolor="r",
        s=50,
        label="other training data",
    )
    
fig.text(0.5, 0.04, "data", ha="center", va="center")
fig.text(0.06, 0.5, "target", ha="center", va="center", rotation="vertical")
plot.show()

Выход:

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

Изучение нелинейности

Содержание

Как работатет

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

  • Регрессия определяется как метод контролируемого машинного обучения. Существует два типа алгоритмов регрессии: линейный и нелинейный.
  • Здесь мы можем использовать технику нелинейной регрессии, которая используется для описания нелинейности и ее параметра в зависимости от одной или нескольких независимых переменных.

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

  • df = pds.read_csv(“reгрессияchina_gdp.csv”) используется для чтения файла, который мы импортируем.
  • plot.figure(figsize=(8,5)) используется для построения фигуры.
  • x_data, y_data =(df[“Год”].values, df[“Значение”].values) используется для описания значений и лет.
  • plot.plot(x_data, y_data, ‘ro’) используется для построения данных x и y.
  • plot.ylabel(‘GDP’) используется для построения метки y.
  • plot.xlabel(‘Year’) используется для построения метки x.
import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
df = pds.read_csv("regressionchina_gdp.csv")
df.head(10)
plot.figure(figsize=(8,5))
x_data, y_data =(df["Year"].values, df["Value"].values)
plot.plot(x_data, y_data, 'ro')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()

Рисование линейной регрессии

В следующем коде мы выбираем модель для рисования линейной регрессии на экране.

  • plot.plot (x,y) используется для построения графика x и y на экране.
  • plot.ylabel (‘Зависимая переменная’) используется для построения метки y на экране.
  • plot.xlabel (‘Независимая переменная’) используется для построения метки x на экране.
x = np.arange(-5.0, 5.0, 0.1)
y = 1.0 /(1.0 + np.exp(-x))
plot.plot(x,y) 
plot.ylabel('Dependent Variable')
plot.xlabel('Indepdendent Variable')
plot.show()

Выбор модели

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

Теперь plot.plot (x_data, Y_pred*15000000000000.) используется для построения графика начальной позиции относительно точек данных.

def sigmoid(x, Beta_1, Beta_2):
     y = 1 /(1 + np.exp(-Beta_1*(x-Beta_2)))
     return y
beta1 = 0.10
beta2 = 1990.0
#logistic function
Y_pred = sigmoid(x_data, beta1 , beta2)

plot.plot(x_data, Y_pred*15000000000000.)
plot.plot(x_data, y_data, 'ro')

Постройка модели

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

  • plot.figure (figsize=(8,5)) используется для построения фигуры на экране.
  • plot.plot (xdata, ydata, ‘ro’, label=’data’) используется для отображения ydata и xdata на экране.
  • plot.plot (x,y, linewidth=3.0, label=’fit’) используется для построения линии соответствия на экране.
xdata =x_data/max(x_data)
ydata =y_data/max(y_data)
from scipy.optimize import curve_fit
popt, pcov = curve_fit(sigmoid, xdata, ydata)
# Now we plot our resulting regression model.
x = np.linspace(1960, 2015, 55)
x = x/max(x)
plot.figure(figsize=(8,5))
y = sigmoid(x, *popt)
plot.plot(xdata, ydata, 'ro', label='data')
plot.plot(x,y, linewidth=3.0, label='fit')
plot.legend(loc='best')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()

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

scikit изучает параметр наилучшего соответствия нелинейной регрессии

Пример

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

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

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

  • df = pds.read_csv (“reгрессияchina_gdp.csv”) используется для чтения CSV-файла, который мы загружаем.
  • y = 1/(1 + np.exp(-Beta_1*(x-Beta_2))) используется для определения сигмовидной функции.
  • ypred = sigmoid(x_data, beta1, beta2) используется как логистическая функция.
  • plot.plot (x_data, ypred * 16000000000000.) используется для построения первоначального прогноза по точкам данных.
  • plot.plot (x_data, y_data, ‘go’) используется для построения x_data и y_data на графике.
import numpy as num
import pandas as pds
import matplotlib.pyplot as plot

     
df = pds.read_csv("regressionchina_gdp.csv")
 
def sigmoid(x, Beta_1, Beta_2):
     y = 1 /(1 + np.exp(-Beta_1*(x-Beta_2)))
     return y
     
beta1 = 0.10
beta2 = 1990.0
 
ypred = sigmoid(x_data, beta1, beta2)

plot.plot(x_data, ypred * 16000000000000.)
plot.plot(x_data, y_data, 'go')

Выход:

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

Пример

Нелинейный SVM

В этом разделе мы узнаем, как scikit Learn нелинейный SVM работает в Python.

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

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

  • x = num.random.randn(350, 2) используется для генерации случайных чисел.
  • classifier = svm.NuSVC() используется для создания классификатора svm
  • classifier.fit(x, Y) используется для соответствия модели.
  • Z = classifier.decision_function(np.c_[xx.ravel(), yy.ravel()]) используется для построения функции решения каждой точки данных в сетке.
  • plot.imshow(Z, interpolation=’ближайший’,extent=(xx.min(), xx.max(), yy.min(), yy.max()), аспект=’auto’,origin=’нижний ‘, cmap=plot.cm.PuOr_r) используется для построения графика на экране.
  • plot.scatter(x[:, 0], x[:, 1], s=35, c=Y, cmap=plot.cm.Paired) используется для построения точки разброса на сетке.
import numpy as num
import matplotlib.pyplot as plot
from sklearn import svm

xx, yy = num.meshgrid(num.linspace(-3, 3, 500),
                     num.linspace(-3, 3, 500))
num.random.seed(0)
x = num.random.randn(350, 2)
Y = num.logical_xor(x[:, 0] > 0, x[:, 1] > 0)


classifier = svm.NuSVC()
classifier.fit(x, Y)

Z = classifier.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plot.imshow(Z, interpolation='nearest',
           extent=(xx.min(), xx.max(), yy.min(), yy.max()), aspect='auto',
           origin='lower', cmap=plot.cm.PuOr_r)
contours = plot.contour(xx, yy, Z, levels=[0], linewidths=2,
                       linetypes='--')
plot.scatter(x[:, 0], x[:, 1], s=35, c=Y, cmap=plot.cm.Paired)
plot.xticks(())
plot.yticks(())
plot.axis([-3, 3, -3, 3])
plot.show()

Выход:

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

scikit изучает нелинейный SVM

Изучение нелинейной модели

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

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

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

  • range = num.random.RandomState(0) используется для генерации случайного состояния.
  • Lendata =(datamax – datamin) используется для получения длины данных.
  • data = num.sort(range.rand(nsample) * лендата – лендата / 2) используется для сортировки данных и упрощения построения графиков.
  • цель = данные ** 3 – 0,6 * данные ** 2 + шум используется для создания цели.
  • full_data = pds.DataFrame({“входная функция”: данные, “цель”: цель}) используется для получения полных данных из фрейма данных.
  • nonlineardata = sns.scatterplot(data=full_data, x=”входной объект”, y=”цель”, цвет=”синий”, альфа=0,5) используется для построения точек разброса на графике.
import numpy as num

range = num.random.RandomState(0)

nsample = 100
datamax, datamin = 1.5, -1.5
lendata =(datamax - datamin)

data = num.sort(range.rand(nsample) * lendata - lendata / 2)
noise = range.randn(nsample) * .3
target = data ** 3 - 0.6 * data ** 2 + noise
import pandas as pds

full_data = pds.DataFrame({"input feature": data, "target": target})
import seaborn as sns

nonlineardata = sns.scatterplot(data=full_data, x="input feature", y="target",
color="blue", alpha=0.5)

Выход:

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

Scikit изучает нелинейную модель

Нелинейный классификатор

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

Нелинейный классификатор определяется как процесс классификации, который используется для описания нелинейности и ее параметра в зависимости от одной или нескольких независимых переменных.

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

  • x = x.copy() используется для копирования данных.
  • x = num.random.normal(size=(n, 2)) используется для генерации случайных чисел.
  • xtrain, xtest, ytrain, ytest = train_test_split(x, y, random_state=0, test_size=0,5) используется для разделения набора данных на данные поезда и тестовые данные.
  • plot.figure(figsize=(5,5)) используется для построения фигуры на экране.
  • plot.scatter(xtrain[:,0], xtrain[:,1], c=ytrain, Edgecolors=’r’); используется для построения диаграммы рассеяния на экране.
import numpy as num
import matplotlib.pyplot as plot

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

%config InlineBackend.figure_format = 'svg' 
plot.style.use('bmh')
plot.rcParams['image.cmap'] = 'Paired_r'
num.random.seed(5)

def f(x):
    x = x.copy()
    x[:,0] -= 0.4
    x[:,1] += 0.2
    return 1.1*x[:,0]**2 + 0.3*x[:,1]**2 - 0.6*x[:,0]*x[:,1]

def makedata():
    n = 800
    x = num.random.normal(size=(n, 2))
    y = f(x) < 0.5
    x += num.random.normal(size=(n,2), scale=0.2)
    return x, y

x, y = makedata()

xtrain, xtest, ytrain, ytest = train_test_split(x, y, random_state=0, test_size=0.5)

plot.figure(figsize=(5,5))
plot.scatter(xtrain[:,0], xtrain[:,1], c=ytrain, edgecolors='r');

scikit изучает нелинейный классификатор

В приведенном ниже коде мы построим границы классификатора.

  • xx, yy = num.meshgrid(num.arange(x_min, x_max, h),num.arange(y_min, y_max, h)) используется для создания сетки на экране.
  • Z = classifier.predict(num.c_[xx.ravel(), yy.ravel()]) используется для прогнозирования классификатора.
  • plot.figure(figsize=(5,5)) используется для построения классификатора на экране.
  • plot.scatter(X[:,0], X[:,1], c=Y,edgecolors=’r’); используется для построения диаграммы рассеяния на экране.
  • plot_boundary(classifier, xtrain, ytrain) используется для построения границ классификатора.
  • Precision_score(ytest, classifier.predict(xtest)) используется для прогнозирования показателя точности.
def plot_boundary(classifier, X, Y):
    h = 0.02
    x_min, x_max = X[:,0].min() - 10*h, X[:,0].max() + 10*h
    y_min, y_max = X[:,1].min() - 10*h, X[:,1].max() + 10*h
    xx, yy = num.meshgrid(num.arange(x_min, x_max, h),
                         num.arange(y_min, y_max, h))
    Z = classifier.predict(num.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    plot.figure(figsize=(5,5))
    plot.contourf(xx, yy, Z, alpha=0.25)
    plot.contour(xx, yy, Z, colors='r', linewidths=0.7)
    plot.scatter(X[:,0], X[:,1], c=Y, edgecolors='r');
    from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression().fit(xtrain, ytrain)

plot_boundary(classifier, xtrain, ytrain)
accuracy_score(ytest, classifier.predict(xtest))

scikit изучает границу нелинейного классификатора

Нелинейное уменьшение размерности

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

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

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

  • alerts.filterwarnings(‘ignore’) используется для выдачи предупреждения фильтра.
  • x, y = make_s_curve(n_samples=100) используется для построения кривой.
  • digits = load_digits(n_class=6) используется для загрузки цифры.
  • plot.figure(figsize=(12,8)) используется для построения фигуры на экране.
  • axis =plot.axes(projection=’3d’) используется для построения осей на экране.
  • axis.scatter3D(x[:, 0], x[:, 1], x[:, 2], c=y) используется для построения разброса на графике.
import sklearn

import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
from mpl_toolkits.mplot3d import Axes3D

import warnings
import sys

warnings.filterwarnings('ignore')

%matplotlib inline
from sklearn.datasets import make_s_curve

x, y = make_s_curve(n_samples=100)
from sklearn.datasets import load_digits

digits = load_digits(n_class=6)
x_digits, y_digits  = digits.data, digits. target
print('Dataset Size : ', x_digits.shape, y_digits.shape)
plot.figure(figsize=(12,8))
axis = plot.axes(projection='3d')

axis.scatter3D(x[:, 0], x[:, 1], x[:, 2], c=y)
axis.view_init(10, -60);

Выход:

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

scikit изучает нелинейное уменьшение размерности

Нелинейный PCA

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

  • При этом мы объясняем разницу на примере, где с одной стороны KernalPCA может найти проекцию данных, которая линейно разделяет их, а в случае PCA этого не происходит.
  • PCA означает анализ основных компонентов. В этом процессе он используется в качестве основных компонентов. Это также метод уменьшения размерности, который помогает уменьшить размерность.
  • Теперь мы объясняем пример нелинейного PCA, объясняя разницу между PCA и KernalPCA с использованием данных проецирования.

В следующем коде мы рассказываем о преимуществах использования ядра при проецировании данных с использованием PCA.

В этом блоке кода мы генерируем два вложенных набора данных.

from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split

x, y = make_circles(n_samples=1_000, factor=0.3, noise=0.05, random_state=0)
x_train, x_test, y_train, y_test = train_test_split(x, y, stratify=y, random_state=0)

import matplotlib.pyplot as plot

_,(train_ax1, test_ax1) = plot.subplots(ncols=2, sharex=True, sharey=True, figsize=(8, 4))

train_ax1.scatter(x_train[:, 0], x_train[:, 1], c=y_train)
train_ax1.set_ylabel("Feature 1")
train_ax1.set_xlabel("Feature 0")
train_ax1.set_title("Train data")

test_ax1.scatter(x_test[:, 0], x_test[:, 1], c=y_test)
test_ax1.set_xlabel("Feature 0")
_ = test_ax1.set_title("Test data")

Выход:

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

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

scikit изучает нелинейный PCA

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

  • Используемое здесь ядро — это ядро радиальной базисной функции(RBF).
  • orig_data_ax1.set_ylabel() используется для присвоения метки оси Y для данных тестирования.
  • orig_data_ax1.set_xlabel() используется для присвоения метки оси X для данных тестирования.
  • orig_data_ax1.set_title() используется для присвоения метки заголовку графика для данных тестирования.
  • pca_proj_ax1.set_ylabel() используется для присвоения метки оси Y для PCA.
  • pca_proj_ax1.set_xlabel() используется для присвоения метки оси X для PCA.
  • pca_proj_ax1.set_title() используется для указания заголовка графика для PCA.
from sklearn.decomposition import PCA, KernelPCA

pca1 = PCA(n_components=2)
kernel_pca1 = KernelPCA(
    n_components=None, kernel="rbf", gamma=10, fit_inverse_transform=True, alpha=0.1
)

x_test_pca1 = pca1.fit(x_train).transform(x_test)
x_test_kernel_pca1 = kernel_pca1.fit(x_train).transform(x_test)


fig,(orig_data_ax1, pca_proj_ax1, kernel_pca_proj_ax1) = plot.subplots(
    ncols=3, figsize=(14, 4)
)

orig_data_ax1.scatter(x_test[:, 0], x_test[:, 1], c=y_test)
orig_data_ax1.set_ylabel("Feature 1")
orig_data_ax1.set_xlabel("Feature 0")
orig_data_ax1.set_title("Testing data")

pca_proj_ax1.scatter(x_test_pca1[:, 0], x_test_pca1[:, 1], c=y_test)
pca_proj_ax1.set_ylabel("Principal component 1")
pca_proj_ax1.set_xlabel("Principal component 0")
pca_proj_ax1.set_title("projection of test data\n using PCA")

kernel_pca_proj_ax1.scatter(x_test_kernel_pca1[:, 0], x_test_kernel_pca1[:, 1], c=y_test)
kernel_pca_proj_ax1.set_ylabel("Principal component 1")
kernel_pca_proj_ax1.set_xlabel("Principal component 0")
_ = kernel_pca_proj_ax1.set_title("projection of test data using\n Kernel PCA")

Выход:

После запуска следующего кода мы получаем следующий вывод, где мы можем увидеть сравнение данных тестирования, проекцию данных тестирования с использованием PCA и проекцию данных тестирования с использованием KernelPCA.

  • Давайте вспомним, что PCA преобразует данные линейно, что означает, что организованная система будет центрирована, масштабирована по всем компонентам с учетом ее дисперсии и, наконец, повернута.
  • Глядя на приведенный ниже вывод, мы видим в средней структуре, что в структуре нет изменений, связанных с масштабированием.
  • Ядро PCA позволяет создавать нелинейные проекции.
  • Здесь, используя ядро RBF, мы ожидаем, что проекция откроет набор данных, заботясь о сохранении относительных расстояний пар точек данных, которые расположены близко друг к другу в исходном пространстве.
  • Мы можем видеть и наблюдать такие различия в структуре KernelPCA, которая находится справа.

Scikit изучает нелинейное ядро PCA

Добавить комментарий