[[433966]]

不同類型的機器學(xué)習(xí)技術(shù)可以劃分到不同類別，如圖 1 所示。方法的選擇取決于問題的類型(分類、回歸、聚類)、數(shù)據(jù)的類型(圖像、圖形、時間系列、音頻等等)以及方法本身的配置(調(diào)優(yōu))。 

 

在本文中，我們將使用 Python 中最著名的三個模塊來實現(xiàn)一個簡單的線性回歸模型。 使用 Python 的原因是它易于學(xué)習(xí)和應(yīng)用。 我們將使用的三個模塊是：

1- Numpy：可以用于數(shù)組、矩陣、多維矩陣以及與它們相關(guān)的所有操作。

2- Keras：TensorFlow 的高級接口。 它也用于支持和實現(xiàn)深度學(xué)習(xí)模型和淺層模型。 它是由谷歌工程師開發(fā)的。

3- PyTorch：基于 Torch 的深度學(xué)習(xí)框架。 它是由 Facebook 開發(fā)的。

所有這些模塊都是開源的。 Keras 和 PyTorch 都支持使用 GPU 來加快執(zhí)行速度。

以下部分介紹線性回歸的理論和概念。 如果您已經(jīng)熟悉理論并且想要實踐部分，可以跳過到下一部分。

線性回歸

它是一種數(shù)學(xué)方法，可以將一條線與基礎(chǔ)數(shù)據(jù)擬合。 它假設(shè)輸出和輸入之間存在線性關(guān)系。 輸入稱為特征或解釋變量，輸出稱為目標(biāo)或因變量。 輸出變量必須是連續(xù)的。 例如，價格、速度、距離和溫度。 以下等式在數(shù)學(xué)上表示線性回歸模型：

Y = W*X + B

如果把這個方程寫成矩陣形式。 Y 是輸出矩陣，X 是輸入矩陣，W 是權(quán)重矩陣，B 是偏置向量。 權(quán)重和偏置是線性回歸參數(shù)。 有時權(quán)重和偏置分別稱為斜率和截距。

訓(xùn)練該模型的第一步是隨機初始化這些參數(shù)。 然后它使用輸入的數(shù)據(jù)來計算輸出。 通過測量誤差將計算出的輸出與實際輸出進行比較，并相應(yīng)地更新參數(shù)。并重復(fù)上述步驟。該誤差稱為 L2 范數(shù)(誤差平方和)，由下式給出： 

 

計算誤差的函數(shù)又被稱作損失函數(shù)，它可以有不同的公式。 i 是數(shù)據(jù)樣本數(shù)，y 是預(yù)測輸出，t 是真實目標(biāo)。 根據(jù)以下等式中給出的梯度下降規(guī)則更新參數(shù)： 

  

 

在這里，(希臘字母 eta)是學(xué)習(xí)率，它指定參數(shù)的更新步驟(更新速度)。 (希臘字母 delta)只是預(yù)測輸出和真實輸出之間的差異。 i 代表迭代(所謂的輪次)。 L(W) 是損失函數(shù)相對于權(quán)重的梯度(導(dǎo)數(shù))。 關(guān)于學(xué)習(xí)率的價值，有一點值得一提。 較小的值會導(dǎo)致訓(xùn)練速度變慢，而較大的值會導(dǎo)致圍繞局部最小值或發(fā)散(無法達到損失函數(shù)的局部最小值)的振蕩。 圖 2 總結(jié)了以上所有內(nèi)容。 

 

現(xiàn)在讓我們深入了解每個模塊并將上面的方法實現(xiàn)。

Numpy 實現(xiàn)

我們將使用 Google Colab 作為我們的 IDE(集成開發(fā)環(huán)境)，因為它功能強大，提供了所有必需的模塊，無需安裝(部分模塊除外)，并且可以免費使用。

為了簡化實現(xiàn)，我們將考慮具有單個特征和偏置 (y = w1*x1 + b) 的線性關(guān)系。

讓我們首先導(dǎo)入 Numpy 模塊來實現(xiàn)線性回歸模型和 Matplotlib 進行可視化。 

# Numpy is needed to build the model 
import numpy as np 
# Import the module matplotlib for visualizing the data 
import matplotlib.pyplot as plt 

我們需要一些數(shù)據(jù)來處理。 數(shù)據(jù)由一個特征和一個輸出組成。 對于特征生成，我們將從隨機均勻分布中生成 1000 個樣本。 

