Docker容器化機器學習模型佈署與線上推論

隨著機器學習應用日益普及，模型佈署成為關鍵環節。本文介紹如何使用 Docker 容器化技術封裝機器學習模型，並結合 Flask 框架構建 REST API，實作線上即時預測功能。同時，我們也將整合 Jenkins 自動化伺服器，建立 CI/CD 流程，提升模型佈署效率與版本控管。此方法確保模型在不同環境一致性，簡化佈署流程，並易於擴充套件應用規模。透過容器化技術，開發者能更專注於模型開發與最佳化，而無須擔心環境差異與佈署複雜性。

使用Docker容器進行機器學習的優點

當我們建立並執行上述程式碼時，我們應該可以在 /mydata 目錄中看到 output.csv 檔案。另外，我們也可以在Dockerfile中新增 VOLUME 指令，從而建立一個新的掛載點：

FROM jupyter/scipy-notebook
VOLUME /Users/Xavi/Desktop/code/data

這個指令會建立一個掛載點，該掛載點被標記為從本地主機或其他容器中掛載的外部卷，該捲包含我們想要處理的資料。

在未來的開發中，可能需要從一開始就設定環境變數，以便在構建時持久化訓練模型，並可能向特定位置新增額外的資料或後設資料。設定環境變數的優點是避免在程式碼中硬編碼必要的路徑，並且更好地與他人分享工作成果，根據一致的目錄結構。

讓我們考慮另一個例子，使用新的Dockerfile：

FROM jupyter/scipy-notebook
RUN mkdir my-model
ENV MODEL_DIR=/home/jovyan/my-model
ENV MODEL_FILE_LDA=clf_lda.joblib
ENV MODEL_FILE_NN=clf_nn.joblib
RUN pip install joblib
COPY train.csv./train.csv
COPY test.csv./test.csv
COPY train.py./train.py
COPY inference.py./inference.py
RUN python3 train.py

我們需要在 train.py 和 inference.py 檔案中新增環境變數：

#!/usr/bin/python3
# train.py
import os
import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neural_network import MLPClassifier
import pandas as pd
from joblib import dump

def train():
    # 載入目錄路徑以持久化模型
    model_dir = os.environ["MODEL_DIR"]
    #...

使用Docker容器的優點

隔離性：Docker容器提供了一個隔離的環境，讓你可以在不影響主機的情況下執行你的應用程式。
輕量級：Docker容器比傳統的虛擬機器更輕量級，因為它們分享同一個核心。
易於佈署：Docker容器可以輕鬆地佈署到任何支援Docker的環境中。
一致性：Docker容器確保了應用程式在不同環境中的行為一致性。

圖表翻譯

  graph LR
    A[Docker容器] -->|提供隔離性|> B[應用程式]
    A -->|輕量級|> C[核心]
    A -->|易於佈署|> D[環境]
    A -->|確保一致性|> E[行為]

這個圖表展示了Docker容器的優點，包括隔離性、輕量級、易於佈署和一致性。

使用Docker容器進行機器學習的優點

在進行機器學習的過程中，使用Docker容器可以帶來許多優點。首先，Docker容器可以提供一個隔離的環境，讓我們可以在不同的環境中進行機器學習的實驗和佈署，而不會受到其他環境的影響。

載入和預處理訓練資料

首先，我們需要載入和預處理訓練資料。這包括讀取訓練資料檔案、將資料轉換為適合的格式以及進行資料正規化。

import os
import pandas as pd
from sklearn.preprocessing import normalize

# 設定模型檔案路徑
MODEL_DIR = "./models"
MODEL_FILE_LDA = "lda_model.pkl"
MODEL_FILE_NN = "nn_model.pkl"

MODEL_PATH_LDA = os.path.join(MODEL_DIR, MODEL_FILE_LDA)
MODEL_PATH_NN = os.path.join(MODEL_DIR, MODEL_FILE_NN)

# 載入訓練資料
training_data_path = "./train.csv"
data_train = pd.read_csv(training_data_path)

# 將資料轉換為適合的格式
y_train = data_train['# Letter'].values
X_train = data_train.drop(data_train.loc[:, 'Line':'# Letter'].columns, axis=1)

# 對資料進行正規化
X_train = normalize(X_train, norm='l2')

模型訓練和儲存

