Verifiera koden lokalt

Slutförd

När du ändrar kod i maskininlärningsprojektet vill du verifiera koden och modellkvaliteten.

Under kontinuerlig integrering skapar och verifierar du tillgångar för ditt program. Som dataexpert fokuserar du förmodligen på att skapa skript som används för förberedelse av data och modellträning. Maskininlärningsteknikern använder skripten senare i pipelines för att automatisera dessa processer.

Det finns två vanliga uppgifter för att verifiera skripten:

• Linting: Sök efter programmässiga eller stilistiska fel i Python- eller R-skript.
• Enhetstestning: Kontrollera prestanda för innehållet i skripten.

Genom att verifiera koden förhindrar du buggar eller problem när modellen distribueras. Du kan verifiera koden lokalt genom att köra linters och enhetstester lokalt i en IDE som Visual Studio Code.

Du kan också köra linters- och enhetstester i ett automatiserat arbetsflöde med Azure Pipelines eller GitHub Actions.

Du får lära dig hur du kör lintnings- och enhetstester i Visual Studio Code.

Lint din kod

Kodens kvalitet beror på vilka standarder du och ditt team är överens om. För att säkerställa att den överenskomna kvaliteten uppfylls kan du köra linters som kontrollerar om koden överensstämmer med teamets standarder.

Beroende på vilket kodspråk du använder finns det flera alternativ för att lint din kod. Om du till exempel arbetar med Python kan du använda antingen Flake8 eller Pylint.

Använda Flake8 för att lint din kod

Så här använder du Flake8 lokalt med Visual Studio Code:

1. Installera Flake8 med pip install flake8.
2. Skapa en konfigurationsfil .flake8 och lagra filen på lagringsplatsen.
3. Konfigurera Visual Studio Code för att använda Flake8 som linter genom att gå till dina inställningar (Ctrl+,).
4. Sök efter flake8.
5. Aktivera Python > Linting > Flake8 aktiverat.
6. Ange Flake8-sökvägen till den plats på lagringsplatsen där du lagrade .flake8 filen.

Om du vill ange vad teamets standarder är för kodkvalitet kan du konfigurera Flake8-lintern. En vanlig metod för att definiera standarder är genom att skapa en .flake8 fil som lagras med din kod.

Filen .flake8 bör börja med [flake8], följt av någon av de konfigurationer som du vill använda.

Dricks

En fullständig lista över möjliga konfigurationsparametrar finns i Flake8-dokumentationen.

Om du till exempel vill ange att den maximala längden på en rad inte får vara längre än 80 tecken lägger du till följande rad i .flake8 filen:

[flake8]
max-line-length = 80

Flake8 har en fördefinierad lista över fel som kan returneras. Dessutom kan du använda felkoder som baseras på PEP 8-stilguiden. Du kan till exempel inkludera felkoder som refererar till korrekt användning av indrag eller blanksteg.

Du kan välja att antingen välja (select) en uppsättning felkoder som ska ingå i lintern eller välja vilka felkoder som ska ignoreras (ignore) i standardlistan med alternativ.

Därför kan konfigurationsfilen .flake8 se ut som i följande exempel:

[flake8]
ignore = 
    W504,
    C901,
    E41
max-line-length = 79
exclude = 
    .git,
    .cache,
per-file-ignores =
    code/__init__.py:D104
max-complexity = 10
import-order-style = pep8

Dricks

En översikt över felkoder som du kan referera till finns i flake8-fellistan

När du har konfigurerat Visual Studio Code för att lint din kod kan du öppna valfri kodfil för att granska lintresultatet. Varningar eller fel understryks. Du kan välja Visa problem för att kontrollera problemet för att förstå felet.

Lint med Azure Pipelines eller GitHub Actions

Du kan också köra linter automatiskt med Azure Pipelines eller GitHub Actions. Agenten som tillhandahålls av någon av plattformarna kör lintern när du:

