Kubernetes佈署機器學習預測API服務

隨著資料量的增長和模型複雜度的提升，佈署機器學習模型到生產環境的需求也日益增長。本文將示範如何使用 Python 的 Flask 框架構建一個機器學習模型預測 API，並利用 Docker 和 Kubernetes 實作容器化佈署，確保服務的高用性和可擴充套件性。首先，我們會使用 Scikit-learn 訓練一個簡單的模型，然後使用 Flask 將其包裝成 API 服務，最後利用 Docker 建立容器映像，並佈署到 Kubernetes 叢集中。這個流程可以讓資料科學家更輕鬆地將模型佈署到生產環境，並讓應用程式開發人員方便地整合機器學習預測功能。

API設計

我們設計了三個API：

API 1：根據使用者提供的行號，提取對應的資料並傳回。
API 2：根據使用者提供的行號，提取對應的資料，然後將新的資料注入模型中，並傳回模型的分類別預測結果。
API 3：讀取test.json檔案中的所有資料，並傳回模型的分類別評分。

實作細節

以下是api.py檔案的實作細節：

import json
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 load
from sklearn import preprocessing
from flask import Flask

# 設定環境變數
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)

# 載入LDA模型
print("Loading model from: {}".format(MODEL_PATH_LDA))
inference_lda = load(MODEL_PATH_LDA)

# 載入神經網路模型
print("Loading model from: {}".format(MODEL_PATH_NN))
inference_NN = load(MODEL_PATH_NN)

# 建立Flask應用
app = Flask(__name__)

# API 1
@app.route('/line/<Line>')
def get_data(Line):
    with open('./test.json', 'r') as jsonfile:
        file_data = json.loads(jsonfile.read())
    # 找到對應的資料並傳回
    return file_data[int(Line)]

# API 2
@app.route('/predict/<Line>')
def predict(Line):
    with open('./test.json', 'r') as jsonfile:
        file_data = json.loads(jsonfile.read())
    # 找到對應的資料並注入模型中
    data = file_data[int(Line)]
    # 預測結果
    prediction_lda = inference_lda.predict(data)
    prediction_NN = inference_NN.predict(data)
    return {'prediction_lda': prediction_lda, 'prediction_NN': prediction_NN}

# API 3
@app.route('/score')
def get_score():
    with open('./test.json', 'r') as jsonfile:
        file_data = json.loads(jsonfile.read())
    # 讀取所有資料並傳回模型的分類別評分
    score_lda = inference_lda.score(file_data)
    score_NN = inference_NN.score(file_data)
    return {'score_lda': score_lda, 'score_NN': score_NN}

內容解密：

上述程式碼實作了三個API，分別是根據行號提取資料、根據行號進行預測和讀取所有資料進行評分。每個API都使用Flask框架實作，方便地與使用者進行互動。

圖表翻譯：

  flowchart TD
    A[使用者請求] --> B[API 1: 提取資料]
    B --> C[傳回資料]
    A --> D[API 2: 預測]
    D --> E[注入模型]
    E --> F[傳回預測結果]
    A --> G[API 3: 評分]
    G --> H[讀取所有資料]
    H --> I[傳回評分]

上述流程圖展示了三個API之間的關係，使用者可以根據自己的需求選擇相應的API。

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

在本文中，我們將探討如何使用Docker、Python Flask API和Kubernetes實作實時機器學習預測。這個過程涉及建立一個可擴充套件的API，該API可以接收使用者請求並傳回預測結果。

建立Flask API

首先，我們需要建立一個Flask API來處理使用者請求。以下是API程式碼：

from flask import Flask, request, jsonify
import pandas as pd
from sklearn.externals import joblib

app = Flask(__name__)

# 載入模型
MODEL_PATH_LDA = 'lda_model.pkl'
MODEL_PATH_NN = 'nn_model.pkl'
clf_lda = joblib.load(MODEL_PATH_LDA)
clf_nn = joblib.load(MODEL_PATH_NN)

# API 1: 預測
@app.route('/prediction/<int:line>', methods=['POST', 'GET'])
def prediction(line):
    # 載入資料
    data = pd.read_json('./test.json')
    data_test = data.transpose()
    X = data_test.drop(data_test.loc[:, 'Line':'# Letter'].columns, axis=1)
    X_test = X.iloc[line, :].values.reshape(1, -1)
    
    # 預測
    prediction_lda = clf_lda.predict(X_test)
    prediction_nn = clf_nn.predict(X_test)
    
    # 傳回預測結果
    return jsonify({'prediction LDA': int(prediction_lda), 'prediction Neural Network': int(prediction_nn)})