接下來，我們需要訓練和儲存機器學習模型。在這個例子中，我們使用線性判別分析（Linear Discriminant Analysis, LDA）作為我們的機器學習模型。

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from joblib import dump

# 訓練LDA模型
clf_lda = LinearDiscriminantAnalysis()
clf_lda.fit(X_train, y_train)

# 將模型儲存到檔案中
dump(clf_lda, MODEL_PATH_LDA)

內容解密：

在上面的程式碼中，我們首先載入了訓練資料，並將其轉換為適合的格式。然後，我們對資料進行了正規化，以確保所有的特徵都在相同的尺度上。接下來，我們訓練了LDA模型，並將其儲存到檔案中。

圖表翻譯：

以下是LDA模型的訓練過程圖表：

  flowchart TD
    A[載入訓練資料] --> B[轉換資料格式]
    B --> C[正規化資料]
    C --> D[訓練LDA模型]
    D --> E[儲存模型]

圖表翻譯：

在上面的圖表中，我們可以看到LDA模型的訓練過程。首先，我們載入了訓練資料，然後將其轉換為適合的格式。接下來，我們對資料進行了正規化，以確保所有的特徵都在相同的尺度上。然後，我們訓練了LDA模型，並將其儲存到檔案中。

神經網路多層感知器（MLP）演算法

在神經網路中，多層感知器（MLP）是一種常用的演算法，適用於各種分類別和迴歸問題。以下是使用MLP的範例程式碼：

from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# 載入 iris 資料集
iris = load_iris()
X = iris.data
y = iris.target

# 切分訓練和測試資料
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 定義 MLPClassifier 物件
clf_NN = MLPClassifier(solver='adam', activation='relu', alpha=0.0001,
                      hidden_layer_sizes=(500,), random_state=0, max_iter=1000)

# 訓練模型
clf_NN.fit(X_train, y_train)

# 儲存模型
import joblib
MODEL_PATH_NN = 'mlp_model.joblib'
joblib.dump(clf_NN, MODEL_PATH_NN)

環境變數設定

在進行推論之前，我們需要設定環境變數，以便載入模型和資料。以下是設定環境變數的範例程式碼：

import os
import platform
import sys
import numpy as np
import pandas as pd
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neural_network import MLPClassifier
from joblib import load

# 印出系統和Python版本
print(platform.platform())
print("Python", sys.version)

# 印出NumPy和SciPy版本
print("NumPy", np.__version__)
print("SciPy", np.__version__)  # 注意：這裡使用np.__version__來印出SciPy版本

# 設定環境變數
MODEL_DIR = os.environ["MODEL_DIR"]
MODEL_FILE_LDA = os.environ["MODEL_FILE_LDA"]
MODEL_FILE_NN = os.environ["MODEL_FILE_NN"]

# 載入模型
MODEL_PATH_LDA = os.path.join(MODEL_DIR, MODEL_FILE_LDA)
MODEL_PATH_NN = os.path.join(MODEL_DIR, MODEL_FILE_NN)

推論函式

以下是推論函式的範例程式碼：

def inference():
    # 載入測試資料
    testing = "test.csv"
    data_test = pd.read_csv(testing)
    y_test = data_test['# Letter'].values
    X_test = data_test.drop(data_test.loc[:, 'Line':'# Letter'].columns, axis=1)

    # 載入模型
    clf_NN = load(MODEL_PATH_NN)

    # 進行推論
    y_pred = clf_NN.predict(X_test)

    # 印出推論結果
    print("推論結果：", y_pred)

主函式

以下是主函式的範例程式碼：

if __name__ == '__main__':
    inference()

內容解密：

上述程式碼中，我們首先載入必要的函式庫和資料，然後定義MLPClassifier物件並訓練模型。接著，我們儲存模型並設定環境變數。最後，我們定義推論函式並進行推論。注意：這裡我們使用joblib函式庫來儲存和載入模型。

圖表翻譯：

  graph LR
    A[載入資料] --> B[定義MLPClassifier物件]
    B --> C[訓練模型]
    C --> D[儲存模型]
    D --> E[設定環境變數]
    E --> F[載入模型]
    F --> G[進行推論]
    G --> H[印出推論結果]

圖表說明：

上述圖表展示了整個過程的流程。首先，我們載入資料，然後定義MLPClassifier物件並訓練模型。接著，我們儲存模型並設定環境變數。最後，我們載入模型並進行推論，然後印出推論結果。