# We use this line to make the code reproducible (to get the same results when running) 
np.random.seed(42) 
# First, we should declare a variable containing the size of the training set we want to generate 
observations = 1000 
# Let us assume we have the following relationship 
# y = 13x + 2 
# y is the output and x is the input or feature 
# We generate the feature randomly, drawing from an uniform distribution. There are 3 arguments of this method (low, high, size). 
# The size of x is observations by 1. In this case: 1000 x 1. 
x = np.random.uniform(low=-10, high=10, size=(observations,1)) 
# Let us print the shape of the feature vector 
print (x.shape) 

為了生成輸出(目標(biāo))，我們將使用以下關(guān)系： 

Y = 13 * X + 2 + 噪聲 

這就是我們將嘗試使用線性回歸模型來估計的。 權(quán)重值為 13，偏置為 2。噪聲變量用于添加一些隨機性。 

np.random.seed(42) 
# We add a small noise to our function for more randomness 
noise = np.random.uniform(-1, 1, (observations,1)) 
# Produce the targets according to the f(x) = 13x + 2 + noise definition. 
# This is a simple linear relationship with one weight and bias. 
# In this way, we are basically saying: the weight is 13 and the bias is 2. 
targets = 13*x + 2 + noise 
# Check the shape of the targets just in case. It should be n x m, where n is the number of samples 
# and m is the number of output variables, so 1000 x 1. 
print (targets.shape) 

讓我們繪制生成的數(shù)據(jù)。 

# Plot x and targets 
plt.plot(x,targets) 
# Add labels to x axis and y axis 
plt.ylabel('Targets') 
plt.xlabel('Input') 
# Add title to the graph 
plt.title('Data') 
# Show the plot 
plt.show() 

圖 3 顯示了這種線性關(guān)系： 

 

對于模型訓(xùn)練，我們將從參數(shù)的一些初始值開始。 它們是從給定范圍內(nèi)的隨機均勻分布生成的。 您可以看到這些值與真實值相差甚遠。 

np.random.seed(42) 
# We will initialize the weights and biases randomly within a small initial range. 
# init_range is the variable that will measure that. 
init_range = 0.1 
# Weights are of size k x m, where k is the number of input variables and m is the number of output variables 
# In our case, the weights matrix is 1 x 1, since there is only one input (x) and one output (y) 
weights = np.random.uniform(low=-init_range, high=init_range, size=(1, 1)) 
# Biases are of size 1 since there is only 1 output. The bias is a scalar. 
biases = np.random.uniform(low=-init_range, high=init_range, size=1) 
# Print the weights to get a sense of how they were initialized. 
# You can see that they are far from the actual values. 
print (weights) 
print (biases) 
[[-0.02509198]] 
[0.09014286] 

我們還為我們的訓(xùn)練設(shè)置了學(xué)習(xí)率。 我們選擇了 0.02 的值。 這里可以通過嘗試不同的值來探索性能。 我們有了數(shù)據(jù)，初始化了參數(shù)，并設(shè)置了學(xué)習(xí)率，已準(zhǔn)備好開始訓(xùn)練過程。 我們通過將 epochs 設(shè)置為 100 來迭代數(shù)據(jù)。在每個 epoch 中，我們使用初始參數(shù)來計算新輸出并將它們與實際輸出進行比較。 損失函數(shù)用于根據(jù)前面提到的梯度下降規(guī)則更新參數(shù)。 新更新的參數(shù)用于下一次迭代。 這個過程會不斷重復(fù)，直到達到 epoch 數(shù)。 可以有其他停止訓(xùn)練的標(biāo)準(zhǔn)，但我們今天不討論它。 

# Set some small learning rate  
# 0.02 is going to work quite well for our example. Once again, you can play around with it. 
# It is HIGHLY recommended that you play around with it. 
learning_rate = 0.02 
# We iterate over our training dataset 100 times. That works well with a learning rate of 0.02. 
# We call these iteration epochs. 
# Let us define a variable to store the loss of each epoch. 
losses = [] 
for i in range (100): 
 
# This is the linear model: y = xw + b equation 
outputs = np.dot(x,weights) + biases 
# The deltas are the differences between the outputs and the targets 
# Note that deltas here is a vector 1000 x 1 
deltas = outputs - targets 
 
# We are considering the L2-norm loss as our loss function (regression problem), but divided by 2. 
# Moreover, we further divide it by the number of observations to take the mean of the L2-norm. 
loss = np.sum(deltas ** 2) / 2 / observations 
 
