Gitlab CI/CD für Machine Learning-Projekt einrichten | von Andreas Chandra | Datenleute Indonesien | Juni 2023

Bitte lesen Sie diese Seiten, um das Konzept von CI/CD zu verstehen

Lass uns weitermachen:

• Erstellen Sie ein Gitlab-Konto auf gitlab.com
• Erstellen fly.io Konto für die Net-API-Bereitstellung
• Erstellen Sie ein Repository auf gitlab.com

laufen git clone git@gitlab.com:<your-username>/iris-api.git

• Erstellen Sie eine einfache RESTFUL-API

Erstellen src/most important.py

"""Iris Net API Service."""
from fastapi import FastAPI
from pydantic import BaseModel
import numpy as np
from src import distance, iris
dataset = iris.get_iris_data()
app = FastAPI()
class Merchandise(BaseModel):
"""Enter class for predict endpoint.
Args:
BaseModel (BaseModle): Inherited from pydantic
"""
sepal_length: float
sepal_width: float
petal_length: float
petal_width: float
@app.get("/")
def homepage():
"""Homepage for the online.
Returns:
str: Homepage
"""
return "Homepage Iris Flower - tags 0.0.2"
@app.put up("/predict/")
async def predict(merchandise: Merchandise):
"""Predict operate for inference.
Args:
merchandise (Merchandise): dictionary of sepal dan petal information
Returns:
str: predict the goal
"""
sepal_length = merchandise.sepal_length
sepal_width = merchandise.sepal_width
petal_length = merchandise.petal_length
petal_width = merchandise.petal_width
data_input = np.array([[sepal_length, sepal_width, petal_length, petal_width]])
consequence = distance.calculate_manhattan(dataset, data_input)
return consequence

Erstellen src/iris.py

"""Load iris dataset from scikit-learn."""
from sklearn import datasets
def get_iris_data():
"""Load iris dataset.
Returns:
set: consists of X, y, characteristic names, and target_names
"""
iris = datasets.load_iris()
x_data = iris.information
y_label = iris.goal
features_names = ["sepal_length", "sepal_width", "petal_length", "petal_width"]
target_names = iris.target_names
return x_data, y_label, features_names, target_names
if __name__ == "__main__":
x_data, y_label, options, target_names = get_iris_data()
print("X", x_data)
print("y", y_label)
print("options", options)
print("target_names", target_names)

Erstellen src/distance.py

"""Distance module for calculating distance between information enter and dataset."""
import numpy as np
def calculate_manhattan(iris_data: np.ndarray, input_data: np.ndarray):
"""Calculate the gap between 2 vectors utilizing manhattan distance.
Args:
dataset (np.ndarray): Iris dataset
input_data (np.ndarray): 1x4 matrix information enter
Returns:
string: Return prediction
"""
x_data, y_label, _, target_names = iris_data
distance = np.sqrt(np.sum(np.abs(x_data - input_data), axis=1))
distance_index = np.argsort(distance)
y_pred = target_names[y_label[distance_index[0]]]
return y_pred
if __name__ == "__main__":
dataset = [
np.array([[4.9, 3.0, 1.4, 0.2], [4.9, 3.0, 1.4, 0.9]]),
[0, 0],
["sepal_length", "sepal_width", "petal_length", "petal_width"],
["setosa", "versicolor", "virginica"],
]
sample_data = np.array([[4.9, 3.0, 1.4, 0.2]])
print(calculate_manhattan(dataset, sample_data))

Erstellen check/test_distance.py

import numpy as np
from src.iris import get_iris_data
from src.distance import calculate_manhattan 
def test_calculate_manhattan():
dataset = get_iris_data()
input_data = np.array([[4.9, 3.0, 1.4, 0.2]])
consequence = calculate_manhattan(dataset, input_data)
assert consequence == 'setosa'

Erstellen Sie eine Docker-Datei

FROM python:3.10
EXPOSE 8000
WORKDIR /app
COPY . .
RUN pip set up -r necessities.txt
ENTRYPOINT ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port",  "8000"]

Machen necessities.txt

# python
pydoclint>=0.0.10
pylint>=2.17.0
black>=22.6.0
pydocstyle>=6.1.1
pytest>=7.1.2
# net app
fastapi>=0.98.0
uvicorn>=0.22.0
# fashions
numpy>=1.21.6
scikit-learn>=1.2.2

Erstellen fly.toml

app = "iris-api-demo-stg"
primary_region = "sin"
[build]
dockerfile = "Dockerfile"
[http_service]
internal_port = 8000
force_https = true
auto_stop_machines = true
auto_start_machines = true
min_machines_running = 0

Als Erstes installieren Sie bitte flyctl auf Ihrem Laptop, indem Sie diesem Hyperlink folgen https://fly.io/docs/hands-on/install-flyctl/

Führen Sie dann die Authentifizierung durch flyctl auth login

Dann erstellen Sie hier Ihren persönlichen Zugangstoken für Gitlab https://fly.io/user/personal_access_tokens Speichern Sie den Token in Ihrem Notizblock. Später werden wir den Token zur Gitlab-Umgebung hinzufügen.

Jetzt müssen Sie zwei Apps erstellen: Staging und Produktion.

Staging-App

flyctl launch --auto-confirm --copy-config --dockerfile Dockerfile --name iris-api-demo-stg --now --org private --region sin

Produktions-App

flyctl launch --auto-confirm --copy-config --dockerfile Dockerfile --name iris-api-demo--now --org private --region sin

Vergessen Sie nicht, für Bereitstellungszwecke das Zugriffstoken fly.io zur Gitlab-Umgebung hinzuzufügen. Fügen Sie eine Variable hinzu und nennen Sie sie FLY_TOKEN.