使用Docker佈署機器學習模型的簡單步驟

首先，我們需要準備好機器學習模型的訓練和測試資料。假設我們已經有了訓練好的模型，並將其儲存為MODEL_PATH_LDA和MODEL_PATH_NN。

# 載入測試資料
print(X_test.shape)
print(y_test.shape)

# 對測試資料進行正規化（0,1）
X_test = preprocessing.normalize(X_test, norm='l2')

# 載入訓練好的模型
clf_lda = load(MODEL_PATH_LDA)
clf_nn = load(MODEL_PATH_NN)

# 執行模型並評估其效能
print("LDA模型的評分和分類別結果：")
print(clf_lda.score(X_test, y_test))
print(clf_lda.predict(X_test))

print("NN模型的評分和分類別結果：")
print(clf_nn.score(X_test, y_test))
print(clf_nn.predict(X_test))

接下來，我們可以使用Docker將機器學習模型佈署到雲端。首先，需要建立一個Dockerfile，並在其中定義如何構建和執行模型。

# 使用官方Python映象作為基礎
FROM python:3.9-slim

# 設定工作目錄
WORKDIR /app

# 複製模型檔案到工作目錄
COPY. /app

# 安裝所需的套件
RUN pip install -r requirements.txt

# 暴露REST API的埠
EXPOSE 8000

# 執行命令
CMD ["python", "inference.py"]

然後，執行docker build -t my-docker-image命令構建Docker映象。這樣就可以將機器學習模型佈署到雲端，並暴露REST API讓外部使用者使用。

圖表翻譯：

  graph LR
    A[模型訓練] --> B[模型儲存]
    B --> C[ Docker化 ]
    C --> D[雲端佈署]
    D --> E[REST API暴露]
    E --> F[外部使用者存取]

此圖表描述了從模型訓練到雲端佈署的整個過程，包括模型儲存、Docker化、雲端佈署和REST API暴露等步驟。

內容解密：

在這個例子中，我們使用Docker將機器學習模型佈署到雲端。首先，需要準備好機器學習模型的訓練和測試資料。然後，載入訓練好的模型，並對測試資料進行正規化。接下來，執行模型並評估其效能。最後，使用Docker將模型佈署到雲端，並暴露REST API讓外部使用者使用。

這樣做的好處是，可以簡化機器學習模型的佈署和擴充套件，並提供了一個靈活和可擴充套件的解決方案。另外，使用Docker還可以提供一個一致的環境，確保模型在不同的環境中都能夠正常執行。

使用Docker和Python進行即時機器學習預測

REST API與Flask

在這個章節中，我們將使用Docker和Python建立一個REST API，以進行即時機器學習預測。首先，我們需要了解什麼是REST API。REST（Representational State of Resource）是一種軟體架構風格，定義瞭如何在網際網路上傳輸和存取資源。

我們將使用Flask框架來建立REST API。Flask是一種輕量級的Python Web框架，非常適合建立小型到中型的Web應用程式。

建立Docker容器

要建立Docker容器，我們需要建立一個Dockerfile。Dockerfile是一個文字檔案，包含了用於建立Docker映像的指令。

以下是Dockerfile的內容：

FROM python:3.9-slim

# 設定工作目錄
WORKDIR /app

# 複製requirements.txt到工作目錄
COPY requirements.txt.

# 安裝依賴套件
RUN pip install -r requirements.txt

# 複製程式碼到工作目錄
COPY..

# 建立Docker容器
CMD ["flask", "run", "--host=0.0.0.0"]

這個Dockerfile使用了Python 3.9的基礎映像，並設定了工作目錄、複製了requirements.txt、安裝了依賴套件、複製了程式碼，並建立了Docker容器。

建立REST API

接下來，我們需要建立REST API。以下是api.py的內容：

from flask import Flask, jsonify
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neural_network import MLPClassifier
import pandas as pd
from joblib import load

app = Flask(__name__)

# 載入模型
MODEL_DIR = os.environ["MODEL_DIR"]
MODEL_FILE_LDA = os.environ["MODEL_FILE_LDA"]
MODEL_FILE_NN = os.environ["MODEL_FILE_NN"]
MODEL_PATH_LDA = os.path.join(MODEL_DIR, MODEL_FILE_LDA)
MODEL_PATH_NN = os.path.join(MODEL_DIR, MODEL_FILE_NN)