# We print the loss function value at each step so we can observe whether it is decreasing as desired. 
print (loss) 
# Add the loss to the list  
losses.append(loss) 
 
# Another small trick is to scale the deltas the same way as the loss function 
# In this way our learning rate is independent of the number of samples (observations). 
# Again, this doesn't change anything in principle, it simply makes it easier to pick a single learning rate 
# that can remain the same if we change the number of training samples (observations). 
deltas_scaled = deltas / observations 
 
# Finally, we must apply the gradient descent update rules. 
# The weights are 1 x 1, learning rate is 1 x 1 (scalar), inputs are 1000 x 1, and deltas_scaled are 1000 x 1 
# We must transpose the inputs so that we get an allowed operation. 
weights = weights - learning_rate * np.dot(x.T,deltas_scaled) 
biases = biases - learning_rate * np.sum(deltas_scaled) 
 
# The weights are updated in a linear algebraic way (a matrix minus another matrix) 
# The biases, however, are just a single number here, so we must transform the deltas into a scalar. 
# The two lines are both consistent with the gradient descent methodology. 

我們可以觀察每個輪次的訓(xùn)練損失。 

# Plot epochs and losses 
plt.plot(range(100),losses) 
# Add labels to x axis and y axis 
plt.ylabel('loss') 
plt.xlabel('epoch') 
# Add title to the graph 
plt.title('Training') 
# Show the plot 
# The curve is decreasing in each epoch, which is what we need 
# After several epochs, we can see that the curve is flattened. 
# This means the algorithm has converged and hence there are no significant updates 
# or changes in the weights or biases. 
plt.show() 

正如我們從圖 4 中看到的，損失在每個 epoch 中都在減少。 這意味著模型越來越接近參數(shù)的真實值。 幾個 epoch 后，損失沒有顯著變化。 這意味著模型已經(jīng)收斂并且參數(shù)不再更新(或者更新非常小)。 

 

此外，我們可以通過繪制實際輸出和預(yù)測輸出來驗證我們的模型在找到真實關(guān)系方面的指標(biāo)。 

# We print the real and predicted targets in order to see if they have a linear relationship. 
# There is almost a total match between the real targets and predicted targets. 
# This is a good signal of the success of our machine learning model. 
plt.plot(outputs,targets, 'bo') 
plt.xlabel('Predicted') 
plt.ylabel('Real') 
plt.show() 
# We print the weights and the biases, so we can see if they have converged to what we wanted. 
# We know that the real weight is 13 and the bias is 2 
print (weights, biases) 

這將生成如圖 5 所示的圖形。我們甚至可以打印最后一個 epoch 之后的參數(shù)值。 顯然，更新后的參數(shù)與實際參數(shù)非常接近。 

[[13.09844702]] [1.73587336] 

 

Numpy 實現(xiàn)線性回歸模型就是這樣。

Keras 實現(xiàn)

我們首先導(dǎo)入必要的模塊。 TensorFlow 是這個實現(xiàn)的核心。 它是構(gòu)建模型所必需的。 Keras 是 TensorFlow 的抽象，以便于使用。 

# Numpy is needed to generate the data 
import numpy as np 
# Matplotlib is needed for visualization 
import matplotlib.pyplot as plt 
# TensorFlow is needed for model build 
import tensorflow as tf 

為了生成數(shù)據(jù)(特征和目標(biāo))，我們使用了 Numpy 中生成數(shù)據(jù)的代碼。 我們添加了一行來將 Numpy 數(shù)組保存在一個文件中，以防我們想將它們與其他模型一起使用(可能不需要，但添加它不會有什么壞處)。 

np.savez('TF_intro', inputs=x, targets=targets) 

Keras 有一個 Sequential 的類。 它用于堆疊創(chuàng)建模型的層。 由于我們只有一個特征和輸出，因此我們將只有一個稱為密集層的層。 這一層負(fù)責(zé)線性變換 (W*X +B)，這是我們想要的模型。 該層有一個稱為神經(jīng)元的計算單元用于輸出計算，因為它是一個回歸模型。 對于內(nèi)核(權(quán)重)和偏置初始化，我們在給定范圍內(nèi)應(yīng)用了均勻隨機分布(與 Numpy 中相同，但是在層內(nèi)指定)。 

