Självstudie: modellutveckling på en molnarbetsstation

Den här artikeln beskriver hur du utvecklar ett träningsskript med hjälp av en notebook-fil på en Azure Machine Learning-molnarbetsstation. Självstudien beskriver de grundläggande steg som du behöver för att komma igång:

Förutsättningar

Om du vill använda Azure Machine Learning behöver du en arbetsyta. Om du inte har någon slutför du Skapa resurser som du behöver för att komma igång med att skapa en arbetsyta och lära dig mer om hur du använder den.

Skapa eller starta beräkning

Du kan skapa beräkningsresurser i avsnittet Beräkning på din arbetsyta. En beräkningsinstans är en molnbaserad arbetsstation som hanteras helt av Azure Machine Learning. I den här självstudieserien används en beräkningsinstans. Du kan också använda den för att köra din egen kod och för att utveckla och testa modeller.

1. Logga in på Azure Machine Learning-studio.
2. Välj din arbetsyta om den inte redan är öppen.
3. I den vänstra rutan väljer du Beräkning.
4. Om du inte har någon beräkningsinstans visas Nytt mitt på sidan. Välj Nytt och fyll i formuläret. Du kan använda alla standardvärden.
5. Om du har en beräkningsinstans väljer du den i listan. Om den har stoppats väljer du Start.

Öppna Visual Studio Code (VS Code)

När du har en beräkningsinstans som körs kan du komma åt den på olika sätt. I den här självstudien beskrivs hur du använder beräkningsinstansen från Visual Studio Code. Visual Studio Code tillhandahåller en fullständig integrerad utvecklingsmiljö (IDE) för att skapa beräkningsinstanser.

I listan över beräkningsinstanser väljer du länken VS Code (Web) eller VS Code (Desktop) för den beräkningsinstans som du vill använda. Om du väljer VS Code (Desktop) kan du se ett meddelande som frågar om du vill öppna programmet.

Den här Visual Studio Code-instansen är kopplad till din beräkningsinstans och ditt arbetsytefilsystem. Även om du öppnar den på skrivbordet är filerna du ser filer på din arbetsyta.

Konfigurera en ny miljö för prototyper

För att skriptet ska kunna köras måste du arbeta i en miljö som är konfigurerad med de beroenden och bibliotek som koden förväntar sig. Det här avsnittet hjälper dig att skapa en miljö som är skräddarsydd för din kod. Om du vill skapa den nya Jupyter-kerneln som notebook-filen ansluter till använder du en YAML-fil som definierar beroendena.

• Ladda upp en fil.

  Filer som du laddar upp lagras i en Azure-filresurs och dessa filer monteras på varje beräkningsinstans och delas på arbetsytan.

  1. Gå till azureml-examples/tutorials/get-started-notebooks/workstation_env.yml.

  2. Ladda ned Conda-miljöfilen workstation_env.yml till datorn genom att välja ellipsknappen (...) i det övre högra hörnet på sidan och sedan välja Ladda ned.

  3. Dra filen från datorn till Visual Studio Code-fönstret. Filen laddas upp till din arbetsyta.

  4. Flytta filen till din användarnamnsmapp.

     

  5. Välj filen för att förhandsgranska den. Granska de beroenden som anges. Du bör se något som liknar följande:

  name: workstation_env
  # This file serves as an example - you can update packages or versions to fit your use case
  dependencies:
    - python=3.8
    - pip=21.2.4
    - scikit-learn=0.24.2
    - scipy=1.7.1
    - pandas>=1.1,<1.2
    - pip:
      - mlflow-skinny 
      - azureml-mlflow
      - psutil>=5.8,<5.9
      - ipykernel~=6.0
      - matplotlib
  

• Skapa en kernel.

  Använd nu terminalen för att skapa en ny Jupyter-kernel som baseras på workstation_env.yml-filen .

  1. På menyn överst i Visual Studio Code väljer du Terminal > Ny terminal.

  

  1. Visa dina aktuella Conda-miljöer. Den aktiva miljön är markerad med en asterisk (*).

     conda env list
     

  2. Använd cd för att navigera till mappen där du laddade upp workstation_env.yml-filen . Om du till exempel har laddat upp den till din användarmapp använder du det här kommandot:

     cd Users/myusername
     

  3. Kontrollera att workstation_env.yml finns i mappen.

     ls
     

  4. Skapa miljön baserat på conda-filen som tillhandahålls. Det tar några minuter att konfigurera miljön.

     conda env create -f workstation_env.yml
     

  5. Aktivera den nya miljön.

     conda activate workstation_env
     

     Kommentar

     Om du ser CommandNotFoundError följer du anvisningarna för att köra conda init bash, stänger terminalen och öppnar sedan en ny. Försök sedan med conda activate workstation_env kommandot igen.

  6. Kontrollera att rätt miljö är aktiv och leta igen efter den miljö som har markerats med *.

     conda env list
     

  7. Skapa en ny Jupyter-kernel som baseras på din aktiva miljö.

     python -m ipykernel install --user --name workstation_env --display-name "Tutorial Workstation Env" 
     

  8. Stäng terminalfönstret.