*Trommelwirbel*

Konzentrieren wir uns hier nun auf den Hauptinhalt, die Konfiguration der CI/CD-Pipline.

• Erstellen wir eine neue Datei mit dem Namengitlab-ci.yml und nennen Sie dies v1

picture: python:newest
docker-build:
stage: construct
script:
- echo "Construct Docker"
code-test:
stage: check
script:
- echo "Run Code Take a look at"
manufacturing:
stage: deploy
atmosphere: manufacturing
script:
- echo "Deploy to fly.io"

Dies ist ein einfaches Gitlab-CI, das jeden einzelnen Push ausführt, den Sie zum Distant-Repo ausführen. Wenn Sie eine Änderung vornehmen, werden drei Jobs ausgelöst. Docker-Construct, Code-Take a look at und Produktion.

Lassen Sie uns näher darauf eingehen, wie die Dinge funktionieren.

picture: python:newest bedeutet, dass alle diese Jobs auf dem Docker-Picture der neuesten Python-Model ausgeführt werden, das Sie finden können Docker-Hub.

docker-build ist der Identify des Jobs. Der Identify des Jobs kann beliebig sein und Sie können mehrere Jobs in einer einzigen .yml-Datei erstellen.

stage bedeutet, in welche Part dieser Job fällt. Es gibt drei gemeinsame Phasen in der CI/CD-Pipeline: Erstellen, Testen und Bereitstellen.

atmosphere wird verwendet, um anzugeben, in welcher Umgebung dieser Job ausgeführt wird. Sie erhalten eine Liste von Jobs mit bestimmten Umgebungen. Auf diese Weise können Sie festlegen, welches Commit Sie erneut bereitstellen möchten. Daher ist es einfacher, wenn in der Staging- oder Produktionsumgebung etwas schief geht.

script ermöglicht es Ihnen, einen Shell-Befehl in den Container zu schreiben. Stellen Sie sich vor, dass im Terminal eine Reihe von Skripten ausgeführt wird.

Sobald Sie fertig sind:

git add gitlab-ci.yml

git commit -m "add gitlab-ci.yml

git push

Anschließend können Sie zur Registerkarte „Pipeline“ navigieren

Wie Sie sehen können, gibt es drei grüne Häkchen, die anzeigen, dass erfolgreiche Jobs ausgeführt wurden. Wenn dies fehlschlägt, ist das Image ein rotes Kreuz.

Jetzt haben Sie eine einfache Pipeline erstellt.

Erstellen wir eine Pipeline, die normalerweise für die ML-API-Entwicklung verwendet wird.

picture: python:newest
code-check:
stage: construct
solely:
- merge_requests
script:
- echo "Construct Docker"
- pip set up -r necessities.txt
- pylint src --rcfile=.pylintrc
- black src --check
- pydocstyle src
code-test:
stage: check
solely:
- merge_requests
script:
- echo "Run Code Take a look at"
- pip set up -r necessities.txt
- pytest
staging:
stage: deploy
atmosphere: staging
solely:
- staging
script:
- echo "Deploy to fly.io in staging atmosphere"
- curl -L https://fly.io/set up.sh | sh
- bash
- /root/.fly/bin/flyctl deploy --app iris-api-demo-stg --access-token $FLY_TOKEN
manufacturing:
stage: deploy
atmosphere: manufacturing
solely:
- tags
script:
- echo "Deploy to fly.io in manufacturing atmosphere"
- curl -L https://fly.io/set up.sh | sh
- /root/.fly/bin/flyctl deploy --app iris-api-demo --access-token $FLY_TOKEN

Wir haben 4 Jobs:

• code-check Dieser Job führt eine Codequalitätsprüfung durch, z. B. Linting mit Pylint, Formatter mit Black und DocString mit Pydocstyle. Dies wird verwendet, um sicherzustellen, dass der geschriebene Code den Richtlinien entspricht. Dieser Job wird nur auf Zusammenführungsanforderung ausgeführt. Wenn Sie nur zum Distant-Zweig pushen, wird dieser Job nicht ausgelöst.
• code-test Dann haben wir den Codetest durchgeführt und oben bereits einen einfachen Komponententest erstellt test_main.pyDadurch soll sichergestellt werden, dass das von uns erstellte Modul wie erwartet funktioniert.
• staging Dieser Job wird ausgeführt, wenn die Zusammenführungsanforderung im Staging-Zweig genehmigt wurde. Dies wird mithilfe der Staging-Anwendung automatisch auf fly.io bereitgestellt. Auf diese Weise können Sie einen Benutzerakzeptanztest durchführen.
• manufacturing Schließlich haben wir einen Produktionsauftrag. Der Zweck ist mit Staging eins ziemlich ähnlich. Dieser Job wird ausgelöst, wenn Sie ein Tag im Repository erstellen.

Sobald Sie eine Zusammenführungsanforderung erstellt und in den Staging-Zweig zusammengeführt haben. Es wird in der Staging-App bereitgestellt. Wenn es wie erwartet ist, können Sie mit der Zusammenführungsanfrage im Hauptzweig fortfahren und diese dann genehmigen. Sobald Sie fertig sind, können Sie ein Tag erstellen, um es in der Produktions-Webanwendung bereitzustellen.

Das ist mehr oder weniger die Einrichtung von CI/CD auf Gitlab. Dies magazine vereinfacht erscheinen, ich werde immer komplexere Pipelines erstellen, die MLOps wie Modellverfolgung, Datenversionierung, Modellregistrierung, Modellüberwachung usw. umfassen. Klicken Sie auf die Schaltfläche „Folgen“ und stellen Sie bitte eine Verbindung zu LinkedIn unter her https://www.linkedin.com/in/chandraandreas/