inference_lda = load(MODEL_PATH_LDA)
inference_NN = load(MODEL_PATH_NN)

# 建立Flask路由
@app.route('/line/<Line>')
def get_data(Line):
    # 從json檔案中取得資料
    data = pd.read_json('test.json')
    # 取得指定行的資料
    row = data.iloc[int(Line)]
    # 將資料轉換為字典
    row_dict = row.to_dict()
    # 回傳資料
    return jsonify(row_dict)

if __name__ == '__main__':
    app.run(host='0.0.0.0')

這個api.py使用了Flask框架，載入了LinearDiscriminantAnalysis和MLPClassifier模型，並建立了Flask路由。

執行Docker容器

最後，我們需要執行Docker容器。以下是執行命令：

docker build -t my-api.
docker run -p 5000:5000 my-api

這個命令建立了Docker容器，並將其執行在5000埠。

圖表翻譯：

以下是Mermaid圖表，描述了REST API的流程：

  graph LR
    A[Client] -->| Request | B[Flask App]
    B -->| Load Model | C[Model]
    C -->| Predict | D[Result]
    D -->| Return | A

這個圖表描述了Client傳送請求到Flask App，Flask App載入模型，模型進行預測，然後回傳結果給Client。

內容解密：

以上程式碼描述瞭如何使用Docker和Python建立一個REST API，以進行即時機器學習預測。首先，我們需要建立一個Dockerfile，然後建立一個api.py檔案，載入模型，並建立Flask路由。最後，我們需要執行Docker容器。

使用Flask開發預測API

在這個範例中，我們將使用Flask框架開發一個預測API，該API可以接收HTTP請求並傳回預測結果。

載入JSON資料

首先，我們需要載入JSON資料檔案。假設我們有一個名為test.json的檔案，內容如下：

[
    {
        "Line": 1,
        "Feature1": 0.5,
        "Feature2": 0.3,
       ...
    },
    {
        "Line": 2,
        "Feature1": 0.2,
        "Feature2": 0.4,
       ...
    },
   ...
]

我們可以使用以下程式碼載入JSON資料：

import json
import pandas as pd

with open('./test.json', 'r') as jsonfile:
    file_data = json.loads(jsonfile.read())

data = pd.DataFrame(file_data)

定義預測函式

接下來，我們需要定義預測函式。假設我們有兩個預測模型：LDA和Neural Network。我們可以使用以下程式碼定義預測函式：

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
from sklearn.neural_network import MLPClassifier
from joblib import load

def prediction(line):
    # 載入LDA模型
    clf_lda = load('lda_model.joblib')
    
    # 載入Neural Network模型
    clf_nn = load('nn_model.joblib')
    
    # 提取特徵資料
    X = data.drop(['Line'], axis=1)
    
    # 預測結果
    prediction_lda = clf_lda.predict(X.iloc[line].values.reshape(1, -1))
    prediction_nn = clf_nn.predict(X.iloc[line].values.reshape(1, -1))
    
    return {'prediction LDA': int(prediction_lda), 'prediction Neural Network': int(prediction_nn)}

定義Flask路由

最後，我們需要定義Flask路由以接收HTTP請求並傳回預測結果。我們可以使用以下程式碼定義Flask路由：

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/prediction/<int:line>', methods=['POST', 'GET'])
def predict(line):
    return jsonify(prediction(line))

@app.route('/score', methods=['POST', 'GET'])
def score():
    # 載入所有資料
    data = pd.read_json('./test.json')
    
    # 預測結果
    predictions_lda = []
    predictions_nn = []
    
    for i in range(len(data)):
        prediction_lda = clf_lda.predict(data.drop(['Line'], axis=1).iloc[i].values.reshape(1, -1))
        prediction_nn = clf_nn.predict(data.drop(['Line'], axis=1).iloc[i].values.reshape(1, -1))
        
        predictions_lda.append(int(prediction_lda))
        predictions_nn.append(int(prediction_nn))
    
    return jsonify({'predictions LDA': predictions_lda, 'predictions Neural Network': predictions_nn})

if __name__ == '__main__':
    app.run(debug=True)

測試API

現在，你可以使用以下命令啟動Flask伺服器：

python app.py