# API 2: 評分
@app.route('/score', methods=['POST', 'GET'])
def score():
    # 載入資料
    data = pd.read_json('./test.json')
    data_test = data.transpose()
    X = data_test.drop(data_test.loc[:, 'Line':'# Letter'].columns, axis=1)
    
    # 評分
    score_lda = clf_lda.score(X)
    score_nn = clf_nn.score(X)
    
    # 傳回評分結果
    return jsonify({'score LDA': score_lda, 'score Neural Network': score_nn})

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

使用Docker佈署API

接下來，我們需要使用Docker佈署API。以下是Dockerfile程式碼：

FROM python:3.9-slim

# 載入模型
COPY lda_model.pkl /app/
COPY nn_model.pkl /app/

# 載入資料
COPY test.json /app/

# 安裝依賴函式庫
RUN pip install flask scikit-learn pandas

# 執行API
CMD ["python", "app.py"]

使用Kubernetes佈署API

最後，我們需要使用Kubernetes佈署API。以下是deployment.yaml程式碼：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: flask-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: flask-api
  template:
    metadata:
      labels:
        app: flask-api
    spec:
      containers:
      - name: flask-api
        image: flask-api:latest
        ports:
        - containerPort: 5000

佈署和測試

現在，我們可以佈署API並進行測試。以下是命令：

# 建立Docker映象
docker build -t flask-api.

# 佈署API到Kubernetes
kubectl apply -f deployment.yaml

# 測試API
curl http://localhost:5000/prediction/1
curl http://localhost:5000/score

這樣，我們就完成了使用Docker、Python Flask API和Kubernetes進行實時機器學習預測的過程。

使用Flask和Scikit-learn進行機器學習模型佈署

在這個範例中，我們將使用Flask框架建立一個簡單的Web伺服器，負責提供機器學習模型的預測結果。同時，我們也會使用Scikit-learn函式庫訓練和儲存兩個不同的機器學習模型：線性判別分析（LDA）和多層感知器（MLP）。

訓練模型

首先，我們需要訓練和儲存機器學習模型。這個過程在train.py檔案中完成。以下是相關程式碼：

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

def train():
    # 載入資料
    data = pd.read_csv('train.csv')
    
    # 對資料進行預處理
    X = data.drop(['target'], axis=1)
    y = data['target']
    X_scaled = preprocessing.StandardScaler().fit_transform(X)
    
    # 訓練LDA模型
    clf_lda = LinearDiscriminantAnalysis()
    clf_lda.fit(X_scaled, y)
    
    # 訓練MLP模型
    clf_nn = MLPClassifier()
    clf_nn.fit(X_scaled, y)
    
    # 儲存模型
    dump(clf_lda, 'lda_model.joblib')
    dump(clf_nn, 'nn_model.joblib')

建立Flask應用程式

接下來，我們需要建立一個Flask應用程式，負責提供機器學習模型的預測結果。以下是相關程式碼：

from flask import Flask, request, jsonify
from joblib import load

app = Flask(__name__)

# 載入模型
clf_lda = load('lda_model.joblib')
clf_nn = load('nn_model.joblib')

# 定義路由
@app.route('/predict', methods=['POST'])
def predict():
    # 取得輸入資料
    data = request.get_json()
    
    # 對資料進行預處理
    X_scaled = preprocessing.StandardScaler().fit_transform(data)
    
    # 使用LDA模型進行預測
    y_pred_lda = clf_lda.predict(X_scaled)
    
    # 使用MLP模型進行預測
    y_pred_nn = clf_nn.predict(X_scaled)
    
    # 回傳預測結果
    return jsonify({'LDA': y_pred_lda, 'NN': y_pred_nn})

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

測試應用程式

最後，我們可以使用以下程式碼測試應用程式：

import requests

# 準備輸入資料
data = {'feature1': [1, 2, 3], 'feature2': [4, 5, 6]}

# 送出請求
response = requests.post('http://localhost:5000/predict', json=data)

# 取得預測結果
print(response.json())

這個範例展示瞭如何使用Flask和Scikit-learn進行機器學習模型佈署。同時，也展示瞭如何使用Flask建立一個簡單的Web伺服器，負責提供機器學習模型的預測結果。

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

資料載入與預處理

首先，我們需要載入訓練資料。假設我們的訓練資料儲存於train.csv檔案中。

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

# 載入訓練資料
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)

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

資料正規化

為了確保模型的最佳效能，我們需要對資料進行正規化。這裡，我們使用L2正規化。

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

模型訓練

線性判別分析（LDA）

首先，我們訓練一個線性判別分析模型。

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

序列神經網路（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)

模型序列化

為了方便地佈署模型，我們需要將模型序列化。

from joblib import dump

# 序列化LDA模型
MODEL_PATH_LDA = "path/to/model/lda_model.joblib"
dump(clf_lda, MODEL_PATH_LDA)

# 序列化MLP模型
MODEL_PATH_NN = "path/to/model/mlp_model.joblib"
dump(clf_NN, MODEL_PATH_NN)