Nu har du en ny kernel. Därefter öppnar du en notebook-fil och använder den här kerneln.

Skapa en notebook-fil

1. I menyn överst i Visual Studio Code väljer du Arkiv > Ny fil.
2. Ge den nya filen namnet develop-tutorial.ipynb (eller använd ett annat namn). Se till att använda tillägget .ipynb .

Ange kerneln

1. I det övre högra hörnet av den nya filen väljer du Välj kernel.
2. Välj Azure ML-beräkningsinstans (computeinstance-name).
3. Välj den kernel som du skapade: Självstudie om Arbetsstation Env. Om du inte ser kerneln väljer du uppdateringsknappen ovanför listan.

Utveckla ett träningsskript

I det här avsnittet utvecklar du ett Python-träningsskript som förutsäger standardbetalningar för kreditkort med hjälp av de förberedda test- och träningsdatauppsättningarna från UCI-datauppsättningen.

Den här koden använder sklearn för träning och MLflow för att logga metrics.

1. Börja med kod som importerar de paket och bibliotek som du ska använda i träningsskriptet.

   import os
   import argparse
   import pandas as pd
   import mlflow
   import mlflow.sklearn
   from sklearn.ensemble import GradientBoostingClassifier
   from sklearn.metrics import classification_report
   from sklearn.model_selection import train_test_split

2. Läs sedan in och bearbeta data för experimentet. I den här självstudien läser du data från en fil på Internet.

   # load the data
   credit_df = pd.read_csv(
       "https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
       header=1,
       index_col=0,
   )
   
   train_df, test_df = train_test_split(
       credit_df,
       test_size=0.25,
   )

3. Förbered data för träning.

   # Extracting the label column
   y_train = train_df.pop("default payment next month")
   
   # convert the dataframe values to array
   X_train = train_df.values
   
   # Extracting the label column
   y_test = test_df.pop("default payment next month")
   
   # convert the dataframe values to array
   X_test = test_df.values

4. Lägg till kod för att starta automatisk loggning med MLflow så att du kan spåra mått och resultat. Med den iterativa karaktären hos modellutveckling hjälper MLflow dig att logga modellparametrar och resultat. Se olika körningar för att jämföra och förstå hur din modell presterar. Loggarna ger också kontext för när du är redo att gå från utvecklingsfasen till träningsfasen för dina arbetsflöden i Azure Machine Learning.

   # set name for logging
   mlflow.set_experiment("Develop on cloud tutorial")
   # enable autologging with MLflow
   mlflow.sklearn.autolog()

5. Träna en modell.

   # Train Gradient Boosting Classifier
   print(f"Training with data of shape {X_train.shape}")
   
   mlflow.start_run()
   clf = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1)
   clf.fit(X_train, y_train)
   
   y_pred = clf.predict(X_test)
   
   print(classification_report(y_test, y_pred))
   # Stop logging for this model
   mlflow.end_run()

   Kommentar

   Du kan ignorera MLflow-varningarna. De resultat du behöver kommer fortfarande att spåras.

6. Välj Kör alla ovanför koden.

Upprepa

Nu när du har modellresultat ändrar du något och kör modellen igen. Prova till exempel en annan klassificeringsteknik:

# Train  AdaBoost Classifier
from sklearn.ensemble import AdaBoostClassifier

print(f"Training with data of shape {X_train.shape}")

mlflow.start_run()
ada = AdaBoostClassifier()

ada.fit(X_train, y_train)

y_pred = ada.predict(X_test)

print(classification_report(y_test, y_pred))
# Stop logging for this model
mlflow.end_run()

Välj Kör alla för att köra modellen.

Granska resultaten

Nu när du har provat två olika modeller använder du resultaten som spåras av MLFfow för att avgöra vilken modell som är bättre. Du kan referera till mått som noggrannhet eller andra indikatorer som är viktigast för dina scenarier. Du kan granska dessa resultat mer detaljerat genom att titta på jobben som skapats av MLflow.

1. Gå tillbaka till din arbetsyta i Azure Machine Learning-studio.