然後，你可以使用以下命令測試API：

curl http://localhost:5000/prediction/1

這將傳回預測結果：

{
  "prediction LDA": 1,
  "prediction Neural Network": 1
}

你也可以使用以下命令測試API：

curl http://localhost:5000/score

這將傳回所有資料的預測結果：

{
  "predictions LDA": [1, 2, 3,...],
  "predictions Neural Network": [1, 2, 3,...]
}

使用Docker和Python REST API進行實時機器學習預測

在本文中，我們將探討如何使用Docker和Python REST API進行實時機器學習預測。首先，我們需要設定環境變數並載入序列化的機器學習模型。

載入模型和設定環境變數

import os
from joblib import load

# 載入環境變數
MODEL_DIR = os.environ["MODEL_DIR"]
MODEL_FILE_LDA = os.environ["MODEL_FILE_LDA"]
MODEL_FILE_NN = os.environ["MODEL_FILE_NN"]

# 設定模型路徑
MODEL_PATH_LDA = os.path.join(MODEL_DIR, MODEL_FILE_LDA)
MODEL_PATH_NN = os.path.join(MODEL_DIR, MODEL_FILE_NN)

# 載入模型
clf_lda = load(MODEL_PATH_LDA)
clf_nn = load(MODEL_PATH_NN)

建立Flask應用程式和路由

接下來，我們需要建立Flask應用程式和路由，以便處理HTTP請求。

from flask import Flask, request, jsonify

app = Flask(__name__)

# 建立路由
@app.route('/line/<int:line>', methods=['GET'])
def get_line(line):
    # 處理請求
    data = pd.read_csv('./test.csv')
    row = data.iloc[line]
    return jsonify({'data': row.to_dict()})

@app.route('/inject/<int:line>', methods=['POST'])
def inject_line(line):
    # 處理請求
    data = pd.read_csv('./test.csv')
    row = data.iloc[line]
    # 對.inject的行進行處理
    return jsonify({'message': 'Inject成功'})

@app.route('/available', methods=['GET'])
def get_available():
    # 處理請求
    data = pd.read_csv('./test.csv')
    return jsonify({'available': len(data)})

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

訓練模型

最後，我們需要訓練模型以進行預測。以下是訓練模型的程式碼：

import pandas as pd
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neural_network import MLPClassifier
from sklearn import preprocessing

def train():
    # 載入訓練資料
    training = "./train.csv"
    data = pd.read_csv(training)

    # 正規化資料
    scaler = preprocessing.StandardScaler()
    data[['feature1', 'feature2']] = scaler.fit_transform(data[['feature1', 'feature2']])

    # 訓練模型
    clf_lda = LinearDiscriminantAnalysis()
    clf_nn = MLPClassifier()

    clf_lda.fit(data[['feature1', 'feature2']], data['target'])
    clf_nn.fit(data[['feature1', 'feature2']], data['target'])

    # 儲存模型
    dump(clf_lda, MODEL_PATH_LDA)
    dump(clf_nn, MODEL_PATH_NN)

train()

圖表翻譯：

  graph LR
    A[載入模型和設定環境變數] --> B[建立Flask應用程式和路由]
    B --> C[訓練模型]
    C --> D[進行預測]

內容解密：

以上程式碼展示瞭如何使用Docker和Python REST API進行實時機器學習預測。首先，我們需要設定環境變數並載入序列化的機器學習模型。接下來，我們需要建立Flask應用程式和路由，以便處理HTTP請求。最後，我們需要訓練模型以進行預測。

機器學習模型訓練與序列化

在本文中，我們將探討如何訓練機器學習模型，並將其序列化以便於後續使用。首先，我們需要載入訓練資料集，並將其分割為特徵資料（X_train）和目標變數（y_train）。

import pandas as pd
from sklearn.preprocessing import preprocessing
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neural_network import MLPClassifier
from joblib import dump

# 載入訓練資料集
data_train = pd.read_csv('training.csv')

# 分割資料集為特徵資料和目標變數
y_train = data_train['# Letter'].values
X_train = data_train.drop(data_train.loc[:, 'Line':'# Letter'].columns, axis=1)

print("訓練資料形狀：")
print(X_train.shape)
print(y_train.shape)

接下來，我們需要對特徵資料進行標準化，以確保所有特徵都處於相同的尺度上。這裡，我們使用L2標準化。

# 對特徵資料進行L2標準化
X_train = preprocessing.normalize(X_train, norm='l2')

線性判別分析（LDA）模型

現在，我們可以開始訓練機器學習模型。首先，我們使用線性判別分析（LDA）模型。

# 訓練LDA模型
clf_lda = LinearDiscriminantAnalysis()
clf_lda.fit(X_train, y_train)

# 將LDA模型序列化
dump(clf_lda, 'lda_model.joblib')

多層感知器（MLP）模型

接下來，我們使用多層感知器（MLP）模型。

# 訓練MLP模型
clf_NN = MLPClassifier(solver='adam', activation='relu', alpha=0.0001,
                       hidden_layer_sizes=(500,), random_state=0, max_iter=1000)
clf_NN.fit(X_train, y_train)

# 將MLP模型序列化
dump(clf_NN, 'mlp_model.joblib')

圖表翻譯

以下是Mermaid圖表，展示了模型訓練和序列化的流程：

  flowchart TD
    A[載入訓練資料] --> B[分割資料集]
    B --> C[標準化特徵資料]
    C --> D[訓練LDA模型]
    D --> E[序列化LDA模型]
    C --> F[訓練MLP模型]
    F --> G[序列化MLP模型]

圖表翻譯：

此圖表展示了機器學習模型訓練和序列化的流程。首先，載入訓練資料集，然後分割資料集為特徵資料和目標變數。接下來，對特徵資料進行標準化。然後，訓練LDA模型和MLP模型，並將其序列化以便於後續使用。

建立Docker映像檔以進行線上推斷

要建立Docker映像檔，我們需要建立一個Dockerfile，使用jupyter/scipy-notebook作為基礎映像檔。同時，我們需要設定環境變數、安裝joblib以允許序列化和反序列化我們的訓練模型，以及安裝Flask（requirements.txt）。我們將train.csv、test.json、train.py和api.py檔案複製到映像檔中。然後，我們執行train.py，這將適合和序列化機器學習模型作為我們映像檔構建過程的一部分。

以下是Dockerfile的內容：

FROM jupyter/scipy-notebook
RUN mkdir my-model
ENV MODEL_DIR=/home/jovyan/my-model
ENV MODEL_FILE_LDA=clf_lda.joblib
ENV MODEL_FILE_NN=clf_nn.joblib
COPY requirements.txt./requirements.txt
RUN pip install -r requirements.txt
COPY train.csv./train.csv
COPY test.json./test.json
COPY train.py./train.py
COPY api.py./api.py
RUN python3 train.py

要建立這個映像檔，我們執行以下命令：

docker build -t my-docker-api -f Dockerfile.

執行Docker線上推斷

現在，我們的目標是執行我們的線上推斷，也就是說，每當客戶端傳送POST請求到/line/、/prediction/、/score端點時，我們將顯示所請求的資料（行）、使用我們的預先訓練模型預測資料的類別，並呈現我們的預先訓練模型使用所有可用資料的得分。要啟動網頁伺服器，我們將執行一個Docker容器並執行api.py指令碼：

docker run -it -p 5000:5000 my-docker-api python3 api.py

-p旗標暴露容器中的5000埠到主機機器上的5000埠。-it旗標允許我們看到容器中的日誌，並執行python3 api.py在my-api映像檔中。

測試API

如果我們傳送請求到IP地址：

curl http://localhost:5000/line/232

我們將得到第232行資料從我們的資料中（test.json）。

如果我們傳送請求：

curl http://localhost:5000/prediction/232

我們將看到以下輸出： LDA模型已將提供的資料（第232行）分類別為字母21（U），而多層感知器神經網路已將資料分類別為字母8（H）。兩個模型不一致。

如果我們傳送請求：

curl http://localhost:5000/score

我們將看到我們的模型在整個資料集上的得分：如我們所見，多層感知器神經網路具有0.59的準確度得分，雖然得分不是很高。還有一些工作需要做以提高準確度！

從DevOps到MLOps：使用Jenkins和Docker整合機器學習模型

有多少AI模型已經佈署到生產環境中？隨著對資料科學團隊和技術的投資，AI專案的數量已經大大增加，同時也增加了錯失佈署它們並評估其真正商業價值的機會之一。其中一個解決方案是MLOps，它提供了將資料科學和IT操作團隊聚集在一起佈署、監控和管理ML/DL模型在生產環境中的能力。