佈署模型

現在，我們可以使用Docker、Flask和Kubernetes來佈署這些模型，實作實時預測。以下是簡單的Flask API範例：

from flask import Flask, request, jsonify
import joblib

app = Flask(__name__)

# 載入序列化模型
lda_model = joblib.load(MODEL_PATH_LDA)
mlp_model = joblib.load(MODEL_PATH_NN)

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    # 預處理資料
    X_new = pd.DataFrame([data])
    X_new = normalize(X_new, norm='l2')
    
    # 使用LDA模型進行預測
    prediction_lda = lda_model.predict(X_new)
    
    # 使用MLP模型進行預測
    prediction_mlp = mlp_model.predict(X_new)
    
    return jsonify({'LDA Prediction': prediction_lda.tolist(), 'MLP Prediction': prediction_mlp.tolist()})

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

這個API可以接受JSON格式的資料，對其進行預處理，然後使用既有的LDA和MLP模型進行預測，最後傳回預測結果。

使用Kubernetes佈署

你可以使用Kubernetes來佈署這個Flask API，確保其高用性和擴充套件性。以下是一個簡單的佈署範例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-prediction-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ml-prediction-api
  template:
    metadata:
      labels:
        app: ml-prediction-api
    spec:
      containers:
      - name: ml-prediction-api
        image: your-docker-image-name
        ports:
        - containerPort: 5000

這個 YAML 檔案定義了一個名為 ml-prediction-api 的佈署，包含三個副本，每個副本執行你的Docker映象。你的Docker映象應該包含Flask API的程式碼和所需的依賴項。

透過這些步驟，你可以建立一個強大的機器學習預測系統，利用Docker、Flask和Kubernetes實作實時預測和高用性。

使用Docker和Kubernetes佈署機器學習模型

在上一節中，我們已經訓練並儲存了機器學習模型。現在，我們將使用Docker和Kubernetes將模型佈署到生產環境中。

6.7.3 建立Docker映像

首先，我們需要建立一個Docker映像，該映像包含我們的機器學習模型和相關依賴項。下面是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./
RUN pip install -r requirements.txt

COPY train.csv./
COPY test.json./
COPY train.py./
COPY api.py./

RUN python3 train.py

這個Dockerfile使用jupyter/scipy-notebook作為基礎映像，然後建立一個名為my-model的目錄，並設定環境變數MODEL_DIR、MODEL_FILE_LDA和MODEL_FILE_NN。接下來，它複製requirements.txt、train.csv、test.json、train.py和api.py到映像中，然後執行train.py以訓練和儲存機器學習模型。

6.7.4 執行Docker容器

建立好Docker映像後，我們可以執行Docker容器以測試模型。下面是執行容器的命令：

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

這個命令執行my-kube-api容器，並將容器的5000埠對映到主機的5000埠。然後，它執行api.py以啟動Flask網路伺服器。

6.7.5 建立和準備虛擬機器

在佈署Kubernetes叢集之前，我們需要建立虛擬機器。下面是建立虛擬機器的步驟：

建立兩臺虛擬機器：kubmaster和kubenode1
組態虛擬機器的網路設定，以便它們可以相互通訊

6.7.6 安裝Kubeadm

在虛擬機器上安裝Kubeadm之前，我們需要安裝Docker引擎。下面是安裝Docker引擎的步驟：

更新apt包索引
安裝必要的包以允許apt使用HTTPS連線
新增Docker的官方GPG金鑰
設定穩定倉函式庫
安裝最新版本的Docker引擎和容器

然後，我們可以安裝Kubeadm和相關二進位制檔案。下面是安裝Kubeadm的步驟：

下載Kubernetes二進位制檔案的GPG金鑰
安裝Kubeadm、kubectl和kubelet

6.7.7 建立Kubernetes叢集

安裝好Kubeadm和相關二進位制檔案後，我們可以建立Kubernetes叢集。下面是建立叢集的步驟：

初始化主節點（kubmaster）
組態網路設定以連線不同節點

建立好叢集後，我們可以使用kubectl命令列工具管理叢集。

內容解密：

在這個章節中，我們學習瞭如何使用Docker和Kubernetes佈署機器學習模型。首先，我們建立了一個Docker映像，該映像包含我們的機器學習模型和相關依賴項。然後，我們執行Docker容器以測試模型。接下來，我們建立和準備虛擬機器，安裝Kubeadm和相關二進位制檔案，最後建立Kubernetes叢集。

圖表翻譯：

  graph LR
    A[Dockerfile] -->|建立|> B[Docker映像]
    B -->|執行|> C[Docker容器]
    C -->|測試|> D[機器學習模型]
    D -->|佈署|> E[Kubernetes叢集]
    E -->|管理|> F[kubectl]

