Praktisches Tutorial zum maschinellen Lernen (10): Logistische Regression

Überblick

Die logistische Regression ist eine statistische Lernmethode zur Lösung binärer oder mehrfacher Klassifizierungsprobleme. Es wird in Form einer linearen Kombination unabhängiger Variablen modelliert und verwendet die Sigmoid-Funktion, um das Ergebnis in den Wertebereich von [0, 1] abzubilden, der die Wahrscheinlichkeit angibt, dass die Stichprobe zu einer bestimmten Kategorie gehört.
Die logistische Regression ist der am weitesten verbreitete Algorithmus. Die logistische Regression gehört das ganze Jahr über zu den Top 10 der Algorithmen für maschinelles Lernen.

Ableitung der logistischen Regression

lineare Regression

Ausdruck der linearen Regression:
$f\left(x\right)={ich}_{}+{ich}_{}{X}_{}+{ich}_{}{X}_{}+....+{ich}_{}{X}_{}$
In Matrixmultiplikation umgewandelt:
$[[x_{},X_{}....,X_{}]]$ Objekt$[[{ich}_{},{ich}_{}.....,{ich}_{}]{]}^T$
矩阵演示：
首先，假设我们有一个包含3个样本、每个样本有2个特征的训练集X：

X = [[1, 2], [3, 4], [5, 6]]

其中，每个样本都有两个特征。接着，我们随机初始化参数向量θ：

θ = [[0.5,0.5]]
θ.T=[[0.5],[0.5]]
X * θ = [[1, 2], [3, 4], [5, 6]] * [[0.5], [0.5]] = [[10.5+20.5], [30.5+40.5], [50.5+60.5]] = [[1.5], [3.5], [5.5]]

所以：
$f(x)={\theta }_0+{\theta }^{T}x$
如果在x数据集加上一列常量1，${\theta }_0$加入到$\theta$矩阵中，也就能再次缩写
$f(x)={\theta }^{T}x$

$\theta$是权值,它与输出y之间的关系强度。如果权值越大，则输入特征对输出的影响就越大；如果权值越小，则输入特征对输出的影响就越小。。

逻辑回归

逻辑回归(Logistic Regression, LR)模型其实仅在线性回归的基础上，套用了一个逻辑函数，但也就由于这个逻辑函数，使得逻辑回归模型成为了机器学习领域一颗耀眼的明星，更是计算广告学的核心。
通常线性方程的值域为 $(-\infty ，+\infty )$ und der Wertebereich der Wahrscheinlichkeit ist [0, 1], also nehmen wir auf dieser Basis eine Verformung vor, um aus$(-\infty ，+\infty )$ , Umwandlung in [0,1].
Die Hypothesenfunktion der logistischen Regression kann ausgedrückt werden als
$$H_{}\left(x\right)=g\left({ich}^{T}x\right)$$
Diese Konvertierungsfunktion g wird Sigmoidfunktion genannt. Der Ausdruck der Funktion:
$$g\left(z\right)=\frac{}{(1+e^{-z})}$$
Werfen wir einen Blick auf den Graphen der Sigmoid-Funktion

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(t):
    return 1 / (1 + np.exp(-t))

x = np.linspace(-10, 10, 500)
y = sigmoid(x)
plt.plot(x, y)
plt.show()

Wir erhalten also diese Beziehung:

• X (das heißt ${ich}^{Wenn\; T}x$) > 0, ist der Wert (Wahrscheinlichkeit) von Y größer als 0,5 und die Bezeichnung ist 1
• Wenn X <0 ist, ist der Wert (Wahrscheinlichkeit) von Y kleiner als 0,5 und die Bezeichnung ist 0
• Wenn X=0, ist der Wert von Y=0,5

二分类问题，比如是否有肿瘤，概率大于0.5预测就是明确的1，概率小于0.5预测就是明确的0

决策边界

下面再举一个例子，假设我们有许多样本，并在图中表示出来了，并且假设我们已经通过某种方法求出了LR模型的参数（如下图）。

根据上面得到的关系式，我们可以得到：

我们再图像上画出得到：

这时，直线上方所有样本都是正样本y=1，直线下方所有样本都是负样本y=0。因此我们可以把这条直线成为**决策边界**。
以下代码暂时只做参考,绘制一个x1+x2=3附近的随机点，使用sklearn的逻辑回归训练，并绘制边界（安装mlxtend库）

#%%
import numpy as np;
import matplotlib.pyplot as plt
from mlxtend.plotting import plot_decision_regions
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
#产生一个x+y在3附近的随机点。
np.random.seed(100)
x1=np.random.uniform(0,6,100)
x2=x1-3+ np.random.normal(0, 3, size=100)
X=np.hstack((x1.reshape(-1,1),x2.reshape(-1,1)))
y=np.array([1 if i1+i2>=3 else 0 for i1,i2 in zip(x1,x2)])
color=np.array(['red' if i1+i2>=3 else 'blue' for i1,i2 in zip(x1,x2)])
plt.scatter(x1, x2,c=color)
plt.show()
#使用逻辑回归训练模型
lr_model = LogisticRegression(max_iter=2100)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
lr_model.fit(X_train, y_train)
#绘制边界
plot_decision_regions(X, y, clf=lr_model, legend=2)

输出：

同理，对于非线性可分的情况，我们只需要引入多项式特征就可以很好的去做分类预测，如下图：

产生一个x2+y2=1附近的随机点。

import numpy as np;
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
#产生一个x**2+y**2=1附近的随机点。
np.random.seed(100)
x1=np.random.uniform(-1,1,100)
x2=np.sqrt(1-x1**2)+ np.random.normal(-1, 1, size=100)
X=np.hstack((x1.reshape(-1,1),x2.reshape(-1,1)))
y=np.array([1 if i1**2+i2**2>=1 else 0 for i1,i2 in zip(x1,x2)])
#下面同上
#y = np.where(x1**2 + x2**2 < 1, 0, 1)

#使用逻辑回归训练模型
lr_model = LogisticRegression(max_iter=2100)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
lr_model.fit(X_train, y_train)
#绘制边界
print("截距",lr_model.intercept_)
print("斜率",lr_model.coef_)
# 绘制圆形决策边界
circle = plt.Circle((0, 0), radius=1, color='black', fill=False)
fig, ax = plt.subplots()
ax.add_artist(circle)
ax.scatter(x1[y == 0], x2[y == 0], color='blue', s=5)
ax.scatter(x1[y == 1], x2[y == 1], color='red', s=5)
ax.set_xlim([-1, 1])
ax.set_ylim([-1, 1])
plt.axis([-2, 2, -2, 2])
#plt.axis('equal')
plt.show()

输出

得注意的一点，决策边界并不是训练集的属性，而是假设本身和参数的属性。因为训练集不可以定义决策边界，它只负责拟合参数；而只有参数确定了，决策边界才得以确定。

损失函数

损失函数就是用来衡量模型的输出与真实输出的差别。
假设只有两个标签1和0， y n ∈ { 0 , 1 } y_n\in\{0,1\} yn​∈{ 0,1} 。我们把采集到的任何一组样本看做一个事件的话，那么这个事件发生的概率假设为p。我们的模型y的值等于标签为1的概率也就是p。

交叉熵（Cross-Entropy，CE）和均方误差（Mean Squared Error，MSE）是机器学习中经常使用的两种损失函数。它们在许多领域都被广泛应用，例如分类、回归等任务。它们的区别在于对于不同类型的问题，理论依据和优化效果不同。

• MSE通常用于回归问题，用于衡量预测值与真实值之间的差异
• 而CE则通常用于分类问题中，它可以衡量预测结果与真实标签之间的差异。对于二分类问题，它的公式为：

MSE(均方误差)

为什么损失函数不用最小二乘？即逻辑斯蒂回归损失函数为什么使用交叉熵（下一节）而不是MSE？
从逻辑的角度出发，我们知道逻辑斯蒂回归的预测值是一个概率，而交叉熵又表示真实概率分布与预- 测概率分布的相似程度，因此选择使用交叉熵。
从MSE的角度来说，预测的概率与欧氏距离没有任何关系，并且在分类问题中，样本的值不存在大小关系，与欧氏距离更无关系，因此不适用MSE。

原因一：损失函数的凸性（使用MSE可能会陷入局部最优）
前面我们介绍线性回归模型时，给出了线性回归的代价函数的形式（误差平方和函数），具体形式如下：
$$J(\theta )=\frac{1}{m}\sum _{i=1}^m\frac{1}{2}(h_{\theta }(x^{(j)})-y^{(j)})$$
这里我们想到逻辑回归也可以视为一个广义的线性模型，那么线性模型中应用最广泛的代价函数-误差平方和函数，可不可以应用到逻辑回归呢？首先告诉你答案：是不可以的！ 那么为什么呢? 这是因为LR的假设函数的外层函数是Sigmoid函数，Sigmoid函数是一个复杂的非线性函数，这就使得我们将逻辑回归的假设函数
$$h_{\theta }(x)=\frac{1}{(1+e^{-{\theta }^{T}x})}$$
带入上式时，我们得到的
$$J(\theta )=\frac{1}{m}\sum _{i=1}^m\frac{1}{2}(\frac{}{(1+e^{-{\theta }^T{x}^{\left(j\right)}})}-j^{\left(j\right)})$$

ist eine nicht konvexe Funktion, wie unten gezeigt:

Eine solche Funktion hat mehrere lokale Minima. Wenn wir also die Gradientenabstiegsmethode verwenden, um den Minimalwert der Funktion zu lösen, ist das erhaltene Ergebnis nicht immer das globale Minimum, sondern hat ein größer Es ist möglich, ein lokales Minimum zu erhalten

Logistische Regression, bei der MSE die Verlustfunktion ist, ist eine nicht konvexe Funktion. Wie kann man das beweisen? Um die Konvexität einer Funktion zu beweisen, beweisen Sie einfach, dass ihre Ableitung zweiter Ordnung immer größer oder gleich 0 ist. Wenn dies nicht immer der Fall ist größer oder gleich 0, dann ist eine nichtkonvexe Funktion.

• Konvex: Jeder Punkt auf dem Liniensegment, das durch zwei beliebige Punkte im Diagramm der Intervallfunktion verbunden ist, liegt unter (oder über) dem Diagramm der Funktion.
  Eine typische konvexe Funktion $j=-x^{2.}$
  Alle Punkte auf der Linie, die zwei beliebige Punkte verbindet, liegen unter dem Funktionsgraphen, wie unten gezeigt:
  

• Nicht konvex: Die Funktion hat in diesem Intervall mehrere Extremwerte, dh das System verfügt über mehrere stabile Gleichgewichtszustände.
  Nichtkonvexe Funktion $j=sin\left(x\right)$ können die Punkte auf der Verbindungslinie der beiden Punkte auf beiden Seiten des Funktionsbildes verteilt sein, wie unten gezeigt:
  
  Hier müssen Sie nur beweisen, dass die obige Funktion nicht immer größer oder gleich 0 ist. Ich werde es hier nicht beweisen. Baidu.

CE (Kreuzentropie)