持續整合（CI）和持續交付（CD），也就是CI/CD管道，體現了一種文化，以敏捷操作原則和實踐為DevOps團隊提供了一種方式，允許軟體開發團隊更頻繁地更可靠地修改程式碼，或讓資料科學家連續測試模型的準確度。CI/CD是一種關注業務需求的方式，例如改進模型準確度、自動化佈署步驟或程式碼品質。

MLOps = ML + DEV + OPS

資料建模

演算法

…（內容省略）

整合機器學習模型與 DevOps：使用 Jenkins 和 Docker

在機器學習（ML）和深度學習（DL）專案中，持續整合和持續交付（CI/CD）是一個非常重要的概念。CI/CD 可以幫助我們自動化專案的構建、測試、佈署和監控，從而提高專案的品質和效率。在這個章節中，我們將探討如何使用 Jenkins 和 Docker 將機器學習模型整合到 DevOps 中。

Jenkins 簡介

Jenkins 是一個開源的自動化伺服器，可以幫助我們實作 CI/CD。它提供了豐富的外掛和功能，讓我們可以輕鬆地構建、佈署和自動化軟體專案。Jenkins 的主要目的是減少佈署時間，增加程式碼品質。它允許我們建立任務，例如測試資料科學專案的不同任務。

Docker 簡介

Docker 是一個容器化平臺，允許我們將應用程式封裝成容器，從而實作跨平臺和跨環境的佈署。Docker 提供了輕量級和可移植的容器，讓我們可以輕鬆地佈署和管理應用程式。

整合機器學習模型與 Jenkins 和 Docker

在這個章節中，我們將探討如何使用 Jenkins 和 Docker 將機器學習模型整合到 DevOps 中。首先，我們需要建立一個 Jenkins 任務，該任務將負責構建和佈署機器學習模型。然後，我們需要建立一個 Docker 映像，該映像將包含所有必要的依賴項和組態。

Jenkins 安裝

首先，我們需要安裝 Jenkins。Jenkins 可以在多個平臺上安裝，包括 Linux、macOS 和 Windows。我們可以使用以下命令安裝 Jenkins：

在 Red Hat 或 CentOS 上：sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
在 Ubuntu 上：sudo apt-get update && sudo apt-get install jenkins

建立 Jenkins 任務

建立 Jenkins 任務後，我們需要組態任務的構建和佈署過程。這包括建立一個 Docker 映像，該映像將包含所有必要的依賴項和組態。

Docker 化

Docker 化是指將應用程式封裝成 Docker 容器的過程。這樣可以實作跨平臺和跨環境的佈署。在這個章節中，我們將探討如何使用 Docker 將機器學習模型 Docker 化。

機器學習模型佈署

機器學習模型佈署是指將訓練好的機器學習模型佈署到生產環境的過程。在這個章節中，我們將探討如何使用 Jenkins 和 Docker 將機器學習模型佈署到生產環境。

圖表翻譯：

上述圖表展示瞭如何使用 Jenkins 和 Docker 將機器學習模型整合到 DevOps 中。首先，我們需要建立一個 Jenkins 任務，該任務將負責構建和佈署機器學習模型。然後，我們需要建立一個 Docker 映像，該映像將包含所有必要的依賴項和組態。最後，我們可以將機器學習模型佈署到生產環境中。

import docker
import jenkins

# 建立 Jenkins 連線
jenkins_conn = jenkins.Jenkins('http://localhost:8080')

# 建立 Docker 連線
docker_conn = docker.Docker()

# 建立 Jenkins 任務
job = jenkins_conn.create_job('my_job')

# 建立 Docker 映像
image = docker_conn.images.build(path='.')

# 佈署機器學習模型
docker_conn.containers.run(image)

內容解密：

上述程式碼展示瞭如何使用 Python 建立 Jenkins 連線、Docker 連線、Jenkins 任務和 Docker 映像。然後，我們可以使用這些連線和任務來佈署機器學習模型。這個程式碼示範瞭如何使用 Jenkins 和 Docker 將機器學習模型整合到 DevOps 中。

Jenkins 伺服器設定與自動化流程

在設定好 Jenkins 伺服器後，我們可以透過以下指令檢查其狀態：

sudo systemctl status jenkins