2. I den vänstra rutan väljer du Jobb.

   

3. Välj Handledning om utveckling på molnet.

4. Det finns två jobb som visas, ett för var och en av de modeller som du provade. Namnen genereras automatiskt. Om du vill byta namn på jobbet hovra över namnet och välj pennknappen bredvid det.

5. Välj länken för det första jobbet. Namnet visas överst på sidan. Du kan också byta namn på den här med hjälp av pennknappen.

6. Sidan visar jobbinformation, till exempel egenskaper, utdata, taggar och parametrar. Under Taggar visas estimator_name, som beskriver typen av modell.

7. Välj fliken Mått för att visa de mått som loggades av MLflow. (Resultatet blir annorlunda eftersom du har en annan träningsuppsättning.)

   

8. Välj fliken Bilder för att visa de bilder som genereras av MLflow.

   

9. Gå tillbaka och granska mått och bilder för den andra modellen.

Skapa ett Python-skript

Nu ska du skapa ett Python-skript från anteckningsboken för modellträning.

1. Högerklicka på anteckningsbokens filnamn i Visual Studio Code och välj Importera anteckningsbok till skript.

2. Välj Spara fil > för att spara den nya skriptfilen. Kalla det train.py.

3. Titta igenom filen och ta bort kod som du inte vill använda i träningsskriptet. Behåll till exempel koden för den modell som du vill använda och ta bort kod för den modell som du inte vill använda.

   • Se till att du behåller koden som startar automatisk loggning (mlflow.sklearn.autolog()).
   • När du kör Python-skriptet interaktivt (som du gör här) kan du behålla den rad som definierar experimentnamnet (mlflow.set_experiment("Develop on cloud tutorial")). Eller så kan du ge det ett annat namn för att se det som en annan post i avsnittet Jobb . Men när du förbereder skriptet för ett träningsjobb gäller inte den raden och bör utelämnas: jobbdefinitionen innehåller experimentnamnet.
   • När du tränar en enskild modell är linjerna för att starta och avsluta en körning (mlflow.start_run() och mlflow.end_run()) inte nödvändiga (de har ingen effekt), men du kan lämna dem i.

4. Spara filen när du är klar med dina redigeringar.

Nu har du ett Python-skript som du kan använda för att träna önskad modell.

Kör Python-skriptet

För tillfället kör du den här koden på din beräkningsinstans, som är din Azure Machine Learning-utvecklingsmiljö. Självstudie: Träna en modell visar hur du kör ett träningsskript på ett mer skalbart sätt på mer kraftfulla beräkningsresurser.

1. Välj den miljö som du skapade tidigare i den här självstudien som din Python-version (workstations_env). I det nedre högra hörnet i notebook-filen visas miljönamnet. Välj den och välj sedan miljön överst i Visual Studio Code.

   

2. Kör Python-skriptet genom att välja knappen Kör alla ovanför koden.

   

Granska skriptresultatet

Gå tillbaka till Jobb på din arbetsyta i Azure Machine Learning-studio för att se resultatet av ditt träningsskript. Tänk på att träningsdata ändras med varje uppdelning, så resultatet skiljer sig mellan körtillfällena.

Rensa resurser

Om du planerar att fortsätta med andra handledningar, gå vidare till Nästa steg.

Stoppa beräkningsinstansen

Om du inte ska använda den nu stoppar du beräkningsinstansen:

1. I studiofönstret till vänster väljer du Beräkning.
2. Längst upp på sidan väljer du Beräkningsinstanser.
3. I listan väljer du beräkningsinstansen.
4. Längst upp på sidan väljer du Stoppa.

Ta bort alla resurser

Om du inte planerar att använda någon av de resurser som du har skapat tar du bort dem så att du inte debiteras några avgifter:

1. I Azure Portal i sökrutan anger du Resursgrupper och väljer dem i resultatet.

2. I listan väljer du den resursgrupp som du skapade.

3. På sidan Översikt väljer du Ta bort resursgrupp.

   

4. Ange resursgruppsnamnet. Välj sedan ta bort.

Nästa steg

Mer information finns i dessa resurser:

• Artefakter och modeller i MLflow
• Använda Git med Azure Machine Learning
• Köra Jupyter Notebooks på din arbetsyta
• Arbeta med en beräkningsinstansterminal på din arbetsyta
• Hantera notebook- och terminalsessioner

Den här handledningen visar de tidiga stegen för att skapa en modell och innefattar prototypframtagning, som sker på samma dator där koden finns. För produktionsträningen lär du dig hur du använder träningsskriptet på mer kraftfulla fjärrberäkningsresurser: