Kurz: Trénování prvního modelu strojového učení (část 2 ze 3)

V tomto kurzu si ukážeme, jak vytrénovat model strojového učení v Azure Machine Learning. Tento kurz je 2. částí třísekunové série kurzů.

V části 1: Spuštění "Hello world!" z této série jste zjistili, jak pomocí řídicího skriptu spustit úlohu v cloudu.

V tomto kurzu se v dalším kroku odešlete skript, který trénuje model strojového učení. Tento příklad vám pomůže pochopit, jak Azure Machine Learning usnadňuje konzistentní chování mezi místním laděním a vzdálenými spuštěními.

V tomto kurzu jste:

Požadavky

• Dokončení 1. části série

Vytváření trénovací skripty

Nejprve definujete architekturu neurální sítě v model.py souboru. Veškerý trénovací kód bude do src podadresáře, včetně model.py.

Trénovací kód je převzatý z tohoto úvodního příkladu z PyTorchu. Všimněte si, Azure Machine Learning koncepty se vztahují na jakýkoli kód strojového učení, nejen na PyTorch.

1. Vytvořte soubor model.py v podsložce src. Zkopírujte do souboru tento kód:

   import torch.nn as nn
   import torch.nn.functional as F
   class Net(nn.Module):
       def __init__(self):
           super(Net, self).__init__()
           self.conv1 = nn.Conv2d(3, 6, 5)
           self.pool = nn.MaxPool2d(2, 2)
           self.conv2 = nn.Conv2d(6, 16, 5)
           self.fc1 = nn.Linear(16 * 5 * 5, 120)
           self.fc2 = nn.Linear(120, 84)
           self.fc3 = nn.Linear(84, 10)
       def forward(self, x):
           x = self.pool(F.relu(self.conv1(x)))
           x = self.pool(F.relu(self.conv2(x)))
           x = x.view(-1, 16 * 5 * 5)
           x = F.relu(self.fc1(x))
           x = F.relu(self.fc2(x))
           x = self.fc3(x)
           return x
   

2. Na panelu nástrojů vyberte Uložit a soubor uložte. Pokud chcete, zavřete kartu.

3. Dále definujte trénovací skript také v podsložce src. Tento skript stáhne datovou sadu CIFAR10 pomocí rozhraní API PyTorch, nastaví síť definovanou v model.py a vytrénuje ji na dvě epochy pomocí standardní SGD a ztráty mezi torchvision.dataset entropiemi.

   Vytvořte train.py skript v podsložce src:

   import torch
   import torch.optim as optim
   import torchvision
   import torchvision.transforms as transforms
   
   from model import Net
   
   # download CIFAR 10 data
   trainset = torchvision.datasets.CIFAR10(
       root="../data",
       train=True,
       download=True,
       transform=torchvision.transforms.ToTensor(),
   )
   trainloader = torch.utils.data.DataLoader(
       trainset, batch_size=4, shuffle=True, num_workers=2
   )
   
   if __name__ == "__main__":
   
       # define convolutional network
       net = Net()
   
       # set up pytorch loss /  optimizer
       criterion = torch.nn.CrossEntropyLoss()
       optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
   
       # train the network
       for epoch in range(2):
   
           running_loss = 0.0
           for i, data in enumerate(trainloader, 0):
               # unpack the data
               inputs, labels = data
   
               # zero the parameter gradients
               optimizer.zero_grad()
   
               # forward + backward + optimize
               outputs = net(inputs)
               loss = criterion(outputs, labels)
               loss.backward()
               optimizer.step()
   
               # print statistics
               running_loss += loss.item()
               if i % 2000 == 1999:
                   loss = running_loss / 2000
                   print(f"epoch={epoch + 1}, batch={i + 1:5}: loss {loss:.2f}")
                   running_loss = 0.0
   
       print("Finished Training")
   

4. Teď máte následující strukturu složek:

   

Místní testování

Výběrem možnosti Uložit a spustit skript v terminálu train.py skript spustit přímo na výpočetní instanci.

Po dokončení skriptu vyberte aktualizovat nad složkami souborů. Zobrazí se nová složka dat s názvem get-started/data Rozbalte tuto složku a zobrazte stažená data.

Vytvoření řídicího skriptu

Rozdíl mezi následujícím řídicím skriptem a skriptem, který jste použili k odeslání zprávy "Hello world!" Je to, že pro nastavení prostředí přidáte několik dalších řádků.

Ve složce get-started vytvořte nový soubor Pythonu s názvem run-pytorch.py :

# run-pytorch.py
from azureml.core import Workspace
from azureml.core import Experiment
from azureml.core import Environment
from azureml.core import ScriptRunConfig

if __name__ == "__main__":
    ws = Workspace.from_config()
    experiment = Experiment(workspace=ws, name='day1-experiment-train')
    config = ScriptRunConfig(source_directory='./src',
                             script='train.py',
                             compute_target='cpu-cluster')

    # use curated pytorch environment 
    env = ws.environments['AzureML-PyTorch-1.6-CPU']
    config.run_config.environment = env

    run = experiment.submit(config)

    aml_url = run.get_portal_url()
    print(aml_url)

Pochopení změn kódu

Odeslání spuštění do Azure Machine Learning

1. Vyberte Uložit a spustit skript v terminálu a spusťte run-pytorch.py skript.

2. V okně terminálu se zobrazí odkaz, který se otevře. Výběrem odkazu zobrazíte spuštění.

   Poznámka

   Může se zobrazit některá upozornění, která začínají chybou při načítání azureml_run_type_providers.... Tato upozornění můžete ignorovat. Výstup zobrazíte pomocí odkazu v dolní části těchto upozornění.

