Artificial Intelligence (AI)

GitHub Actions For Machine Learning Beginners

Written by smirow

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen
Bild vom Autor

GitHub Actions ist eine leistungsstarke Funktion der GitHub-Plattform, die dabei hilft, Softwareentwicklungs-Workflows wie das Testen, Erstellen und Bereitstellen von Code zu automatisieren. Dies rationalisiert nicht nur den Entwicklungsprozess, sondern macht ihn auch zuverlässiger und effizienter.

In diesem Tutorial erfahren Sie, wie Sie GitHub Actions für ein maschinelles Lernprojekt (ML) für Einsteiger verwenden. Von der Einrichtung unseres ML-Projekts auf GitHub bis hin zur Erstellung eines GitHub Actions-Workflows, der Ihre ML-Aufgaben automatisiert, decken wir alles ab, was Sie wissen müssen.

GitHub Actions ist ein leistungsstarkes Tool, das eine kostenlose Pipeline für kontinuierliche Integration und kontinuierliche Bereitstellung (CI/CD) für alle GitHub-Repositorys bereitstellt. Es automatisiert den gesamten Softwareentwicklungsworkflow, von der Erstellung und dem Test bis zur Codebereitstellung, alles innerhalb der GitHub-Plattform. Sie können damit Ihre Entwicklungs- und Bereitstellungseffizienz verbessern.

Hauptfunktionen von GitHub-Aktionen

Jetzt lernen wir die Schlüsselkomponenten des Workflows kennen.

Arbeitsablauf

Workflows sind automatisierte Prozesse, die Sie in Ihrem GitHub-Repository definieren. Sie bestehen aus einer oder mehreren Aufgaben und können durch GitHub-Ereignisse wie einen Push-Request, einen Pull-Request, die Erstellung eines Tickets oder durch Workflows ausgelöst werden. Workflows werden in einer YML-Datei im Verzeichnis .github/workflows Ihres Repositorys definiert. Sie können es bearbeiten und den Workflow direkt aus dem GitHub-Repository erneut ausführen.

Werke und Bühnen

Innerhalb eines Workflows definieren Aufgaben eine Reihe von Schritten, die auf demselben Ausführenden ausgeführt werden. Jeder Schritt in einer Aufgabe kann Befehle oder Aktionen ausführen, bei denen es sich um wiederverwendbare Codeteile handelt, die eine bestimmte Aufgabe ausführen können, beispielsweise das Formatieren von Code oder das Trainieren des Modells.

Veranstaltungen

Workflows können durch verschiedene GitHub-Ereignisse ausgelöst werden, z. B. Push-Anfragen, Pull-Anfragen, Forks, Stars, Releases und mehr. Mithilfe der Cron-Syntax können Sie Workflows auch so planen, dass sie zu bestimmten Zeiten ausgeführt werden.

Läufer

Runner sind die virtuellen Umgebungen/Maschinen, auf denen Workflows ausgeführt werden. GitHub stellt gehosteten Läufern Linux-, Windows- und macOS-Umgebungen zur Verfügung. Alternativ können Sie Ihren eigenen Läufer hosten, um mehr Kontrolle über die Umgebung zu erhalten.

Aktionen

Aktionen sind wiederverwendbare Codeeinheiten, die Sie als Schritte in Ihren Aufgaben verwenden können. Sie können Ihre eigenen Aktionen erstellen oder von der GitHub-Community auf GitHub Marketplace geteilte Aktionen verwenden.

Mit GitHub Actions können Entwickler ihre Build-, Test- und Bereitstellungsworkflows einfach direkt in GitHub automatisieren und so die Produktivität verbessern und den Entwicklungsprozess rationalisieren.

In diesem Projekt werden wir zwei Aktionen verwenden:

  1. Aktionen/checkout@v3: um Ihr Repository auszuchecken, damit der Workflow auf die Datei und die Daten zugreifen kann.
  2. iterative/setup-cml@v2: um die Modellmetriken und die Verwirrungsmatrix unterhalb der Validierung als Nachricht anzuzeigen.

