Självstudie: Modellutveckling på en molnarbetsstation

Lär dig hur du utvecklar ett träningsskript med en notebook-fil på en Azure Machine Learning-molnarbetsstation. Den här självstudien beskriver grunderna du behöver för att komma igång:

• Konfigurera och konfigurera molnarbetsstationen. Din molnarbetsstation drivs av en Azure Machine Learning-beräkningsinstans som är förkonfigurerad med miljöer för att stödja dina olika modellutvecklingsbehov.
• Använd molnbaserade utvecklingsmiljöer.
• Använd MLflow för att spåra dina modellmått, allt från en notebook-fil.

Förutsättningar

Om du vill använda Azure Machine Learning behöver du först 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.

Börja med notebook-filer

Avsnittet Notebooks på din arbetsyta är ett bra ställe att börja lära dig mer om Azure Machine Learning och dess funktioner. Här kan du ansluta till beräkningsresurser, arbeta med en terminal och redigera och köra Jupyter Notebooks och skript.

1. Logga in på Azure Machine Learning-studio.

2. Välj din arbetsyta om den inte redan är öppen.

3. I det vänstra navigeringsfältet väljer du Notebooks.

4. Om du inte har någon beräkningsinstans visas Skapa beräkning mitt på skärmen. Välj Skapa beräkning och fyll i formuläret. Du kan använda alla standardvärden. (Om du redan har en beräkningsinstans visas i ställetTerminalen på den platsen. Du kommer att använda Terminal senare i den här självstudien.)

   

Konfigurera en ny miljö för prototyper (valfritt)

För att skriptet ska kunna köras måste du arbeta i en miljö som konfigurerats med de beroenden och bibliotek som koden förväntar sig. Det här avsnittet hjälper dig att skapa en miljö som är anpassad efter 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. Ladda ned den här conda-miljöfilen workstation_env.yml till datorn med hjälp av knappen Ladda ned råfil längst upp till höger.

  1. Välj Lägg till filer och välj sedan Ladda upp filer för att ladda upp dem till din arbetsyta.

     

  2. Välj Bläddra och välj filer.

  3. Välj workstation_env.yml-fil som du laddade ned.

  4. Välj överför.

  Filen workstation_env.yml visas under din användarnamnsmapp på fliken Filer. Välj den här filen om du vill förhandsgranska den och se vilka beroenden den anger. Du ser innehållet så här:

  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 Azure Machine Learning-terminalen för att skapa en ny Jupyter-kernel baserat på filen workstation_env.yml .

  1. Välj Terminal för att öppna ett terminalfönster. Du kan också öppna terminalen från det vänstra kommandofältet:

     

  2. Om beräkningsinstansen har stoppats väljer du Starta beräkning och väntar tills den körs.

     

  3. När beräkningen körs visas ett välkomstmeddelande i terminalen och du kan börja skriva kommandon.

  4. Visa dina aktuella conda-miljöer. Den aktiva miljön är markerad med *.

     conda env list
     

  5. Om du har skapat en undermapp för den här självstudien, cd till den mappen nu.

  6. Skapa miljön baserat på den angivna conda-filen. Det tar några minuter att skapa den här miljön.

     conda env create -f workstation_env.yml
     
     

  7. Aktivera den nya miljön.

      conda activate workstation_env
     

  8. Verifiera att rätt miljö är aktiv och leta efter miljön som markerats med *.

     conda env list
     

  9. Skapa en ny Jupyter-kernel baserat på din aktiva miljö.

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

  10. 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. Välj Lägg till filer och välj Skapa ny fil.

   

2. Ge den nya anteckningsboken namnet develop-tutorial.ipynb (eller ange önskat namn).

3. Om beräkningsinstansen har stoppats väljer du Starta beräkning och väntar tills den körs.

   

4. Du ser att notebook-filen är ansluten till standardkärnan längst upp till höger. Växla om du vill använda kerneln Tutorial Workstation Env om du har skapat kerneln.

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 förberedda test- och träningsdatauppsättningar från UCI-datauppsättningen.