這個圖表展示了使用Docker和Kubernetes佈署機器學習模型的流程。首先，我們建立Dockerfile，然後建立Docker映像。接下來，我們執行Docker容器以測試模型。最後，我們佈署模型到Kubernetes叢集，並使用kubectl命令列工具管理叢集。

建立 Kubernetes叢集並佈署機器學習模型

在這個章節中，我們將學習如何建立一個 Kubernetes叢集並佈署一個機器學習模型。首先，我們需要建立一個 Kubernetes叢集。

建立 Kubernetes叢集

要建立一個 Kubernetes叢集，我們需要先安裝 Flannel 網路外掛。Flannel 是一個簡單的網路外掛，可以幫助我們建立一個 Kubernetes叢集內的網路。

mkdir -p $HOME/.kube
chown $(id -u):$(id -g) $HOME/.kube/config
sysctl net.bridge.bridge-nf-call-iptables=1

接下來，我們需要安裝 Flannel 網路外掛。可以使用以下命令：

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

安裝完成後，我們可以使用以下命令檢查 Pods 的狀態：

kubectl get pods --all-namespaces

如果所有 Pods 都正常執行，我們就可以加入節點到叢集中。可以使用以下命令：

kubeadm join 192.168.1.55:6443 --token 08hcql.zbbieukn1h96f1px \
--discovery-token-ca-cert-hash sha256:851d02642c9b2177dd89c8e7cf7178c36185d61799eaaec4fec99b172809373f

佈署機器學習模型

要佈署機器學習模型，我們需要先建立一個 namespace。可以使用以下 YAML 檔案：

apiVersion: v1
kind: Namespace
metadata:
  name: mlops

接下來，我們需要建立一個 deployment。可以使用以下 YAML 檔案：

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: my-app
    env: qa
  name: my-app
  namespace: mlops
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
        env: qa
    spec:
      containers:
      - image: xaviervasques/my-kube-api:latest
        name: my-kube-api
        command: ["python3", "api.py"]
        ports:
        - containerPort: 5000
          protocol: TCP

然後，我們需要建立一個 service。可以使用以下 YAML 檔案：

apiVersion: v1
kind: Service
metadata:
  name: my-app
  labels:
    app: my-app
  namespace: mlops
spec:
  type: LoadBalancer
  ports:
  - port: 5000
    targetPort: 5000
  selector:
    app: my-app

最後，我們需要建立一個 kustomization 檔案。可以使用以下 YAML 檔案：

kind: Kustomization
resources:
- namespace.yaml
- deployment.yaml
- service.yaml

然後，我們可以使用以下命令佈署應用程式：

kubectl apply --kustomize=${PWD}/base/ --record=true

檢查佈署狀態

要檢查佈署狀態，可以使用以下命令：

kubectl get ns
kubectl get deployment -n mlops
kubectl get service -n mlops

使用佈署的模型

要使用佈署的模型，可以使用以下命令：

curl http://localhost:5000/predict -X POST -H "Content-Type: application/json" -d @test.json

這將會傳回預測結果。

佈署機器學習應用於IBM Cloud Kubernetes Service

在本文中，我們將探討如何使用Python、Docker和Kubernetes佈署機器學習應用於IBM Cloud Kubernetes Service。首先，我們需要登入IBM Cloud CLI，使用以下命令：

ibmcloud login

如果您具有聯合ID，可以使用 ibmcloud login –sso 登入。否則，您可以使用IBM Cloud API key登入：

ibmcloud login --apikey <IBM CLOUD API KEY>

如果您尚未擁有API key，可以在IBM Cloud控制檯中建立一個。

接下來，我們需要安裝IBM Cloud Kubernetes Service外掛：

ibmcloud plugin install container-service

以及IBM Cloud Container Registry外掛：

ibmcloud plugin install container-registry

並安裝IBM Cloud Kubernetes Service observability外掛：

ibmcloud plugin install observe-service

如果您的環境中尚未安裝Kubernetes CLI，可以按照以下步驟安裝：https://kubernetes.io/docs/tasks/tools/install-kubectl/

列出叢集

要列出所有叢集，可以使用以下命令：

ibmcloud ks cluster ls

檢查叢集健康狀態

要檢查叢集的健康狀態，可以使用以下命令：

ibmcloud ks cluster get -c <叢集名稱>

容器化機器學習應用

在本文中，我們將示範如何使用Docker容器化機器學習應用。首先，我們需要建立以下檔案：

Dockerfile
train.py
api.py
requirements.txt

train.py 檔案是一個Python指令碼，負責載入和訓練模型。Dockerfile 將用於構建Docker映像，requirements.txt 檔案包含Python依賴項，api.py 指令碼將被呼叫以執行線上推理。

以下是 train.py 檔案的內容：

# train.py

from sklearn import svm
from joblib import dump, load
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris

def train():
    # 載入和分割資料
    iris = load_iris()
    X, y = iris.data, iris.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

    # 列印資料
    print(X_train)
    print(X_test)

內容解密：

在上述程式碼中，我們使用scikit-learn函式庫載入Iris資料集，並將其分割為訓練和測試資料。然後，我們列印預出訓練和測試資料。

圖表翻譯：

以下是使用Mermaid語法繪製的流程圖：

  flowchart TD
    A[載入資料] --> B[分割資料]
    B --> C[訓練模型]
    C --> D[評估模型]
    D --> E[儲存模型]

在這個流程圖中，我們展示了機器學習應用的基本流程：載入資料、分割資料、訓練模型、評估模型和儲存模型。

訓練模型並建立API

在本文中，我們將訓練一個支援向量機（SVM）模型，並將其儲存為檔案，以便於線上推斷。同時，我們也會建立一個API，負責接收資料並輸出模型的分類別結果。

訓練SVM模型

首先，我們需要訓練一個SVM模型。以下是訓練過程的程式碼：

from sklearn import svm
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris

# 載入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)

# 建立SVM模型
clf = svm.SVC()

# 訓練模型
clf.fit(X_train, y_train)
print("SVM模型訓練完成")

# 將訓練好的模型儲存為檔案
import joblib
joblib.dump(clf, 'svc_model.model')

建立API

接下來，我們需要建立一個API，負責接收資料並輸出模型的分類別結果。以下是API的程式碼：

from flask import Flask, request, jsonify
from joblib import load

app = Flask(__name__)

# 載入訓練好的模型
MODEL_DIR = os.environ["MODEL_DIR"]
MODEL_FILE = os.environ["MODEL_FILE"]
MODEL_PATH = os.path.join(MODEL_DIR, MODEL_FILE)
inference = load(MODEL_PATH)

# 定義API路由
@app.route('/predict', methods=['POST'])
def predict():
    # 接收資料
    data = request.get_json()
    X_test = data['X_test']

    # 使用模型進行預測
    y_pred = inference.predict(X_test)

    # 輸出預測結果
    return jsonify({'prediction': y_pred.tolist()})

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

在這個API中，我們定義了一個路由 /predict，負責接收資料並輸出模型的分類別結果。當收到請求時，API會使用訓練好的模型進行預測，並將結果以JSON格式輸出。

圖表翻譯：

  graph LR
    A[收到請求] --> B[載入模型]
    B --> C[進行預測]
    C --> D[輸出結果]

在這個圖表中，我們展示了API的工作流程。當收到請求時，API會載入訓練好的模型，進行預測，並將結果輸出。

佈署機器學習模型至生產環境

在上一節中，我們已經建立了一個簡單的機器學習模型，並使用 Flask 框架建立了一個 API 來提供預測服務。現在，我們將這個 API 佈署到生產環境中。

建立 Docker 映像

首先，我們需要建立一個 Docker 映像來封裝我們的 API。為此，我們需要建立一個 Dockerfile 檔案，該檔案包含了構建映像的指令。

FROM jupyter/scipy-notebook

# 建立一個目錄來儲存模型檔案
RUN mkdir my-model

# 設定環境變數
ENV MODEL_DIR=/home/jovyan/my-model
ENV MODEL_FILE=svc_model.model

# 複製 requirements.txt 檔案到映像中
COPY requirements.txt./requirements.txt

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

# 複製 train.py 和 api.py 檔案到映像中
COPY train.py./train.py
COPY api.py./api.py

# 暴露 5000 埠
EXPOSE 5000

# 執行 train.py 指令碼來訓練模型
RUN python3 train.py

建立和執行 Docker 映像

接下來，我們需要建立和執行 Docker 映像。為此，我們可以使用以下命令：

docker build -t my-kube-api -f Dockerfile.
docker run -it -p 5000:5000 my-kube-api python3 api.py

測試 API

現在，我們可以使用 curl 命令來測試 API：

curl -X POST http://localhost:5000/score

如果一切正常，API 應該會傳回預測結果。

內容解密：

在上面的程式碼中，我們使用了 Flask 框架來建立一個 API，該 API 提供預測服務。為此，我們需要建立一個 Dockerfile 檔案來封裝 API，然後使用 Docker 建立和執行映像。最後，我們可以使用 curl 命令來測試 API。

圖表翻譯：

以下是 Docker 容器化過程的流程圖：

  flowchart TD
    A[建立 Dockerfile] --> B[建立 Docker 映像]
    B --> C[執行 Docker 映像]
    C --> D[測試 API]
    D --> E[傳回預測結果]

在這個流程圖中，我們可以看到 Docker 容器化過程的各個步驟，從建立 Dockerfile 檔案到測試 API。

佈署機器學習應用至IBM Cloud Kubernetes Service