# Declare a variable where we will store the input size of our model 
# It should be equal to the number of variables you have 
input_size = 1 
# Declare the output size of the model 
# It should be equal to the number of outputs you've got (for regressions that's usually 1) 
output_size = 1 
# Outline the model 
# We lay out the model in 'Sequential' 
# Note that there are no calculations involved - we are just describing our network 
model = tf.keras.Sequential([ 
# Each 'layer' is listed here 
# The method 'Dense' indicates, our mathematical operation to be (xw + b) 
tf.keras.layers.Input(shape=(input_size , )), 
tf.keras.layers.Dense(output_size, 
# there are extra arguments you can include to customize your model 
# in our case we are just trying to create a solution that is  
# as close as possible to our NumPy model 
# kernel here is just another name for the weight parameter 
kernel_initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1), 
bias_initializer=tf.random_uniform_initializer(minval=-0.1, maxval=0.1) 
) 
]) 
# Print the structure of the model 
model.summary() 

為了訓(xùn)練模型，keras提供 fit 的方法可以完成這項工作。 因此，我們首先加載數(shù)據(jù)，指定特征和標(biāo)簽，并設(shè)置輪次。 在訓(xùn)練模型之前，我們通過選擇合適的優(yōu)化器和損失函數(shù)來配置模型。 這就是 compile 的作用。 我們使用了學(xué)習(xí)率為 0.02(與之前相同)的隨機梯度下降，損失是均方誤差。 

# Load the training data from the NPZ 
training_data = np.load('TF_intro.npz') 
# We can also define a custom optimizer, where we can specify the learning rate 
custom_optimizer = tf.keras.optimizers.SGD(learning_rate=0.02) 
# 'compile' is the place where you select and indicate the optimizers and the loss 
# Our loss here is the mean square error 
model.compile(optimizer=custom_optimizer, loss='mse') 
# finally we fit the model, indicating the inputs and targets 
# if they are not otherwise specified the number of epochs will be 1 (a single epoch of training),  
# so the number of epochs is 'kind of' mandatory, too 
# we can play around with verbose; we prefer verbose=2 
model.fit(training_data['inputs'], training_data['targets'], epochs=100, verbose=2) 

我們可以在訓(xùn)練期間監(jiān)控每個 epoch 的損失，看看是否一切正常。 訓(xùn)練完成后，我們可以打印模型的參數(shù)。 顯然，模型已經(jīng)收斂了與實際值非常接近的參數(shù)值。 

# Extracting the weights and biases is achieved quite easily 
model.layers[0].get_weights() 
# We can save the weights and biases in separate variables for easier examination 
# Note that there can be hundreds or thousands of them! 
weights = model.layers[0].get_weights()[0] 
bias = model.layers[0].get_weights()[1] 
bias,weights 
(array([1.9999999], dtype=float32), array([[13.1]], dtype=float32)) 

當(dāng)您構(gòu)建具有數(shù)千個參數(shù)和不同層的復(fù)雜模型時，TensorFlow 可以為您節(jié)省大量精力和代碼行。 由于模型太簡單，這里并沒有顯示keras的優(yōu)勢。

PyTorch 實現(xiàn)

我們導(dǎo)入 Torch。這是必須的，因為它將用于創(chuàng)建模型。 

# Numpy is needed for data generation 
import numpy as np 
# Pytorch is needed for model build 
import torch 

數(shù)據(jù)生成部分未顯示，因為它與前面使用的代碼相同。 但是Torch 只處理張量(torch.Tensor)。所以需要將特征和目標(biāo)數(shù)組都轉(zhuǎn)換為張量。 最后，從這兩個張量創(chuàng)建一個張量數(shù)據(jù)集。 

# TensorDataset is needed to prepare the training data in form of tensors 
from torch.utils.data import TensorDataset 
# To run the model on either the CPU or GPU (if available) 
device = 'cuda' if torch.cuda.is_available() else 'cpu' 
# Since torch deals with tensors, we convert the numpy arrays into torch tensors 
x_tensor = torch.from_numpy(x).float() 
y_tensor = torch.from_numpy(targets).float() 
# Combine the feature tensor and target tensor into torch dataset 
train_data = TensorDataset(x_tensor , y_tensor) 