Den här koden används sklearn för träning och MLflow för att logga måtten.

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 det hä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 MLflow kan du logga modellparametrar och resultat. Gå tillbaka till dessa 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. Du får fortfarande alla resultat som du behöver spåra.

Upprepa

Nu när du har modellresultat kanske du vill ändra något och försöka igen. Prova till exempel en annan klassificerarteknik:

# 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()

Kommentar

Du kan ignorera mlflow-varningarna. Du får fortfarande alla resultat som du behöver spåra.

Granska resultat

Nu när du har provat två olika modeller använder du de resultat 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 gå in närmare på dessa resultat genom att titta på jobben som skapats av MLflow.

1. I det vänstra navigeringsfältet väljer du Jobb.

   

2. Välj länken för självstudien Utveckla i molnet.

3. Det finns två olika jobb som visas, ett för var och en av de modeller som du provade. Dessa namn genereras automatiskt. När du hovra över ett namn använder du pennverktyget bredvid namnet om du vill byta namn på det.

4. Välj länken för det första jobbet. Namnet visas överst. Du kan också byta namn på det här med pennverktyget.

5. Sidan visar information om jobbet, till exempel egenskaper, utdata, taggar och parametrar. Under Taggar visas estimator_name, som beskriver typen av modell.

6. Välj fliken Mått för att visa de mått som loggades av MLflow. (Förvänta dig att dina resultat skiljer sig åt eftersom du har en annan träningsuppsättning.)

   

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

   

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

Skapa ett Python-skript

Skapa nu ett Python-skript från anteckningsboken för modellträning.

1. Välj menyn i verktygsfältet för anteckningsboken.

2. Välj Exportera som> Python.

   

3. Ge filen namnet train.py.

4. Titta igenom den här filen och ta bort den 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()).
   • Du kanske vill ta bort de autogenererade kommentarerna och lägga till fler egna kommentarer.
   • När du kör Python-skriptet interaktivt (i en terminal eller notebook-fil) kan du behålla den rad som definierar experimentnamnet (mlflow.set_experiment("Develop on cloud tutorial")). Eller till och med 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 fungerar 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 heller nödvändiga (de har ingen effekt), men kan lämnas kvar om du vill.

5. 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. Till vänster väljer du Öppna terminal för att öppna ett terminalfönster.

   

2. Visa dina aktuella conda-miljöer. Den aktiva miljön är markerad med *.

   conda env list
   

3. Om du har skapat en ny kernel aktiverar du den nu:

   conda activate workstation_env
   

4. Om du har skapat en undermapp för den här självstudien, cd till den mappen nu.

5. Kör träningsskriptet.

   python train.py
   

Kommentar

Du kan ignorera mlflow-varningarna. Du får fortfarande alla mått och bilder från automatisk loggning.

Granska skriptresultat

Gå tillbaka till Jobb för att se resultatet av ditt träningsskript. Tänk på att träningsdata ändras med varje delning, så resultaten skiljer sig också mellan körningarna.

Rensa resurser

Om du planerar att fortsätta nu till andra självstudier går du vidare till Nästa steg.

Stoppa beräkningsinstans

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

1. Välj Beräkning i det vänstra navigeringsområdet i studion.
2. På de översta flikarna väljer du Beräkningsinstanser
3. Välj beräkningsinstansen i listan.
4. I det övre verktygsfältet väljer du Stoppa.

Ta bort alla resurser

Viktigt!

De resurser som du har skapat kan användas som förutsättningar för andra Azure Machine Learning-självstudier och instruktionsartiklar.

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-portalen väljer du Resursgrupper längst till vänster.

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

3. Välj Ta bort resursgrupp.

   

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

Nästa steg

Läs mer om:

• Från artefakter till 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 självstudien visade de tidiga stegen för att skapa en modell, prototyper 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:

Träna en modell