在確認應用程式運作正常後，我們可以將其佈署至Kubernetes叢集。但在此之前，我們需要將映像檔推播至倉儲。這裡，我們將使用IBM Cloud Registry（私人倉儲）。

推播映像檔至IBM Cloud Registry

首先，從我們的帳戶儀錶板中，我們可以選擇容器倉儲。然後，我們需要在本地安裝容器倉儲外掛，使用以下命令：

ibmcloud plugin install container-registry -r "IBM Cloud"

接下來，我們登入帳戶：

ibmcloud login

建立並命名名稱空間：

ibmcloud cr namespace-add xaviervasques

登入本地Docker daemon至IBM Cloud Container Registry：

ibmcloud cr login

選擇倉儲並標籤映像檔：

docker tag <image_name> <region_url>/<namespace>/<image_name>:<tag>

推播映像檔：

docker push <region_url>/<namespace>/<image_name>:<tag>

驗證映像檔狀態

驗證映像檔狀態：

ibmcloud cr image-list

圖表翻譯：

  flowchart TD
    A[登入帳戶] --> B[建立名稱空間]
    B --> C[登入本地Docker daemon]
    C --> D[選擇倉儲並標籤映像檔]
    D --> E[推播映像檔]
    E --> F[驗證映像檔狀態]

佈署應用程式至Kubernetes

一旦映像檔已上傳至私人倉儲，我們可以佈署應用程式至Kubernetes。這裡，我們使用CLI。建立Kubernetes叢集：

ibmcloud ks cluster create classic --name my-cluster

檢視叢集狀態：

ibmcloud ks clusters

連線kubectl至叢集：

ibmcloud ks cluster config --cluster my_k8s

驗證連線：

kubectl get nodes

建立目錄並建立YAML檔案：

mkdir base
cd base
touch namespace.yaml deployment.yaml service.yaml service_port.yaml kustomization.yaml

內容解密：

- namespace.yaml：提供Kubernetes資源範圍。
- deployment.yaml：管理一組相同的Pods。
- service.yaml：暴露應用程式為網路服務。
- service_port.yaml：使容器化應用程式可透過NodePort存取。
- kustomization.yaml：組態自定義映像檔提取秘密。

圖表翻譯：

  flowchart TD
    A[建立目錄] --> B[建立YAML檔案]
    B --> C[組態namespace.yaml]
    C --> D[組態deployment.yaml]
    D --> E[組態service.yaml]
    E --> F[組態service_port.yaml]
    F --> G[組態kustomization.yaml]

佈署應用程式

佈署應用程式：

kubectl apply --kustomize=${PWD}/base/ --record=true

複製映像檔提取秘密：

kubectl get secret all-icr-io -n default -o yaml | sed 's/default/mlapi/g' | kubectl create -n mlapi -f -

檢視秘密建立狀態：

kubectl get secrets -n mlapi | grep icr-io

檢視所有佈署元件：

kubectl get ns

檢視佈署狀態：

kubectl get deployment -n mlapi

檢視服務狀態：

kubectl get service -n mlapi

圖表翻譯：

  flowchart TD
    A[佈署應用程式] --> B[複製映像檔提取秘密]
    B --> C[檢視秘密建立狀態]
    C --> D[檢視所有佈署元件]
    D --> E[檢視佈署狀態]
    E --> F[檢視服務狀態]

6.9 Red Hat OpenShift 用於企業機器學習/深度學習應用開發與佈署

隨著機器學習（ML）和深度學習（DL）的投資不斷增加，企業開始關注如何創造價值，例如簡化複雜性、實作自動化、降低成本、增長業務、更好地服務客戶、進行發現和研究等。強大的開源社群已經形成，致力於讓資料科學家和開發人員能夠存取和使用機器學習/深度學習技術。

然而，在本地電腦上工作和將機器學習/深度學習模型佈署到生產環境之間存在著巨大的差距。企業需要在多架構環境或混合雲環境中佈署機器學習工作流程。當前的資料中心由異構系統組成，包括 x86、IBM Power Systems、IBM Z、高效能運算、加速器（如 GPU 或 FPGA）等，執行著各種專業的機器學習/深度學習框架。

Red Hat OpenShift 是一個根據 Kubernetes 的容器應用平臺，為企業應用開發和佈署提供了額外的能力。它是一個認證的 Kubernetes 平臺和分發版，提供了強大的安全性、開發者友好環境、叢集管理、整合構建和 CI/CD 服務等功能。

6.9.1 什麼是 OpenShift？

OpenShift 是一個根據 Kubernetes 的容器應用平臺，為企業應用開發和佈署提供了額外的能力。它是一個認證的 Kubernetes 平臺和分發版，提供了強大的安全性、開發者友好環境、叢集管理、整合構建和 CI/CD 服務等功能。