Zobrazení výstupu

1. Na stránce, která se otevře, se zobrazí stav spuštění. Při prvním spuštění tohoto skriptu Azure Machine Learning z vašeho prostředí PyTorch nová image Dockeru. Dokončení celého spuštění může trvat 3 až 4 minuty. Tato image se znovu použije v budoucích spuštěních, aby se spouštěla mnohem rychleji.
2. Protokoly sestavení Dockeru můžete zobrazit v Azure Machine Learning Studiu. Vyberte kartu Výstupy a protokoly a pak vyberte 20_image_build_log.txt.
3. Když je stav spuštění Dokončeno, vyberte Výstup a protokoly.
4. Výběrem 70_driver_log.txt zobrazíte výstup spuštění.

Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
...
Files already downloaded and verified
epoch=1, batch= 2000: loss 2.19
epoch=1, batch= 4000: loss 1.82
epoch=1, batch= 6000: loss 1.66
epoch=1, batch= 8000: loss 1.58
epoch=1, batch=10000: loss 1.52
epoch=1, batch=12000: loss 1.47
epoch=2, batch= 2000: loss 1.39
epoch=2, batch= 4000: loss 1.38
epoch=2, batch= 6000: loss 1.37
epoch=2, batch= 8000: loss 1.33
epoch=2, batch=10000: loss 1.31
epoch=2, batch=12000: loss 1.27
Finished Training

Pokud se zobrazí chyba Your total snapshot size exceeds the limit , složka dat se nachází v hodnotě použité source_directory v ScriptRunConfig .

Vyberte ... na konci složky a pak výběrem možnosti Move (Přesunout) přesuňte data do složky get-started.

Protokolování metrik trénování

Teď, když máte trénování modelu v Azure Machine Learning, začněte sledovat některé metriky výkonu.

Aktuální trénovací skript vytiskne metriky do terminálu. Azure Machine Learning poskytuje mechanismus pro protokolování metrik s více funkcemi. Přidáním několika řádků kódu získáte možnost vizualizovat metriky ve studiu a porovnávat metriky mezi několika spuštěními.

Úprava train.py tak, aby zahrnovaly protokolování

1. Upravte svůj train.py tak, aby zahrnoval další dva řádky kódu:

   import torch
   import torch.optim as optim
   import torchvision
   import torchvision.transforms as transforms
   from model import Net
   from azureml.core import Run
   # ADDITIONAL CODE: get run from the current context
   run = Run.get_context()
   # download CIFAR 10 data
   trainset = torchvision.datasets.CIFAR10(
       root='./data',
       train=True,
       download=True,
       transform=torchvision.transforms.ToTensor()
   )
   trainloader = torch.utils.data.DataLoader(
       trainset,
       batch_size=4,
       shuffle=True,
       num_workers=2
   )
   if __name__ == "__main__":
       # define convolutional network
       net = Net()
       # set up pytorch loss /  optimizer
       criterion = torch.nn.CrossEntropyLoss()
       optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
       # train the network
       for epoch in range(2):
           running_loss = 0.0
           for i, data in enumerate(trainloader, 0):
               # unpack the data
               inputs, labels = data
               # zero the parameter gradients
               optimizer.zero_grad()
               # forward + backward + optimize
               outputs = net(inputs)
               loss = criterion(outputs, labels)
               loss.backward()
               optimizer.step()
               # print statistics
               running_loss += loss.item()
               if i % 2000 == 1999:
                   loss = running_loss / 2000
                   # ADDITIONAL CODE: log loss metric to AML
                   run.log('loss', loss)
                   print(f'epoch={epoch + 1}, batch={i + 1:5}: loss {loss:.2f}')
                   running_loss = 0.0
       print('Finished Training')
   

2. Uložte tento soubor a pokud chcete, zavřete kartu.

Pochopení dalších dvou řádků kódu

V train.py přistupovat k objektu run přímo z trénovacího skriptu pomocí metody a použít Run.get_context() ho k protokolování metrik:

# ADDITIONAL CODE: get run from the current context
run = Run.get_context()

...
# ADDITIONAL CODE: log loss metric to AML
run.log('loss', loss)

Metriky v Azure Machine Learning jsou:

• Uspořádané podle experimentů a spuštění, takže je snadné sledovat a porovnávat metriky.
• Vybavené uživatelským rozhraním, abyste mohli vizualizovat výkon trénování ve studiu.
• Navrženo pro škálování, takže si tyto výhody zachováte i při spouštění stovek experimentů.

Odeslání spuštění do Azure Machine Learning

Vyberte kartu pro skript run-pytorch.py a pak vyberte Uložit a spustit skript v terminálu a znovu spusťte skript run-pytorch.py skriptu.

Tentokrát při návštěvě studia přejděte na kartu Metriky, kde se teď můžete podívat na aktuální informace o ztrátě trénování modelu. Zahájení trénování může trvat 1 až 2 minuty.

Další kroky

V této relaci jste upgradovali ze základního "Hello World!" skript do realističtějšího trénovacího skriptu, který vyžadoval spuštění konkrétního prostředí Pythonu. Viděli jste, jak používat kurátorovaná Azure Machine Learning prostředí. Nakonec jste viděli, že na několika řádcích kódu můžete metriky protokolovat do Azure Machine Learning.

Existují i jiné způsoby, jak Azure Machine Learning prostředí, včetně z requirements.txtpip nebo z existujícího místního prostředí Conda.

V další relaci uvidíte, jak pracovat s daty v Azure Machine Learning tím, že nahrajete datovou sadu CIFAR10 do Azure.