如果一切設定正確，我們應該可以看到類別似以下的輸出：

jenkins.service - Jenkins Service
   Loaded: loaded (/lib/systemd/system/jenkins.service; enabled; vendor preset: enabled)
   Active: active (running) since Thu 2023-02-16 14:30:00 UTC; 1h 30min ago
 Main PID: 1234 (jenkins)
    Tasks: 10 (limit: 4915)
   CGroup: /system.slice/jenkins.service
           └─1234 /usr/bin/java -jar /usr/share/jenkins/jenkins.war

由於 Jenkins 使用 8080 埠，我們需要使用 ufw 開啟此埠：

sudo ufw allow 8080

然後，我們可以檢查 ufw 狀態以確認新的規則：

sudo ufw status

接下來，我們可以透過瀏覽器存取 Jenkins 伺服器，假設伺服器的 IP 位址為 192.168.1.107，則可以透過以下 URL 存取：

http://192.168.1.107:8080

登入 Jenkins 後，我們需要輸入初始管理員密碼，可以透過以下指令取得：

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

複製密碼並將其貼入 Administrator密碼欄位，然後點選繼續。接下來，我們需要按照簡單的步驟組態環境。

自動化流程實作

假設我們需要定期訓練模型，在這種情況下，建議將過程包裝在 Jenkins 中，以避免手動工作並使程式碼更容易維護和改進。在本文中，我們將描述兩種情景：

情景 1：自動克隆 GitHub 倉函式庫

當有人更新機器學習程式碼或提供額外資料時，Jenkins 將自動克隆 GitHub 倉函式庫，然後自動啟動模型訓練並提供分類別準確率，檢查準確率是否小於 80%。

情景 2：自動訓練多層感知器神經網路模型

我們將執行與情景 1 相同的任務，並新增一些額外任務。Jenkins 將自動啟動多層感知器神經網路模型的訓練，提供分類別準確率，並檢查準確率是否小於 80%。如果是，Jenkins 將執行 train-auto-nn.py 指令碼，該指令碼將尋找模型的最佳超引數並列印新的準確率和最佳超引數。

自動化流程圖

以下是自動化流程的圖示：

  graph LR
    A[修改推播] --> B[啟動建置]
    B --> C[克隆倉函式庫]
    C --> D[執行容器]
    D --> E[執行微調]
    E --> F[佈署]
    F --> G[提交修改]
    G --> H[訓練模型]
    H --> I[測試模型準確率]

圖表翻譯：

上述圖表描述了 Jenkins 自動化流程的過程。當修改被推播到 GitHub 倉函式庫時，Jenkins 將自動啟動建置過程，包括克隆倉函式庫、執行容器、執行微調、佈署、提交修改、訓練模型和測試模型準確率。這個流程可以幫助我們自動化機器學習模型的訓練和佈署，提高效率和準確率。

使用 Docker 容器化機器學習模型的綜合效益

綜觀機器學習模型開發的生命週期，從資料預處理、模型訓練、序列化到佈署與線上推論，Docker 容器技術的匯入都展現了顯著的優勢。透過容器化的隔離性和可移植性，我們得以在不同的開發與生產環境中確保模型執行的一致性，有效降低了環境差異帶來的風險。從效能最佳化視角來看，Docker 輕量級的特性也大幅減少了系統資源的消耗，提升了模型訓練和推論的效率。

然而，Docker 的應用並非毫無限制。例如，在處理大規模資料集和複雜模型時，容器的儲存和網路效能仍需進一步最佳化。此外，模型版本控制和更新機制也需要仔細規劃，以確保線上服務的穩定性和可靠性。對於重視模型可解釋性和除錯的團隊而言，容器化的黑盒特性也可能帶來一定的挑戰。

展望未來，隨著 MLOps 理念的普及和技術的發展，預期 Docker 將與 Jenkins 等 CI/CD 工具更加緊密地整合，實作模型訓練、測試、佈署和監控的全面自動化。同時，Serverless 計算、邊緣運算等新興技術也將與 Docker 容器技術產生更深層次的融合，進一步推動機器學習模型的應用落地。玄貓認為，掌握 Docker 容器技術及其相關生態，將成為機器學習工程師和 DevOps 團隊的必備技能，也是企業構建高效能、可擴充套件 AI 基礎設施的關鍵。

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。