6.9.2 OpenShift 和 Kubernetes 的區別

Kubernetes 有許多分發版和依賴於社群或外部專業知識。如果公司需要官方支援，尤其是對於關鍵業務應用，則需要更多的方面考慮，例如強大的安全性、開發者友好環境、叢集管理、整合構建和 CI/CD 服務等。

OpenShift 提供了更多的功能和優勢，包括：

更加嚴格的預設策略
內建的角色基礎存取控制（RBAC）
支援 Kubernetes Operators 和 Deployments
支援第三方工具，如 Helm Charts、Prometheus、Istio、Knative 等
內建的容器映像管理和自動更新
支援多租戶環境和多叢集管理

6.9.3 為什麼選擇 Red Hat OpenShift 來構建生產就緒的 ML/DL 環境？

Red Hat OpenShift 可以幫助資料科學家和開發人員專注於他們的模型和程式碼，並將其佈署到 Kubernetes 中，而無需深入瞭解 Kubernetes。它提供了一種簡單的方式來管理複雜性，並允許佈署任何容器化的 ML/DL 堆積疊在任何環境中。

6.10 在 Red Hat OpenShift 容器平臺上佈署機器學習模型作為 API

本文將展示如何在 OpenShift 叢集上佈署一個簡單的機器學習模型。該模型是使用 Python 開發的，並使用 Flask 和 Scikit-Learn 等函式庫進行實作。

6.10.1 建立 OpenShift 叢集例項

首先，需要建立一個 OpenShift 叢集例項。這可以透過 IBM Cloud 平臺完成。

6.10.1.1 佈署應用程式從 GitHub 儲存函式庫

然後，需要建立一個新的 OpenShift Enterprise 應用程式從原始碼。這可以透過 OpenShift Web 控制檯或 CLI 完成。

示例程式碼

以下是示例程式碼：

import os
from sklearn import svm
from joblib import dump, load
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris

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

    # 載入和分割資料
    iris = load_iris()
    X, y = iris.data, iris.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

圖表翻譯：

  graph LR
    A[資料載入] --> B[資料分割]
    B --> C[模型訓練]
    C --> D[模型評估]
    D --> E[模型佈署]

內容解密：

以上程式碼展示瞭如何使用 Python 和 Scikit-Learn 等函式庫進行機器學習模型的訓練和評估。首先，需要載入資料並分割成訓練集和測試集。然後，需要訓練模型並評估其效能。最後，需要將模型佈署到生產環境中。

圖表說明：

以上圖表展示了機器學習模型的生命週期，包括資料載入、資料分割、模型訓練、模型評估和模型佈署等階段。

佈署機器學習模型為 API 於 Red Hat OpenShift 容器平臺

在本文中，我們將探討如何將機器學習模型佈署為 API 於 Red Hat OpenShift 容器平臺。這涉及到模型的訓練、儲存、載入以及使用 Flask 框架建立 API 來提供預測服務。

訓練模型

首先，我們需要訓練一個機器學習模型。以下是使用支援向量機（SVM）演算法的 iris 資料集進行訓練的示例：

from sklearn import svm
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from joblib import dump

# 載入 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)

# 訓練 SVM 模型
clf = svm.SVC()
clf.fit(X_train, y_train)

# 儲存訓練好的模型
MODEL_DIR = "models"
MODEL_FILE = "svm_model.joblib"
MODEL_PATH = os.path.join(MODEL_DIR, MODEL_FILE)
dump(clf, MODEL_PATH)

建立 API

接下來，我們需要建立一個 API 來提供預測服務。以下是使用 Flask 框架的示例：

from flask import Flask, request, jsonify
from joblib import load

app = Flask(__name__)

# 載入儲存的模型
MODEL_DIR = "models"
MODEL_FILE = "svm_model.joblib"
MODEL_PATH = os.path.join(MODEL_DIR, MODEL_FILE)
inference = load(MODEL_PATH)

# 定義預測 API
@app.route("/predict", methods=["POST"])
def predict():
    # 取得請求資料
    data = request.get_json()
    # 進行預測
    prediction = inference.predict(data)
    # 回傳預測結果
    return jsonify({"prediction": prediction.tolist()})

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

佈署於 Red Hat OpenShift 容器平臺

最後，我們需要將 API 佈署於 Red Hat OpenShift 容器平臺。這涉及到建立一個 Docker 映像檔、推播到 Docker Hub，以及佈署於 OpenShift 平臺。

以下是 Dockerfile 的示例：

FROM python:3.9-slim

# 設定工作目錄
WORKDIR /app

# 複製 requirements.txt 檔案
COPY requirements.txt.

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

# 複製應用程式碼
COPY..

# 暴露 port 5000
EXPOSE 5000

# 執行命令
CMD ["flask", "run", "--host=0.0.0.0"]