Die Verlustfunktion der logistischen Regression wird verwendet, um die Differenz zwischen der Ausgabe des Modells und der tatsächlichen Ausgabe zu messen.
Angenommen, es gibt nur zwei Labels 1 und 0, yn ∈ { 0 , 1 } y_n \in\{0, 1\}jn∈{ 0,1}。我们把采集到的任何一组样本看做一个事件的话，那么这个事件发生的概率假设为p。我们的模型y的值等于标签为1的概率也就是p。
$$P_{y=1}=\frac{1}{1+e^{-{\mathbf{\theta }}^T\mathbf{x}}}=p$$
因为标签不是1就是0，因此标签为0的概率就是：$P_{y=0}=1-p$
我们把单个样本看做一个事件，那么这个事件发生的概率就是：
$$P(y|\mathbf{x})=\{\begin{array}{r}p,y=1\\ 1-p,y=0\end{array}$$
Die Berechnung dieser Funktion ist umständlich. Sie entspricht:
$$P({und}_{}|x_{})=P^{j_{}}(1-p{)}^{1-y_{}}$$
Um die Bedeutung dieser Funktion zu erklären, haben wir eine Stichprobe $(x_{},j_{})$ für dieses Beispiel lautet die Bezeichnung$j_{}$Die Wahrscheinlichkeit von ist
$P^{j_{}}(1-p{)}^{1-y_{}}$(Wenn y=1, ist das Ergebnis p; wenn y=0, ist das Ergebnis 1-p).
Wenn wir einen Datensatz von insgesamt N sammeln, $\{(x_{},j_{}),(x_{},j_{}),(x_{},j_{})...(x_{},j_{})\}$ , wie finde ich die Gesamtwahrscheinlichkeit des Auftretens dieses kombinierten Ereignisses? Multiplizieren Sie einfach die Wahrscheinlichkeit des Auftretens jeder Stichprobe, d. h. die Wahrscheinlichkeit, diesen Satz Stichproben zu sammeln:
$$\begin{array}{rl}{P}_{}& =P({und}_{}|x_{}\left)P\right({und}_{}|x_{})P({und}_{}|x_{})....P({und}_{}|x_{})\\ & =\prod _{n=1}{P}^{j_{}}(1-p{)}^{1-y_{}}\end{array}$$

Beachten Sie, dass $P_{}$ist eine Funktion und die einzige unbekannte Größe ist $\theta$ (innerhalb von p).
Da die kontinuierliche Multiplikation sehr kompliziert ist, ändern wir die kontinuierliche Multiplikation in die Form einer kontinuierlichen Addition, indem wir den Logarithmus beider Seiten nehmen. Der Logarithmus kann einen Unterlauf verhindern und hat keinen Einfluss auf die Monotonie. Gleichzeitig wird der Grenzwert gleichzeitig gefunden Punkt als ursprüngliche Funktion, d. h. Was gefunden wird, ist dasselbeθ \thetaZum Beispiel:$F\; (\; \theta \; )\; =\; ln\; (\; P\; 总\; )\; =\; ln\; (\; \prod \; n\; =\; 1\; N\; pyn\; (\; 1\; -\; p\; )\; 1\; -\; yn$
$$\begin{array}{rl}F\left(i\right)=ln\left(P_{}\right)& =ln\left(\prod _{n=1}{P}^{j_{}}\right(1-p{)}^{1-y_{}})\\ & =\sum _{n=1}ln\left(S^{j_{}}\right(1-p{)}^{1-y_{}})\\ & =\sum _{n=1}\left(J_{}ln\right(p)+(1-j_{}\left)ln\right(1-p)\end{array}$$

Zum Beispiel: $P=\frac{}{1+e^{-{ich}^{T}x}}$
Diese Funktion $Der\; Wert\; von\; F\left(w\right)$ entspricht der Gesamtwahrscheinlichkeit des Eintretens eines Ereignisses, und wir hoffen, dass es umso besser ist, je größer er ist. Aber das widerspricht etwas der Bedeutung von Verlust, daher kann man auch ein negatives Vorzeichen voranstellen. Je kleiner die negative Zahl, desto besser,$-F\left(w\right)$ wird auch seine Verlustfunktion genannt. Die Verlustfunktion kann als eine Funktion verstanden werden, die die Differenz zwischen der Ausgabe unseres aktuellen Modells und der tatsächlichen Ausgabe misst.
Die Verlustfunktion ist Kreuzentropie

$$\begin{array}{r}J\left(\theta \right)=-ln\left(P_{}\right)=-\sum _{n=1}\left(J_{}ln\right(p)+(1-j_{}\left)ln\right(1-p)\end{array}$$

Bei der logistischen Regression verwenden wir normalerweise Kreuzentropie als Verlustfunktion, um den Unterschied zwischen den Modellvorhersagen und den tatsächlichen Bezeichnungen auszuwerten. Das Ziel der Verlustfunktion besteht darin, den Vorhersagefehler des Modells zu minimieren, damit das Modell die Bezeichnung der Daten genauer vorhersagen kann.

Beim tatsächlichen Training teilen wir normalerweise den gesamten Trainingssatz in mehrere kleine Chargen (Batches) auf und verwenden die Daten jeder kleinen Charge, um die Modellparameter zu aktualisieren. Dies hat den Vorteil, dass die Geschwindigkeit des Modelltrainings erhöht und die Volatilität des Modells während des Trainingsprozesses verringert werden kann.

Um den Einfluss der Anzahl der Stichproben auf die Größe der Verlustfunktion zu vermeiden, wird bei der Berechnung der Verlustfunktion normalerweise der Durchschnitt aller Stichprobenverlustfunktionswerte als endgültiger Verlustfunktionswert verwendet. Mit anderen Worten: Was mit der obigen Formel berechnet wird, ist die durchschnittliche Verlustfunktion aller Stichproben im Trainingssatz.
$$\begin{array}{r}J\left(\theta \right)=-\frac{}{N}\sum _{n=1}\left(J_{}ln\right(p)+(1-j_{}\left)ln\right(1-p)\end{array}$$
而除以样本数量m，其实就是将平均损失函数转化为单个样本的损失函数，即用每个样本的损失函数值的平均值来衡量模型在单个样本上的错误程度。这样做可以使优化算法更加稳定和可靠。
好的，假设我们的训练集中有1000个样本，我们将其分成10个小批次（每个小批次包含100个样本）进行训练。模型对每个小批次的样本进行预测

那么，使用如下的公式计算这个模型的交叉熵损失：

$$\text{CE}(\mathbf{y},\hat{\mathbf{y}})=J(\mathbf{\theta })=-\frac{1}{10\times 100}\sum _{i=1}^{10\times 100}[y_i{\log }_e{\hat{y}}_i+(1-y_i){\log }_e(1-{\hat{y}}_i)]$$

1000个样本的平均损失函数值。在实际训练中，优化算法通常是按照小批次的形式进行迭代更新的，因此使用平均损失函数可以对单个小批次的数据完整反映模型对整个训练集数据的学习程度。

而如果我们不将损失函数除以样本数量m，那么不同样本数量的训练集会对损失函数大小产生影响，从而使得优化算法在训练时产生不必要的波动和不稳定。

CE梯度推导

我们指导入到需要使用梯度下降法求出最小值的$\theta$，需要先获取到损失函数的梯度。
首先，我们需要知道向量是如何求导的。具体的推导过程以及原理请参见梯度下降

首先我们知道
$$p=\frac{1}{1+e^{-{\mathbf{\theta }}^T\mathbf{x}}}$$
那么
$$1-P=1-\frac{}{1+e^{-{ich}^{T}x}}=\frac{1+e^{-{ich}^T}}{1+e^{-{ich}^{T}x}}-\frac{}{1+e^{-{ich}^{T}x}}=\frac{e^{-{ich}^T}}{1+e^{-{ich}^{T}x}}$$
p ist eine Variable $Als\; Funktion\; von\; \theta$ leiten wir die Ableitung von p ab und können sie mithilfe der Kettenableitungsregel langsam erweitern, um Folgendes zu erhalten:
$\begin{array}{rl}{p}^{\prime }=f^{\prime }(\mathbf{\theta })& =(\frac{1}{1+e^{-{\mathbf{\theta }}^T\mathbf{x}}}{)}^{\prime }\\ & =-\frac{1}{(1+e^{-{\mathbf{\theta }}^T\mathbf{x}}{)}^2}\cdot (1+e^{-{\mathbf{\theta }}^T\mathbf{x}}{)}^{\prime }\\ & =-\frac{1}{(1+e^{-{\mathbf{\theta }}^T\mathbf{x}}{)}^2}\cdot e^{-{\mathbf{\theta }}^T\mathbf{x}}\cdot (-{\mathbf{\theta }}^T\mathbf{x}{)}^{\prime }\\ & =-\frac{1}{(1+e^{-{\mathbf{\theta }}^T\mathbf{x}}{)}^2}\cdot e^{-{\mathbf{\theta }}^T\mathbf{x}}\cdot (-\mathbf{x})\\ & =\frac{e^{-{\mathbf{\theta }}^T\mathbf{x}}}{(1+e^{-{\mathbf{\theta }}^T\mathbf{x}}{)}^2}\cdot \mathbf{x}\\ & =\frac{1}{1+e^{-{\mathbf{\theta }}^T\mathbf{x}}}\cdot \frac{e^{-{\mathbf{\theta }}^T\mathbf{x}}}{1+e^{-{\mathbf{\theta }}^T\mathbf{x}}}\cdot \mathbf{x}\\ & =p(1-p)\mathbf{x}\end{array}$

上面都是我们做的准备工作，总之我们得记住：
$p^{\prime }=p(1-p)\mathbf{x}$
那么
$(1-p{)}^{\prime }=1^{\prime }-p^{\prime }=-p^{\prime }=-p(1-p)\mathbf{x}$
接下来我们对$J_{}Bitte\; denken\; Sie\; bei\; der$ Ableitung immer daran, dass unsere Variablen nur$\nabla \; J\; (\; \theta$ ) = ∇ ( ∑ n = 1 N ( ynln ( p ) + ( 1 −
.
$\begin{array}{rl}\nabla J（\theta ）& =\nabla （\sum _{n=1}\left(J_{}ln\right(p)+(1-j_{}\left)ln\right(1-p))）\\ & =\sum \left(y_{}l{n}^{\prime }\right(p)+(1-j_{}\left)l{n}^{\text{'}}\right(1-p))\\ & =\sum ((y_{}\frac{}{P}{P}^{\prime })+(1-j_{}\left)\frac{}{1-P}\right(1-p{)}^{\prime })\\ & =\sum \left(y_{}\right(1-p)x_{}-(1-j_{}\left)p{x}_{}\right)\\ & =\sum _{n=1}(J_{}-p)x_{}\end{array}$

Schließlich haben wir den Gradienten $Schauen\; wir\; uns\; nun\; den\; Ausdruck\; von\; J\left(\theta \right)$ an:
$\begin{array}{rl}\nabla J（\theta & =\sum _{n=1}(J_{}-p)x_{}\end{array}$
Sie ist so einfach und elegant, was einer der Gründe ist, warum wir uns für die Sigmoidfunktion entschieden haben. Natürlich können wir p auch wieder erweitern, also:

$\begin{array}{rl}\nabla J（\theta & =\sum _{n=1}(J_{}-\frac{}{1+e^{-{ich}^T{x}_{}}})x_{}\end{array}$

Gradientenabstieg (GD) und stochastischer Gradientenabstieg (SGD)

Jetzt haben wir die Verlustfunktion $J_{\theta }$在任意 $\theta$处的梯度 $\nabla J（\mathbf{\theta }）$，可是我们怎么算出来 $\theta \ast$ 呢？ 回到之前的问题，我们现在要求损失函数取最小值时候的的$\theta \ast$值：
${\mathbf{\theta }}^{\ast }=arg{\min }_{w}J(\mathbf{\theta })$，

梯度下降法(Gradient Descent)，可以用来解决这个问题。核心思想就是先随便初始化一个${\theta }_0$
然后给定一个步长$\eta$ 通过不断地修改$\theta$ , so dass es schließlich den Punkt erreicht, an dem der Minimalwert erhalten wird, das heißt, der folgende iterative Prozess wird fortgesetzt, bis die angegebene Anzahl erreicht ist oder der Gradient gleich 0 ist.
${ich}_{t+}={ich}_{}+\eta \nabla F（\theta ）$

Stochastic Gradient Descent-Methode (Stochastic Gradient Descent): Wenn wir bei jedem Aktualisierungsprozess eine kleine Rauschstörung hinzufügen können, nähert es sich möglicherweise schneller dem optimalen Wert. In SGD verwenden wir nicht direkt $\nabla F\left(\theta \right)$ , verwenden Sie stattdessen eine andere alternative Funktion G (θ) G(\bm{\theta}), derenAusgabe eine Zufallsvariable ist$G\left(\theta \right)$
${ich}_{t+}={ich}_{}+\eta G\left(\theta \right)$
Natürlich ist diese alternative Funktion$G(\mathbf{\theta })$需要满足它的期望值等于$\nabla F（\mathbf{\theta }）$，相当于这个函数围绕着$\nabla F（\mathbf{\theta }）$的输出值随机波动。

在这里我先解释一个问题：为什么可以用梯度下降法？

因为逻辑回归的损失函数L是一个连续的凸函数（conveniently convex）。这样的函数的特征是，它只会有一个全局最优的点，不存在局部最优。对于GD跟SGD最大的潜在问题就是它们可能会陷入局部最优。然而这个问题在逻辑回归里面就不存在了，因为它的损失函数的良好特性，导致它并不会有好几个局部最优。当我们的GD跟SGD收敛以后，我们得到的极值点一定就是全局最优的点，因此我们可以放心地用GD跟SGD来求解。

好了，那我们要怎么实现学习算法呢？其实很简单，注意我们GD求导每次都耿直地用到了所有的样本点，从1一直到N都参与梯度计算。
$\begin{array}{rl}\nabla J（\theta & =-\sum _{n=1}(J_{}-\frac{}{1+e^{-{ich}^T{x}_{}}})x_{}\end{array}$
In SGD müssen wir jedes Mal nur eine der Stichproben $(x_{},j_{})$ Die Verwendung zur Darstellung der gesamten Stichprobe, d$E\left(G\right(\theta ))=\nabla F\left(\theta \right)$

E stellt den erwarteten Wert dar, der normalerweise als E(X) ausgedrückt wird, wobei X eine Zufallsvariable ist, die den wahrscheinlichkeitsgewichteten Durchschnitt aller möglichen Werte dieser Zufallsvariablen darstellt.

Auf diese Weise ist unsere vorherige Summierung weg und gleichzeitig gilt $\eta N$ sind alles Konstanten und der Wert von N kann einfach ineta \etaDie SGD-Funktion des Infinitesimals lautet beispielsweise:$\theta$
${ich}_{t+}={ich}_{}+h(y_{}-\frac{}{1+e^{-{ich}^T{x}_{}}})x_{}$
Unter ihnen $(x_{},j_{})$ ist das Ergebnis einer Zufallsstichprobe aller Stichproben.

Interpretierbarkeit

Das größte Merkmal der redaktionellen Regression ist ihre starke Interpretierbarkeit.
Nachdem das Modelltraining abgeschlossen ist, erhalten wir einen Satz n-dimensionaler Gewichtsvektoren $\theta \ast$ und Abweichung${ich}_{}$
Für den Gewichtsvektor $\theta \ast$ , der Wert jeder Dimension stellt den Beitrag der Merkmale dieser Dimension zum endgültigen Klassifizierungsergebnis dar. Wenn diese Dimension positiv ist, bedeutet dies, dass dieses Merkmal einen positiven Beitrag zum Ergebnis hat. Je größer sein Wert ist, desto wichtiger ist dieses Merkmal für die Klassifizierung als positiv.

Für die Abweichung ${ich}_{}$, stellt in gewissem Maße die Leichtigkeit der Beurteilung zwischen positiven und negativen Kategorien dar. Wenn ${ich}_{}$ist 0, dann sind die positiven und negativen Kategorien einheitlich. Wenn ${ich}_{}$Wenn er größer als 0 ist, bedeutet dies, dass die Wahrscheinlichkeit höher ist, dass er in die positive Kategorie eingestuft wird, und umgekehrt.

Abhängig von der Größe des Gewichtsvektors in der logistischen Regression für jedes Merkmal können wir ein klares und quantitatives Verständnis der Bedeutung jedes Merkmals erhalten. Aus diesem Grund ist das logistische Regressionsmodell gut interpretierbar.

reguläre Amtszeit

Bei linearen Regressionsmodellen wird das Modell mit L1-Regularisierung als Lasso-Regression bezeichnet, und das Modell mit L2-Regularisierung wird als Ridge-Regression (Ridge-Regression) bezeichnet. Informationen zur Lösung des Überanpassungsproblems finden Sie unter: https://blog. csdn.net/liaomin416100569 /article/details/130289602?spm=1001.2014.3001.5501.

Umgang mit Multi-Label-Problemen mit logistischer Regression

Die logistische Regression selbst kann nur für binäre Klassifizierungsprobleme verwendet werden. Wenn die tatsächliche Situation mehrere Klassen umfasst, sind einige Änderungen am Modell erforderlich. Im Folgenden sind drei häufig verwendete Methoden zur Verwendung der logistischen Regression für die Klassifizierung mehrerer Klassen aufgeführt:

Eins gegen Eins

Die Methode von OvO besteht darin, zwei Kategorien aus mehreren Kategorien zu extrahieren, dann die entsprechenden Stichproben in ein logistisches Regressionsmodell einzugeben, einen Klassifikator für die beiden Kategorien zu lernen und dann die obigen Schritte zu wiederholen, bis zwischen allen Kategorien ein Klassifikator vorhanden ist.
Unter der Annahme, dass es vier Kategorien gibt, beträgt die Anzahl der Klassifikatoren 6. Die Tabelle lautet wie folgt:

Die Anzahl der Klassifikatoren verwendet direkt $C_2^{}$Das ist alles, k repräsentiert die Anzahl der Kategorien.

Bei der Vorhersage müssen Sie jedes Modell ausführen und dann die Vorhersageergebnisse jedes Klassifikators aufzeichnen. Das heißt, jeder Klassifikator stimmt einmal ab, und die Kategorie mit den meisten Stimmen ist das endgültige Ergebnis der Mehrfachklassifizierung.

Im obigen Beispiel stimmten beispielsweise 3 der 6 Klassifikatoren für Kategorie 3, 1 für Kategorie 2, 1 für Kategorie 1 und der letzte für Kategorie 0, dann wird Kategorie 3 als endgültige Vorhersage verwendet. Ergebnis.

Wenn in der OvO-Methode viele Kategorien vorhergesagt werden müssen, müssen wir auch viele Klassifikatoren trainieren. Dies erhöht einerseits den Trainingsaufwand, andererseits jedoch in jedem Trainer, Weil Sie nur brauchen Durch die Eingabe von Trainingsmustern, die zwei Kategorien entsprechen, wird der Overhead reduziert.

Aus Sicht der Vorhersage erfordert diese Methode die Ausführung vieler Klassifikatoren und kann die Vorhersagezeitkomplexität jedes Klassifikators nicht reduzieren, sodass der Vorhersageaufwand groß ist.

Einer gegen alle

Auf das Problem ausgerichtet: Eine Probe entspricht mehreren Etiketten.
Die Methode von OvA besteht darin, eine Kategorie aus allen Kategorien als 1 und alle anderen Kategorien als 0 auszuwählen, um den Klassifikator zu trainieren, sodass die Anzahl der Klassifikatoren viel kleiner ist als die von OvO.

Wie Sie dem obigen Beispiel entnehmen können, entspricht die Anzahl der Klassifikatoren tatsächlich der Anzahl der Kategorien, also k.

Obwohl die Anzahl der Klassifikatoren abgenommen hat, müssen für jeden Klassifikator alle Trainingsdaten für das Training eingegeben werden, sodass die Trainingszeitkomplexität jedes Klassifikators höher ist als OvO.

Aus Sicht der Vorhersage ist die gesamte Vorhersagezeitkomplexität kleiner als OvA, da die Anzahl der Klassifikatoren gering ist und die Vorhersagezeitkomplexität jedes Klassifikators unverändert bleibt.

Die Vorhersageergebnisse werden ermittelt, indem jeder Klassifikator nach der Wahrscheinlichkeit seiner entsprechenden Kategorie 1 eingestuft wird und die Kategorie mit der höchsten Wahrscheinlichkeit als endgültige Vorhersagekategorie ausgewählt wird.

sklearn tatsächlicher Kampf

LogisticRegression trainiert die Klassifizierung von Brustkrebstumoren

Das Modul klearn.linear_model stellt uns viele Modelle zur Verfügung, z. B. logistische Regression, Lasso-Regression, Bayesian Ridge-Regression usw. Es ist ersichtlich, dass es noch viel zu lernen gibt. Wir verwenden LogisticRegressioin.
Schauen wir uns zunächst die Funktion LogisticRegression an, die insgesamt 14 Parameter hat:

Die Parameterbeschreibung lautet wie folgt:

• Strafe: Strafelement, str-Typ, optionale Parameter sind l1 und l2, der Standardwert ist l2. Wird verwendet, um die im Strafterm verwendete Spezifikation anzugeben. Die Lösungsalgorithmen Newton-cg, sag und lbfgs unterstützen nur die L2-Spezifikation. Die L1G-Spezifikation geht davon aus, dass die Modellparameter die Laplace-Verteilung erfüllen, und die L2 geht davon aus, dass die Modellparameter die Gaußsche Verteilung erfüllen. Das sogenannte Paradigma besteht darin, den Parametern Einschränkungen hinzuzufügen, damit das Modell nicht überpasst (Overfit), sondern Wenn Sie möchten, kann niemand beantworten, ob es besser ist, wenn wir Einschränkungen hinzufügen. Wir können nur sagen, dass wir theoretisch in der Lage sein sollten, Ergebnisse mit stärkeren Generalisierungsfähigkeiten zu erhalten, wenn wir Einschränkungen hinzufügen.
• dual: Duale oder primitive Methode, Bool-Typ, Standard ist False. Die duale Methode wird nur zur Lösung des L2-Strafterms von linearem Multicore (liblinear) verwendet. Wenn die Anzahl der Stichproben > Stichprobenmerkmale ist, wird „Dual“ normalerweise auf „Falsch“ gesetzt.
• tol: Das Kriterium zum Stoppen der Lösung, Float-Typ, Standard ist 1e-4. Das heißt, wenn die Lösung einen bestimmten Wert erreicht, stoppt sie und es wird davon ausgegangen, dass die optimale Lösung gefunden wurde.
• c: Der Kehrwert des Regularisierungskoeffizienten λ, Float-Typ, Standard ist 1,0. Muss eine positive Gleitkommazahl sein. Wie bei SVM weisen kleinere Werte auf eine stärkere Regularisierung hin.
• fit_intercept: Ob es einen Schnittpunkt oder eine Abweichung gibt, Bool-Typ, der Standardwert ist True.
• intercept_scaling: Nur nützlich, wenn der Regularisierungsterm „liblinear“ ist und fit_intercept auf True gesetzt ist. Float-Typ, Standard ist 1.
• class_weight: Wird zum Markieren verschiedener Arten von Gewichten im Klassifizierungsmodell verwendet. Es kann sich um ein Wörterbuch oder eine „ausgeglichene“ Zeichenfolge handeln. Der Standardwert ist keine Eingabe, dh das Gewicht wird nicht berücksichtigt, was „Keine“ ist. Wenn Sie sich für die Eingabe entscheiden, können Sie „Balanced“ auswählen, damit die Klassenbibliothek die Typgewichtungen selbst berechnet, oder Sie können die Gewichtungen jedes Typs selbst eingeben. Für ein binäres Modell von 0,1 können wir beispielsweise class_weight={0:0.9,1:0.1} definieren, sodass die Gewichtung von Typ 0 90 % und die Gewichtung von Typ 1 10 % beträgt. Wenn „class_weight“ „balanced“ auswählt, berechnet die Klassenbibliothek die Gewichtung basierend auf der Trainingsstichprobengröße. Je größer die Stichprobengröße eines bestimmten Typs ist, desto geringer ist das Gewicht, und je kleiner die Stichprobengröße, desto höher ist das Gewicht. Wenn class_weight ausgeglichen ist, lautet die Methode zur Berechnung der Klassengewichtung wie folgt: n_samples / (n_classes * np.bincount(y)). n_samples ist die Anzahl der Stichproben, n_classes ist die Anzahl der Kategorien, np.bincount(y) gibt die Anzahl der Stichproben jeder Klasse aus, zum Beispiel y=[1,0,0,1,1], dann np. bincount(y)=[2 ,3].
  Was macht class_weight?
  Bei Klassifizierungsmodellen stoßen wir häufig auf zwei Arten von Problemen:
  1. Das erste besteht darin, dass eine Fehlklassifizierung sehr kostspielig ist. Wenn Sie beispielsweise legale Benutzer und illegale Benutzer klassifizieren, sind die Kosten für die Klassifizierung illegaler Benutzer als legale Benutzer sehr hoch. Wir würden legale Benutzer lieber als illegale Benutzer klassifizieren. Zu diesem Zeitpunkt können wir eine erneute manuelle Überprüfung durchführen, möchten jedoch keine Klassifizierung vornehmen illegale Benutzer als legale Benutzer. . Zu diesem Zeitpunkt können wir das Gewicht illegaler Benutzer angemessen erhöhen.

2. Zweitens ist die Stichprobe sehr unausgeglichen. Beispielsweise haben wir 10.000 binäre Stichprobendaten von legalen und illegalen Benutzern, von denen 9.995 für legale Benutzer und nur 5 für illegale Benutzer vorhanden sind. Wenn wir das Gewicht nicht berücksichtigen, haben wir Kann alle kombinieren Der Testsatz wird als legitimer Benutzer vorhergesagt, sodass die Vorhersagegenauigkeit theoretisch 99,95 % beträgt, aber bedeutungslos ist. Zu diesem Zeitpunkt können wir „Balanced“ auswählen, damit die Klassenbibliothek das Gewicht illegaler Benutzerproben automatisch erhöht. Durch Erhöhen des Gewichts einer bestimmten Klassifizierung werden mehr Proben in Kategorien mit hohem Gewicht eingeteilt, als wenn das Gewicht nicht berücksichtigt wird, wodurch die beiden oben genannten Arten von Problemen gelöst werden.

• random_state：随机数种子，int类型，可选参数，默认为无，仅在正则化优化算法为sag,liblinear时有用。
• solver：优化算法选择参数，只有五个可选参数，即newton-cg,lbfgs,liblinear,sag,saga。默认为liblinear。solver参数决定了我们对逻辑回归损失函数的优化方法，有四种算法可以选择，分别是：
  liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数。
  lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
  newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
  sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候。
  saga：线性收敛的随机优化算法的的变重。
  总结：
  liblinear适用于小数据集，而sag和saga适用于大数据集因为速度更快。
  对于多分类问题，只有newton-cg,sag,saga和lbfgs能够处理多项损失，而liblinear受限于一对剩余(OvR)。啥意思，就是用liblinear的时候，如果是多分类问题，得先把一种类别作为一个类别，剩余的所有类别作为另外一个类别。一次类推，遍历所有类别，进行分类。
  newton-cg,sag和lbfgs这三种优化算法时都需要损失函数的一阶或者二阶连续导数，因此不能用于没有连续导数的L1正则化，只能用于L2正则化。而liblinear和saga通吃L1正则化和L2正则化。
  Gleichzeitig verwendet sag jedes Mal nur einen Teil der Stichproben für die Gradienteniteration. Wählen Sie es daher nicht, wenn die Stichprobengröße klein ist. Wenn die Stichprobengröße sehr groß ist, z. B. mehr als 100.000, ist sag die erste Wahl. Aber sag kann nicht für die L1-Regularisierung verwendet werden. Wenn Sie also eine große Anzahl von Stichproben haben und eine L1-Regularisierung benötigen, müssen Sie Ihre eigene Wahl treffen. Reduzieren Sie entweder die Stichprobengröße durch Stichprobenziehung oder kehren Sie zur L2-Regularisierung zurück.
  Aus der obigen Beschreibung könnten Sie denken, dass wir einfach liblinear wählen können, da Newton-cg, lbfgs und sag so viele Einschränkungen haben, wenn es sich nicht um eine große Stichprobe handelt! Falsch, denn liblinear hat auch seine eigenen Schwächen! Wir wissen, dass die logistische Regression die binäre logistische Regression und die multiple logistische Regression umfasst. Es gibt zwei gängige Arten der multivariaten logistischen Regression: Eins-gegen-Rest (OvR) und Viele-gegen-Viele (MvM). Die MvM-Klassifizierung ist im Allgemeinen genauer als die OvR-Klassifizierung. Das Frustrierende daran ist, dass liblinear nur OvR und nicht MvM unterstützt. Wenn wir also eine relativ genaue multiple logistische Regression benötigen, können wir liblinear nicht wählen. Dies bedeutet auch, dass wir die L1-Regularisierung nicht verwenden können, wenn wir eine relativ genaue multiple logistische Regression benötigen.
• max_iter: Die maximale Anzahl von Iterationen für die Algorithmuskonvergenz, Typ int, Standard ist 10. Nur nützlich, wenn der regulierte Optimierungsalgorithmus Newton-CG, Sag und Lbfgs ist, die maximale Anzahl von Iterationen, damit der Algorithmus konvergiert.
• multi_class：分类方式选择参数，str类型，可选参数为ovr和multinomial，默认为ovr。ovr即前面提到的one-vs-rest(OvR)，而multinomial即前面提到的many-vs-many(MvM)。如果是二元逻辑回归，ovr和multinomial并没有任何区别，区别主要在多元逻辑回归上。
  OvR和MvM有什么不同？
  OvR的思想很简单，无论你是多少元逻辑回归，我们都可以看做二元逻辑回归。具体做法是，对于第K类的分类决策，我们把所有第K类的样本作为正例，除了第K类样本以外的所有样本都作为负例，然后在上面做二元逻辑回归，得到第K类的分类模型。其他类的分类模型获得以此类推。
  而MvM则相对复杂，这里举MvM的特例one-vs-one(OvO)作讲解。如果模型有T类，我们每次在所有的T类样本里面选择两类样本出来，不妨记为T1类和T2类，把所有的输出为T1和T2的样本放在一起，把T1作为正例，T2作为负例，进行二元逻辑回归，得到模型参数。我们一共需要T(T-1)/2次分类。
  可以看出OvR相对简单，但分类效果相对略差（这里指大多数样本分布情况，某些样本分布下OvR可能更好）。而MvM分类相对精确，但是分类速度没有OvR快。如果选择了ovr，则4种损失函数的优化方法liblinear，newton-cg,lbfgs和sag都可以选择。但是如果选择了multinomial,则只能选择newton-cg, lbfgs和sag了。
• verbose：日志冗长度，int类型。默认为0。就是不输出训练过程，1的时候偶尔输出结果，大于1，对于每个子模型都输出。
• warm_start：热启动参数，bool类型。默认为False。如果为True，则下一次训练是以追加树的形式进行（重新使用上一次的调用作为初始化）。
• n_jobs: Anzahl paralleler Jobs. Int-Typ, Standardwert ist 1. Bei 1 wird ein Kern der CPU zum Ausführen des Programms verwendet, bei 2 werden 2 Kerne der CPU zum Ausführen des Programms verwendet. Bei der Einstellung -1 werden alle CPU-Kerne zum Ausführen des Programms verwendet.

Binäre Klassifizierung unter Verwendung klinischer Messungen von Brustkrebstumoren zum Nachweis der logistischen Regression

Load_breast_cancer: Brustkrebs-Datensatz mit insgesamt 569 Proben, davon 212 bösartig und 357 gutartig.
1 auf dem Etikett bedeutet bösartig, 0 bedeutet gutartig

#%%
"""
sklearn中的load_breast_cancer数据集是一个二分类的数据集，包含了乳腺癌肿瘤的临床测量指标
"""
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
data = load_breast_cancer()
# 加载数据集
data = load_breast_cancer()
X = data.data    # 特征
y = data.target  # 标签

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义逻辑回归模型
"""
逻辑回归是一种广泛使用的二分类模型，其常用的优化算法是迭代算法，
比如梯度下降算法。收敛是指在训练过程中，模型参数的更新已经收敛到某个稳定的值，
此时继续迭代将不会产生更好的训练效果。max_iter是scikit-learn中LogisticRegression类的一个参数，
表示最大迭代次数，一旦达到这个迭代次数，则认为模型已经收敛。
"""
lr_model = LogisticRegression(max_iter=2100)

# 拟合模型
lr_model.fit(X_train, y_train)

# 预测训练集和测试集上的结果
train_pred = lr_model.predict(X_train)
test_pred = lr_model.predict(X_test)

# 输出准确率
print('Train accuracy score:', accuracy_score(y_train, train_pred))
print('Test accuracy score:', accuracy_score(y_test, test_pred))  # 输出数据集中标签的维度

Zuggenauigkeitswert: 0,9538461538461539 Testgenauigkeitswert
: 0,956140350877193

Achten Sie auf die logistische Regressionskonfiguration: max_iter=5000, die die Anzahl der Konvergenzzeiten darstellt. Standardmäßig wird STOP: TOTAL NO. of ITERATIONS REACHED LIMIT. nach 100 Malen ausgelöst. Wenn die Anzahl der Konvergenzzeiten nicht ausreicht, Der Gefälleabstieg erreicht möglicherweise nicht die Mindestposition.
Wenn Sie den Standardwert 100 verwenden, beträgt die berechnete Genauigkeit 0,94. Wenn sie auf 2100 eingestellt ist, beträgt die Genauigkeit 0,95. Wenn sie auf 2100 oder höher eingestellt ist, dauert 0,95 ebenfalls sehr langsam, daher ist 2100 ein geeigneter Wert.

Ergänzendes Wissen
Accuracy_score und mean_squared_error sind beides Indikatoren zur Bewertung der Modellleistung, eignen sich jedoch für unterschiedliche Arten von Problemen.
precision_score wird normalerweise bei Klassifizierungsproblemen verwendet. Es kann die Klassifizierungsgenauigkeit des Klassifikators im Datensatz messen. Die Berechnungsformel lautet wie folgt:
$$Genauigkeit\_\_\_\_\_=\frac{TP+TN}{TP+TN+FP+FN}$$
其中:

• TP表示真正例（True Positive），即真实为正类且被分类器预测为正类的样本数；
• TN表示真负例（True Negative），即真实为负类且被分类器预测为负类的样本数；
• FP表示假正例（False Positive），即真实为负类但被分类器预测为正类的样本数；
• FN表示假负例（False Negative），即真实为正类但被分类器预测为负类的样本数。

而mean_squared_error则通常用于回归问题中，它可以衡量预测值与真实值之间的差距，其计算公式如下：
$$MSE=\frac{1}{n}\sum _{i=1}^n(y_i-\widehat{y_i}{)}^2$$

总的来说，accuracy_score和mean_squared_error都是用于评估模型性能而且是分类和回归模型的两种标准指标，但是适用于不同类型的问题，accuracy_score适用于分类任务的评估，而mean_squared_error适用于回归任务的评估。

OneVsRestClassifier葡萄酒数据集

OVR-Klassifizierungsweindaten (O vs Rest [Rest]), d. h. der vorherige
Load_Wine-Datensatz „One vs All“, ist ein klassischer, leicht verständlicher Klassifizierungsdatensatz mit mehreren Kategorien, der jeweils insgesamt 178 Weinproben enthält Die Probe verfügt über 13 Funktionen, die in drei Kategorien unterteilt sind. Diese drei Kategorien repräsentieren drei verschiedene Weinsorten. Im Einzelnen handelt es sich um diese drei Kategorien:

• class_0: repräsentiert die erste Weinsorte.
• class_1: Stellt die zweite Weinsorte dar.
• class_2: Stellt die dritte Weinsorte dar.

Code

#%%

"""
sklearn中的load_breast_cancer数据集是一个二分类的数据集，包含了乳腺癌肿瘤的临床测量指标
"""
from sklearn.datasets import load_wine
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OneVsRestClassifier,OneVsOneClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
data = load_wine()
X = data.data    # 特征
y = data.target  # 标签
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定义逻辑回归模型
lr_model = LogisticRegression(max_iter=2100)
ovr = OneVsRestClassifier(lr_model)
# 拟合模型
ovr.fit(X_train, y_train)

# 预测训练集和测试集上的结果
train_pred = ovr.predict(X_train)
test_pred = ovr.predict(X_test)

# 输出准确率
print('Train accuracy score:', accuracy_score(y_train, train_pred))
print('Test accuracy score:', accuracy_score(y_test, test_pred))  # 输出

Ausgabe:

Train accuracy score: 0.9788732394366197
Test accuracy score: 1.0

Die Genauigkeitsrate des Testdatensatzes beträgt 100 %

OneVsOneClassifier Weindatensatz

Dito Datensatz

ovo = OneVsOneClassifier(lr_model)
ovo.fit(X_train, y_train)
# 拟合模型
ovo.fit(X_train, y_train)

# 预测训练集和测试集上的结果
train_pred1 = ovo.predict(X_train)
test_pred1 = ovo.predict(X_test)

# 输出准确率
print('Train accuracy score:', accuracy_score(y_train, train_pred1))
print('Test accuracy score:', accuracy_score(y_test, test_pred1))  

Ausgabe:
Zuggenauigkeitsbewertung: 0,9929577464788732
Testgenauigkeitsbewertung: 1,0

Die Genauigkeitsrate des Testdatensatzes beträgt 100 %