机器学习管道实践 ML Pipeline：2. 一个普通的机器训练模型流程

机器学习管道实践 ML Pipeline：2. 一个普通的机器训练模型流程

我们将通过一系列文章学习机器学习管道（Machine Learning Pipeline）的一个实例。此章节中，我们将按照一般的流程进行模型训练。

• Win10
• IDE：VSCode
• Anaconda
• 代码地址

---

---

1 搭建虚拟环境

首先，我们在Windows的平台下安装Anaconda3。具体的安装步骤此处略过，参见Anaconda的官方文档。

安装完后，新建虚拟环境。使用conda create -n your_env_name python=X.X（2.7、3.6等)命令创建python版本为X.X、名字为your_env_name的虚拟环境。

这里我输入了conda create -n mlAppFlaskMlopsEnv python=3.8。

安装完默认的依赖后，我们进入虚拟环境：conda activate mlAppFlaskMlopsEnv。注意，如果需要退出，则输入conda deactivate。另外，如果Terminal没有成功切换到虚拟环境，可以尝试conda init powershell，然后重启terminal。

然后，我们在虚拟环境中下载好相关依赖：pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

所有的训练数据集保存于data文件夹中。

2 导入数据并分配训练集与测试集

首先让我们导入训练数据，也就是在data_prepare模块中保存的data_animals_head_20.pickle文件，并且分成训练集和测试集：

data = pickle.load(open('./pickle_files/data_animals_head_20.pickle','rb'))
dataDesc = data['description']  
X = data['data']                
y = data['target']              
labels = data['labels']    
# split the data into train and test
x_train,x_test,y_train,y_test = train_test_split(X,y,test_size=0.2,stratify=y)     

3 灰度化所有训练样本

我们新建了一个类，其实很简单，就是一个循环，加上rgb2gray函数。

# Transform all image to grey.
class rgb2gray_transform(BaseEstimator,TransformerMixin):
    import skimage.color
    def __init__(self):
        pass
    
    def fit(self,X,y=None):
        return self
    
    def transform(self,X,y=None):
        return np.array([skimage.color.rgb2gray(x) for x in X])

实例化：

rgb2grayobj = rgb2gray_transform()
x_train_gray = rgb2grayobj.fit_transform(x_train)

注意，在我们这个例子中，x_train_gray的大小为：[数据集数量，图片长，图片宽]，比如[1645, 80, 80]。

4 提取特征

对于常规的机器学习来说，先做预处理（比如灰度图），再做特征提取，最后使用一个机器学习的算法进行模型训练，一般这样三部曲。这里，我们使用HOG算法对特征进行提取。

# Extract the feature
class hogtransformer(BaseEstimator,TransformerMixin):
    import skimage.feature
    def __init__(self,orientations=9,pixels_per_cell=(8, 8),cells_per_block=(3, 3),):
        self.orientations = orientations
        self.pixels_per_cell = pixels_per_cell
        self.cells_per_block = cells_per_block
    def fit(self,X,y=None):
        return self
    def transform(self,X,y=None):
        def local_hog(img):
            hog_features= skimage.feature.hog(img,orientations=self.orientations,
                                pixels_per_cell=self.pixels_per_cell,
                                cells_per_block=self.cells_per_block)         
            return hog_features
        hfeatures = np.array([local_hog(x) for x in X])
        return hfeatures
hogt = hogtransformer()
x_train_hog = hogt.fit_transform(x_train_gray)

HOG 采用了统计的方式(直方图)进行提取. 其基本思路是将图像局部的梯度统计特征拼接起来作为总特征. 局部特征在这里指的是将图像划分为多个Block, 每个Block内的特征进行联合以形成最终的特征。网上有很多关于HOG算法的介绍，这里我就不赘述了。在上面的hogtransformer类中，我们最终返回的就是特征向量矩阵，他的大小为[数据集数量,特征数量]，比如：[1645, 5184]

如下为特征提取的结果：

4 模型训练

# Image classifier
model_sgd = SGDClassifier(loss='hinge',learning_rate='adaptive',
                          early_stopping=True,eta0=0.1,)
model_sgd.fit(x_train_scale,y_train)

这里，我们使用了sklearn自带的SGDClassifier算法对模型进行训练。这个算法具体的解释这里就不做详述了，网上也有很多解释地文章。

5 汇总一下

所以，总的来说，一个普通的机器学习的流程大概就是预处理，特征提取，训练，这三个部分。这里还多了一部分，就是normalization归一化，即，我们对提取出来的特征做一个归一化，再去学习。
上述的代码梳理一下，如下：

model_sgd = SGDClassifier(loss='hinge',learning_rate='adaptive', early_stopping=True,eta0=0.1,)
grayify = rgb2gray_transform()
hogify = hogtransformer()
scalify = StandardScaler()
# step-1: convert into grayscale
x_train_gray = grayify.fit_transform(x_train)
# step-2: extract the features
x_train_hog = hogify.fit_transform(x_train_gray)
# step-3: Normalization
x_train_scale = scalify.fit_transform(x_train_hog)
# step-4: machine learning
model_sgd.fit(x_train_scale,y_train)

我们将训练好的模型model_sgd放进测试集中进行预测：

x_test_gray = grayify.fit_transform(x_test)
x_test_hog = hogify.fit_transform(x_test_gray)
x_test_scale = scalify.transform(x_test_hog)
y_pred_test = model_sgd.predict(x_test_scale)

以及performance：

# Model Evaluation
cr = sklearn.metrics.classification_report(y_test,y_pred_test,output_dict=True)
print(pd.DataFrame(cr).T)
print("Model evaluation score: ", metrics.cohen_kappa_score(y_test,y_pred_test))

我们得到的结果如下：

              precision    recall  f1-score     support
bear           0.470588  0.400000  0.432432   20.000000
cat            0.625000  0.625000  0.625000   32.000000
chicken        0.545455  0.600000  0.571429   20.000000
cow            0.533333  0.380952  0.444444   21.000000
deer           0.625000  0.714286  0.666667   21.000000
dog            0.222222  0.153846  0.181818   26.000000
duck           0.533333  0.761905  0.627451   21.000000
eagle          0.500000  0.450000  0.473684   20.000000
elephant       0.647059  0.550000  0.594595   20.000000
human          0.714286  1.000000  0.833333   20.000000
lion           0.461538  0.300000  0.363636   20.000000
monkey         0.272727  0.300000  0.285714   20.000000
mouse          0.230769  0.150000  0.181818   20.000000
natural        0.000000  0.000000  0.000000    1.000000
panda          0.531250  0.708333  0.607143   24.000000
pigeon         0.500000  0.608696  0.549020   23.000000
rabbit         0.687500  0.550000  0.611111   20.000000
sheep          0.375000  0.300000  0.333333   20.000000
tiger          0.620690  0.782609  0.692308   23.000000
wolf           0.684211  0.650000  0.666667   20.000000
accuracy       0.526699  0.526699  0.526699    0.526699
macro avg      0.488998  0.499281  0.487080  412.000000
weighted avg   0.513620  0.526699  0.512898  412.000000
Model evaluation score:  0.5000653387346687

你可以看到，实际上训练出来的效果并不是很好，一方面是因为数据量不够，也没有像深度学习那样，做过数据增强，另外一方面算法以及参数都不够。接下来，我们将上述的步骤标准化，然后通过自动调参来部分优化这一结果。