模型的創(chuàng)建很簡單。 與keras類似，Sequential 類用于創(chuàng)建層堆棧。 我們只有一個線性層(keras叫密集層)，一個輸入和一個輸出。 模型的參數(shù)使用定義的函數(shù)隨機初始化。 為了配置模型，我們設(shè)置了學(xué)習(xí)率、損失函數(shù)和優(yōu)化器。 還有其他參數(shù)需要設(shè)置，這里不做介紹。 

# Initialize the seed to make the code reproducible 
torch.manual_seed(42) 
# This function is for model's parameters initialization 
def init_weights(m): 
if isinstance(m, torch.nn.Linear): 
torch.nn.init.uniform_(m.weight , a = -0.1 , b = 0.1) 
torch.nn.init.uniform_(m.bias , a = -0.1 , b = 0.1) 
# Define the model using Sequential class 
# It contains only a single linear layer with one input and one output 
model = torch.nn.Sequential(torch.nn.Linear(1 , 1)).to(device) 
# Initialize the model's parameters using the defined function from above 
model.apply(init_weights) 
# Print the model's parameters 
print(model.state_dict()) 
# Specify the learning rate 
lr = 0.02 
# The loss function is the mean squared error 
loss_fn = torch.nn.MSELoss(reduction = 'mean') 
# The optimizer is the stochastic gradient descent with a certain learning rate 
optimizer = torch.optim.SGD(model.parameters() , lr = lr) 

我們將使用小批量梯度下降訓(xùn)練模型。 DataLoader 負(fù)責(zé)從訓(xùn)練數(shù)據(jù)集創(chuàng)建批次。 訓(xùn)練類似于keras的實現(xiàn)，但使用不同的語法。 關(guān)于 Torch訓(xùn)練有幾點補充：

1- 模型和批次必須在同一設(shè)備(CPU 或 GPU)上。

2- 模型必須設(shè)置為訓(xùn)練模式。

3- 始終記住在每個 epoch 之后將梯度歸零以防止累積(對 epoch 的梯度求和)，這會導(dǎo)致錯誤的值。 

# DataLoader is needed for data batching 
from torch.utils.data import DataLoader 
# Training dataset is converted into batches of size 16 samples each. 
# Shuffling is enabled for randomizing the data 
train_loader = DataLoader(train_data , batch_size = 16 , shuffle = True) 
# A function for training the model 
# It is a function of a function (How fancy) 
def make_train_step(model , optimizer , loss_fn): 
def train_step(x , y): 
# Set the model to training mode 
model.train() 
# Feedforward the model with the data (features) to obtain the predictions 
yhat = model(x) 
# Calculate the loss based on the predicted and actual targets 
loss = loss_fn(y , yhat) 
# Perform the backpropagation to find the gradients 
loss.backward() 
# Update the parameters with the calculated gradients 
optimizer.step() 
# Set the gradients to zero to prevent accumulation 
optimizer.zero_grad() 
return loss.item() 
return train_step 
# Call the training function 
train_step = make_train_step(model , optimizer , loss_fn) 
# To store the loss of each epoch 
losses = [] 
# Set the epochs to 100 
epochs = 100 
# Run the training function in each epoch on the batches of the data 
# This is why we have two for loops 
# Outer loop for epochs 
# Inner loop for iterating through the training data batches 
for epoch in range(epochs): 
# To accumulate the losses of all batches within a single epoch 
batch_loss = 0 
for x_batch , y_batch in train_loader: 
x_batch = x_batch.to(device) 
y_batch = y_batch.to(device) 
loss = train_step(x_batch , y_batch) 
batch_loss = batch_loss + loss 
# 63 is not a magic number. It is the number of batches in the training set 
# we have 1000 samples and the batch size is 16 (defined in the DataLoader) 
# 1000/16 = 63 
epoch_loss = batch_loss / 63 
losses.append(epoch_loss) 
# Print the parameters after the training is done 
print(model.state_dict()) 
OrderedDict([('0.weight', tensor([[13.0287]], device='cuda:0')), ('0.bias', tensor([2.0096], device='cuda:0'))]) 

作為最后一步，我們可以繪制 epoch 上的訓(xùn)練損失以觀察模型的性能。 如圖 6 所示。 

完成。 讓我們總結(jié)一下到目前為止我們學(xué)到的東西。

總結(jié) 

線性回歸被認(rèn)為是最容易實現(xiàn)和解釋的機器學(xué)習(xí)模型之一。 在本文中，我們使用 Python 中的三個不同的流行模塊實現(xiàn)了線性回歸。 還有其他模塊可用于創(chuàng)建。 例如，Scikitlearn。