Wir werden an einem einfachen maschinellen Lernprojekt arbeiten, bei dem wir den Bank Churn-Datensatz von Kaggle verwenden, um einen zufälligen Waldklassifikator zu trainieren und auszuwerten.

Aufbau

  1. Wir erstellen das GitHub-Repository, indem wir den Namen und die Beschreibung angeben und die Readme-Datei und die Lizenz überprüfen.

    GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

  2. Gehen Sie zum Projektleiter und klonen Sie das Repository.
  3. Ändern Sie das Verzeichnis in den Repository-Ordner.
  4. Starten Sie den Code-Editor. In unserem Fall ist es VSCode.
$ git clone https://github.com/kingabzpro/GitHub-Actions-For-Machine-Learning-Beginners.git

$ cd .\GitHub-Actions-For-Machine-Learning-Beginners\

$ code .
  1. Bitte erstellen Sie eine „requirements.txt“-Datei und fügen Sie alle erforderlichen Pakete hinzu, um den Workflow erfolgreich auszuführen.
pandas
scikit-learn
numpy
matplotlib
skops
black
  1. Laden Sie die Daten über den Link von Kaggle herunter und extrahieren Sie sie in den Hauptordner.
  2. Der Datensatz ist groß, daher müssen wir GitLFS in unserem Repository installieren und die CSV-Datei des Zugs verfolgen.
$ git lfs install
$ git lfs track train.csv

Schulungs- und Bewertungscode

In diesem Abschnitt schreiben wir den Code, der die Modellpipelines trainiert, auswertet und speichert. Der Code stammt aus meinem vorherigen Tutorial, Optimieren Sie Ihren maschinellen Lernworkflow mit Scikit-learn-Pipelines. Wenn Sie wissen möchten, wie die Scikit-Learn-Pipeline funktioniert, sollten Sie sie lesen.

  1. Erstellen Sie eine „train.py“-Datei, kopieren Sie den folgenden Code und fügen Sie ihn ein.
  2. Der Code verwendet ColumnTransformer und Pipeline zur Vorverarbeitung der Daten und Pipeline für die Funktionsauswahl und das Modelltraining.
  3. Nach der Bewertung der Modellleistung werden die Metriken und die Verwirrungsmatrix im Hauptordner gespeichert. Diese Metriken werden später von der CML-Aktion verwendet.
  4. Letztendlich wird die endgültige Scikit-Learn-Pipeline für die Modellinferenz gespeichert.
import pandas as pd

from sklearn.compose import ColumnTransformer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

from sklearn.feature_selection import SelectKBest, chi2
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler, OrdinalEncoder

from sklearn.metrics import accuracy_score, f1_score
import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix

import skops.io as sio

# loading the data
bank_df = pd.read_csv("train.csv", index_col="id", nrows=1000)
bank_df = bank_df.drop(["CustomerId", "Surname"], axis=1)
bank_df = bank_df.sample(frac=1)


# Splitting data into training and testing sets
X = bank_df.drop(["Exited"], axis=1)
y = bank_df.Exited

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=125
)

# Identify numerical and categorical columns
cat_col = [1, 2]
num_col = [0, 3, 4, 5, 6, 7, 8, 9]

# Transformers for numerical data
numerical_transformer = Pipeline(
    steps=[("imputer", SimpleImputer(strategy="mean")), ("scaler", MinMaxScaler())]
)

# Transformers for categorical data
categorical_transformer = Pipeline(
    steps=[
        ("imputer", SimpleImputer(strategy="most_frequent")),
        ("encoder", OrdinalEncoder()),
    ]
)

# Combine pipelines using ColumnTransformer
preproc_pipe = ColumnTransformer(
    transformers=[
        ("num", numerical_transformer, num_col),
        ("cat", categorical_transformer, cat_col),
    ],
    remainder="passthrough",
)

# Selecting the best features
KBest = SelectKBest(chi2, k="all")

# Random Forest Classifier
model = RandomForestClassifier(n_estimators=100, random_state=125)

# KBest and model pipeline
train_pipe = Pipeline(
    steps=[
        ("KBest", KBest),
        ("RFmodel", model),
    ]
)