1. Skapa en konfigurationsfil .flake8 och lagra filen på lagringsplatsen.
2. Definiera pipelinen eller arbetsflödet för kontinuerlig integrering i YAML.
3. Som en uppgift eller ett steg installerar du Flake8 med python -m pip install flake8.
4. Som en uppgift eller ett steg kör du flake8 kommandot för att lint din kod.

Enhetstest

Där linting verifierar hur du skrev koden kontrollerar enhetstesterna hur koden fungerar. Enheter refererar till den kod som du skapar. Enhetstestning kallas därför även för kodtestning.

Som bästa praxis bör koden främst finnas i funktioner. Oavsett om du har skapat funktioner för att förbereda data eller träna en modell. Du kan använda enhetstestning för till exempel:

• Kontrollera att kolumnnamnen är rätt.
• Kontrollera modellens förutsägelsenivå för nya datauppsättningar.
• Kontrollera fördelningen av förutsägelsenivåer.

När du arbetar med Python kan du använda Pytest och Numpy (som använder Pytest-ramverket) för att testa koden. Om du vill veta mer om hur du arbetar med Pytest kan du lära dig hur du skriver tester med Pytest.

Dricks

Granska en mer detaljerad genomgång av Python-testning i Visual Studio Code.

Anta att du har skapat ett träningsskript train.pysom innehåller följande funktion:

# Train the model, return the model
def train_model(data, ridge_args):
    reg_model = Ridge(**ridge_args)
    reg_model.fit(data["train"]["X"], data["train"]["y"])
    return reg_model

Anta att du har lagrat träningsskriptet i katalogen src/model/train.py på lagringsplatsen. Om du vill testa train_model funktionen måste du importera funktionen från src.model.train.

Du skapar test_train.py filen i tests mappen. Ett sätt att testa Python-kod är att använda numpy. Numpy erbjuder flera assert funktioner för att jämföra matriser, strängar, objekt eller objekt.

Dricks

Läs mer om riktlinjer för testning när du använder Numpy-testning och Numpys teststöd.

Om du till exempel vill testa train_model funktionen kan du använda en liten träningsdatauppsättning och använda assert för att kontrollera om förutsägelserna är nästan lika med dina fördefinierade prestandamått.

import numpy as np
from src.model.train import train_model

def test_train_model():
    X_train = np.array([1, 2, 3, 4, 5, 6]).reshape(-1, 1)
    y_train = np.array([10, 9, 8, 8, 6, 5])
    data = {"train": {"X": X_train, "y": y_train}}

    reg_model = train_model(data, {"alpha": 1.2})

    preds = reg_model.predict([[1], [2]])
    np.testing.assert_almost_equal(preds, [9.93939393939394, 9.03030303030303])

Så här testar du koden i Visual Studio Code med hjälp av användargränssnittet:

1. Installera alla nödvändiga bibliotek för att köra träningsskriptet.
2. Kontrollera att pytest är installerat och aktiverat i Visual Studio Code.
3. Installera Python-tillägget för Visual Studio Code.
4. Välj det skript som train.py du vill testa.
5. Välj fliken Testning på den vänstra menyn.
6. Konfigurera Python-testning genom att välja pytest och ställa in testkatalogen till din tests/ mapp.
7. Kör alla tester genom att välja uppspelningsknappen och granska resultatet.

Så här kör du testet i en Azure DevOps-pipeline eller GitHub-åtgärd:

1. Se till att alla nödvändiga bibliotek är installerade för att köra träningsskriptet. Använd helst en requirements.txt lista över alla bibliotek med pip install -r requirements.txt
2. Installera pytest med pip install pytest
3. Kör testerna med pytest tests/

Resultatet av testerna visas i utdata från pipelinen eller arbetsflödet som du kör.

Kommentar

Om ett fel returneras under lintning eller enhetstestning kan CI-pipelinen misslyckas. Det är därför bättre att verifiera koden lokalt först innan ci-pipelinen utlöses.