部分适应和热启动有什么区别？

Question

上下文：

我正在使用scikit库中的被动式攻击程序，不知道是使用热启动还是部分匹配。在

迄今为止的努力：

1. 引用了此线程讨论：

https://github.com/scikit-learn/scikit-learn/issues/1585

1. 浏览了scikit代码中的\u fit和部分匹配。在

我的观察结果：

1. _fit依次调用_partial_fit。

2. 设置warm_start时，_fit使用self.coef_调用>

3. 当在不设置_partial_fit参数和设置self.coef_的情况下调用self.coef_时，它将继续使用self.coef_

问题：

我觉得两者最终都是一样的功能。那么，它们之间的基本区别是什么？在哪些情况下，它们中的任何一个都被使用？在

我错过了什么明显的东西吗？感谢任何帮助！在

Answer 1

如果warm_start = False，则对.fit()（在对.fit()或partial_fit()的初始调用之后）的每个后续调用都将重置初始化的模型可训练参数。如果warm_start = True，对.fit()的每个后续调用（在对.fit()或partial_fit()的初始调用之后）将保留上一次运行中模型的可训练参数的值，并最初使用这些值。 不管warm_start的值是多少，对partial_fit()的每次调用都将保留上一次运行的模型参数，并最初使用这些参数。在

使用MLPRegressor的示例：

import sklearn.neural_network
import numpy as np
np.random.seed(0)
x = np.linspace(-1, 1, num=50).reshape(-1, 1)
y = (x * 1.5 + 2).reshape(50,)
cold_model = sklearn.neural_network.MLPRegressor(hidden_layer_sizes=(), warm_start=False, max_iter=1)
warm_model = sklearn.neural_network.MLPRegressor(hidden_layer_sizes=(), warm_start=True, max_iter=1)

cold_model.fit(x,y)
print cold_model.coefs_, cold_model.intercepts_
#[array([[0.17009494]])] [array([0.74643783])]
cold_model.fit(x,y)
print cold_model.coefs_, cold_model.intercepts_
#[array([[-0.60819342]])] [array([-1.21256186])]
#after second run of .fit(), values are completely different
#because they were re-initialised before doing the second run for the cold model

warm_model.fit(x,y)
print warm_model.coefs_, warm_model.intercepts_
#[array([[-1.39815616]])] [array([1.651504])]
warm_model.fit(x,y)
print warm_model.coefs_, warm_model.intercepts_
#[array([[-1.39715616]])] [array([1.652504])]
#this time with the warm model, params change relatively little, as params were
#not re-initialised during second call to .fit()

cold_model.partial_fit(x,y)
print cold_model.coefs_, cold_model.intercepts_
#[array([[-0.60719343]])] [array([-1.21156187])]
cold_model.partial_fit(x,y)
print cold_model.coefs_, cold_model.intercepts_
#[array([[-0.60619347]])] [array([-1.21056189])]
#with partial_fit(), params barely change even for cold model,
#as no re-initialisation occurs

warm_model.partial_fit(x,y)
print warm_model.coefs_, warm_model.intercepts_
#[array([[-1.39615617]])] [array([1.65350392])]
warm_model.partial_fit(x,y)
print warm_model.coefs_, warm_model.intercepts_
#[array([[-1.39515619]])] [array([1.65450372])]
#and of course the same goes for the warm model

Answer 2

首先，让我们看看.fit()和{}之间的区别。在

.fit()可以让你从头开始训练。因此，您可以将此选项视为一个只能对模型使用一次的选项。如果您使用一组新数据再次调用.fit()，那么模型将建立在新数据之上，并且不会影响以前的数据集。在

.partial_fit()将允许您使用增量数据更新模型。因此，对于一个模型，此选项可以多次使用。当整个数据集无法加载到内存中时，请参阅here。在

如果.fit()或{}都要使用一次，那么这没有什么区别。在

warm_start只能在.fit()中使用，它可以让你从前面的fit()的合作中开始学习。现在它听起来可能与partial_fit()的目的相似，但是推荐的方法是partial_fit()。可以用相同的增量数据做partial_fit()几次，以提高学习效果。在

Answer 3

我不知道被动侵略者，但至少在使用SGDRegressor时，partial_fit只适合1个纪元，而{}将适合多个纪元（直到损失收敛或max_iter 达到）。因此，当将新数据拟合到模型中时，partial_fit只会向新数据一步更正模型，但是使用fit和{}它将表现为将旧数据和新数据组合在一起，并对模型进行一次拟合，直到收敛。在

示例：

from sklearn.linear_model import SGDRegressor
import numpy as np

np.random.seed(0)
X = np.linspace(-1, 1, num=50).reshape(-1, 1)
Y = (X * 1.5 + 2).reshape(50,)

modelFit = SGDRegressor(learning_rate="adaptive", eta0=0.01, random_state=0, verbose=1,
                     shuffle=True, max_iter=2000, tol=1e-3, warm_start=True)
modelPartialFit = SGDRegressor(learning_rate="adaptive", eta0=0.01, random_state=0, verbose=1,
                     shuffle=True, max_iter=2000, tol=1e-3, warm_start=False)
# first fit some data
modelFit.fit(X, Y)
modelPartialFit.fit(X, Y)
# for both: Convergence after 50 epochs, Norm: 1.46, NNZs: 1, Bias: 2.000027, T: 2500, Avg. loss: 0.000237
print(modelFit.coef_, modelPartialFit.coef_) # for both: [1.46303288]

# now fit new data (zeros)
newX = X
newY = 0 * Y

# fits only for 1 epoch, Norm: 1.23, NNZs: 1, Bias: 1.208630, T: 50, Avg. loss: 1.595492:
modelPartialFit.partial_fit(newX, newY)

# Convergence after 49 epochs, Norm: 0.04, NNZs: 1, Bias: 0.000077, T: 2450, Avg. loss: 0.000313:
modelFit.fit(newX, newY)

print(modelFit.coef_, modelPartialFit.coef_) # [0.04245779] vs. [1.22919864]
newX = np.reshape([2], (-1, 1))
print(modelFit.predict(newX), modelPartialFit.predict(newX)) # [0.08499296] vs. [3.66702685]