# Combining the preprocessing and training pipelines
complete_pipe = Pipeline(
    steps=[
        ("preprocessor", preproc_pipe),
        ("train", train_pipe),
    ]
)

# running the complete pipeline
complete_pipe.fit(X_train, y_train)


## Model Evaluation
predictions = complete_pipe.predict(X_test)
accuracy = accuracy_score(y_test, predictions)
f1 = f1_score(y_test, predictions, average="macro")

print("Accuracy:", str(round(accuracy, 2) * 100) + "%", "F1:", round(f1, 2))


## Confusion Matrix Plot
predictions = complete_pipe.predict(X_test)
cm = confusion_matrix(y_test, predictions, labels=complete_pipe.classes_)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=complete_pipe.classes_)
disp.plot()
plt.savefig("model_results.png", dpi=120)

## Write metrics to file
with open("metrics.txt", "w") as outfile:
    outfile.write(f"\nAccuracy = {round(accuracy, 2)}, F1 Score = {round(f1, 2)}\n\n")
   

# saving the pipeline
sio.dump(complete_pipe, "bank_pipeline.skops")

Wir haben ein gutes Ergebnis erzielt.

$ python train.py
Accuracy: 88.0% F1: 0.77

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

Weitere Informationen zum Innenleben des oben genannten Codes finden Sie in der Lektüre „Optimieren Sie Ihren maschinellen Lernworkflow mit Scikit-Learn-Pipelines“.

Wir möchten nicht, dass Git Ausgabedateien pusht, da diese immer am Ende des Codes generiert werden. Daher fügen wir die .gitignore-Datei hinzu.

Geben Sie einfach „.gitignore“ in das Terminal ein, um die Datei zu starten.

Fügen Sie die folgenden Dateinamen hinzu.

metrics.txt
model_results.png
bank_pipeline.skops

So sollte es auf Ihrem VSCode aussehen.

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

Jetzt organisieren wir die Änderungen, erstellen ein Commit und übertragen die Änderungen an den GitHub-Hauptzweig.

git add .
git commit -m "new changes"
git push origin main

So sollte Ihr GitHub-Repository aussehen.

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

LMC

Bevor Sie mit der Arbeit am Workflow beginnen, ist es wichtig, den Zweck von CML-Aktionen (Continuous Machine Learning) zu verstehen. CML-Funktionen werden im Workflow verwendet, um den Prozess der Erstellung eines Modellbewertungsberichts zu automatisieren. Was bedeutet das? Nun, wenn wir die Änderungen an GitHub übertragen, wird unterhalb des Commits automatisch ein Bericht generiert. Dieser Bericht enthält Leistungskennzahlen und eine Verwirrungsmatrix. Außerdem erhalten wir eine E-Mail mit all diesen Informationen.

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

GitHub-Aktionen

Es ist Zeit für den Hauptteil. Wir werden einen Workflow für maschinelles Lernen entwickeln, um unser Modell zu trainieren und zu bewerten. Dieser Workflow wird immer dann aktiviert, wenn wir unseren Code an den Hauptzweig übertragen oder wenn jemand eine Pull-Anfrage an den Hauptzweig sendet.

Um unseren ersten Workflow zu erstellen, gehen Sie zur Registerkarte „Aktionen“ des Repositorys und klicken Sie auf den blauen Text „Konfigurieren Sie selbst einen Workflow“. Es erstellt eine YML-Datei im Verzeichnis .github/workflows und stellt uns den interaktiven Code-Editor zum Hinzufügen des Codes zur Verfügung.

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