推播 Docker 映像檔到 Docker Hub：

docker build -t my-ml-api.
docker tag my-ml-api:latest <your-docker-hub-username>/my-ml-api:latest
docker push <your-docker-hub-username>/my-ml-api:latest

佈署於 OpenShift 平臺：

oc new-app <your-docker-hub-username>/my-ml-api:latest --name=my-ml-api
oc expose svc my-ml-api --port=5000

現在，您可以使用 oc get route 命令取得 API 的路由，並使用 curl 命令進行預測請求：

curl -X POST -H "Content-Type: application/json" -d '{"data": [[5.1, 3.5, 1.4, 0.2]]}' http://my-ml-api-default.<your-openshift-domain>/predict

這樣，您就成功地將機器學習模型佈署為 API 於 Red Hat OpenShift 容器平臺了！

使用Flask建立機器學習模型的API服務

在這個範例中，我們將使用Flask框架建立一個簡單的API服務，提供機器學習模型的預測功能。首先，我們需要建立一個Flask應用程式，並定義一個路由來處理HTTP請求。

定義Flask路由

from flask import Flask, request, jsonify
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn import svm
import pickle
import os

app = Flask(__name__)

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

# 切分資料集為訓練集和測試集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

# 載入模型
MODEL_PATH = 'svc_model.model'
clf = pickle.load(open(MODEL_PATH, 'rb'))

# 定義路由
@app.route('/', methods=['POST', 'GET'])
def prediction():
    # 預測分數
    score = clf.score(X_test, y_test)
    return {'score': score}

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

建立Docker映像

接下來，我們需要建立一個Docker映像來佈署我們的API服務。以下是Dockerfile的內容：

FROM jupyter/scipy-notebook
RUN mkdir my-model
ENV MODEL_DIR=/home/jovyan/my-model
ENV MODEL_FILE=svc_model.model
COPY requirements.txt./requirements.txt
RUN pip install -r requirements.txt
COPY train.py./train.py
COPY api.py./api.py
EXPOSE 8080
RUN python3 train.py

解釋Dockerfile

FROM jupyter/scipy-notebook: 使用jupyter/scipy-notebook作為基礎映像。
RUN mkdir my-model: 建立一個新的目錄叫做my-model。
ENV MODEL_DIR=/home/jovyan/my-model: 設定環境變數MODEL_DIR為/home/jovyan/my-model。
ENV MODEL_FILE=svc_model.model: 設定環境變數MODEL_FILE為svc_model.model。
COPY requirements.txt./requirements.txt: 複製requirements.txt到目前目錄。
RUN pip install -r requirements.txt: 安裝requirements.txt中的套件。
COPY train.py./train.py: 複製train.py到目前目錄。
COPY api.py./api.py: 複製api.py到目前目錄。
EXPOSE 8080: 將8080埠暴露給外部。
RUN python3 train.py: 執行train.py指令碼。

圖表翻譯：

  graph LR;
    A[建立Flask應用程式] -->|定義路由|> B[載入iris資料集];
    B -->|切分資料集|> C[載入模型];
    C -->|定義預測函式|> D[建立Docker映像];
    D -->|複製requirements.txt|> E[安裝套件];
    E -->|複製train.py和api.py|> F[暴露8080埠];
    F -->|執行train.py指令碼|> G[啟動Flask服務];

內容解密：

在這個範例中，我們使用Flask框架建立了一個簡單的API服務，提供機器學習模型的預測功能。首先，我們載入iris資料集，並切分資料集為訓練集和測試集。接下來，我們載入模型，並定義一個路由來處理HTTP請求。最後，我們建立了一個Docker映像來佈署我們的API服務。

圖表說明：

上述圖表展示了建立Flask應用程式、載入iris資料集、切分資料集、載入模型、定義預測函式、建立Docker映像、複製requirements.txt、安裝套件、複製train.py和api.py、暴露8080埠、執行train.py指令碼和啟動Flask服務的流程。

隨著機器學習應用日益普及，模型佈署的效率和可擴充套件性成為關鍵。本文深入探討了使用 Docker、Flask 與 Kubernetes 佈署機器學習模型的流程，並涵蓋了 IBM Cloud 和 Red Hat OpenShift 等平臺的實務操作。分析顯示，容器化技術有效簡化了模型佈署的複雜性，Kubernetes 則賦予了應用程式高用性和彈性擴充套件能力。然而，不同平臺的整合與組態管理仍存在挑戰，需要技術團隊深入理解各個元件的互動和最佳實踐。展望未來，Serverless 技術和模型自動化佈署工具的發展將進一步降低機器學習應用的門檻，加速其在各個產業的落地。玄貓認為，掌握這些技術對於提升企業競爭力至關重要，技術團隊應優先投入資源學習並應用於實際專案中。

玄貓

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