Fügen Sie der Workflowdatei den folgenden Code hinzu. In diesem Code sind wir:

  1. Nennen Sie unseren Workflow.
  2. Einstellen von Push- und Pull-On-Demand-Triggern mithilfe der „Ein“-Tasten.
  3. Stellen Sie Aktionen mit schriftlicher Genehmigung bereit, damit die CML-Aktion die Nachricht unter Validierung erstellen kann.
  4. Verwenden Sie den Ubuntu-Linux-Runner.
  5. Verwenden Sie die Aktion „actions/checkout@v3“, um auf alle Dateien im Repository zuzugreifen, einschließlich des Datensatzes.
  6. Verwenden Sie die Aktion „iterative/setup-cml@v2“, um das CML-Paket zu installieren.
  7. Erstellen Sie die Laufzeit, um alle Python-Pakete zu installieren.
  8. Erstellen Sie die Laufzeit zum Formatieren von Python-Dateien.
  9. Erstellen Sie den Lauf, um das Modell zu trainieren und auszuwerten.
  10. Erstellen Sie den Lauf mit GITHUB_TOKEN, um die Modellmetriken und das Verwirrungsmatrixdiagramm in die Datei „report.md“ zu verschieben. Verwenden Sie dann den CML-Befehl, um den Bericht unter dem Commit-Kommentar zu erstellen.
name: ML Workflow
on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
  workflow_dispatch:
  
permissions: write-all

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          lfs: true
      - uses: iterative/setup-cml@v2
      - name: Install Packages
        run: pip install --upgrade pip && pip install -r requirements.txt
      - name: Format
        run: black *.py
      - name: Train
        run: python train.py
      - name: Evaluation
        env:
          REPO_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: | 
          echo "## Model Metrics" > report.md
          cat metrics.txt >> report.md
            
          echo '## Confusion Matrix Plot' >> report.md
          echo '![Confusion Matrix](model_results.png)' >> report.md

          cml comment create report.md

So sollte es in Ihrem GitHub-Workflow aussehen.

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

Nach Validierung der Änderungen. Der Workflow beginnt mit der sequenziellen Ausführung des Befehls.

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

Sobald der Workflow abgeschlossen ist, können wir die Protokolle anzeigen, indem wir auf der Registerkarte „Aktionen“ auf den aktuellen Workflow klicken, den Build öffnen und die Protokolle für jede Aufgabe überprüfen.

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

Wir können die Modellbewertung jetzt im Abschnitt „Validierungsmeldungen“ anzeigen. Wir können darauf zugreifen, indem wir auf den Validierungslink klicken: feste Position im Workflow · kingabzpro/GitHub-Actions-For-Machine-Learning-Beginners@44c74fa

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

Sie erhalten außerdem eine E-Mail von GitHub

GitHub-Aktionen für Anfänger im maschinellen LernenGitHub-Aktionen für Anfänger im maschinellen Lernen

Die Codequelle ist in meinem GitHub-Repository verfügbar: kingabzpro/GitHub-Actions-For-Machine-Learning-Beginners. Sie können es klonen und selbst ausprobieren.

Machine Learning Operations (MLOps) ist ein weites Feld, das Kenntnisse über verschiedene Tools und Plattformen erfordert, um Modelle erfolgreich zu erstellen und für die Produktion bereitzustellen. Um mit MLOps zu beginnen, wird empfohlen, das umfassende Tutorial „Beginner's Guide to CI/CD for Machine Learning“ zu befolgen. Es bietet Ihnen eine solide Grundlage für die effektive Implementierung von MLOps-Techniken.

In diesem Tutorial haben wir erklärt, was GitHub-Aktionen sind und wie sie zur Automatisierung Ihres maschinellen Lernworkflows verwendet werden können. Wir haben auch etwas über CML-Aktionen gelernt und erfahren, wie man Skripte im YML-Format schreibt, um Aufgaben erfolgreich auszuführen. Wenn Sie immer noch nicht sicher sind, wo Sie anfangen sollen, empfehle ich Ihnen, einen Blick auf den einzigen kostenlosen Kurs zu werfen, den Sie benötigen, um MLOps-Ingenieur zu werden.

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter professioneller Datenwissenschaftler, der es liebt, Modelle für maschinelles Lernen zu erstellen. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben technischer Blogs zu maschinellem Lernen und Datenwissenschaftstechnologien. Abid verfügt über einen Master-Abschluss in Technologiemanagement und einen Bachelor-Abschluss in Telekommunikationstechnik. Seine Vision ist es, ein KI-Produkt mithilfe eines grafischen neuronalen Netzwerks für Schüler mit psychischen Erkrankungen zu entwickeln.

About the author

smirow

Leave a Comment