Twórz modele Amazon SageMaker za pomocą PyTorch Model Zoo

Wdrażanie wysokiej jakości, wytrenowanych modeli uczenia maszynowego (ML) do przeprowadzania wnioskowania wsadowego lub w czasie rzeczywistym jest kluczowym elementem przynoszącym wartość klientom. Jednak proces eksperymentowania z uczeniem maszynowym może być żmudny — istnieje wiele podejść, których wdrożenie wymaga znacznej ilości czasu. Dlatego wstępnie przeszkolone modele ML, takie jak te dostarczone w Modelowe zoo PyTorch są tak pomocne. Amazon Sage Maker zapewnia ujednolicony interfejs do eksperymentowania z różnymi modelami ML, a PyTorch Model Zoo pozwala nam łatwo wymieniać nasze modele w ustandaryzowany sposób.

Ten post na blogu pokazuje, jak przeprowadzić wnioskowanie ML przy użyciu modelu wykrywania obiektów z Zoo modelowego PyTorch w SageMaker. Wstępnie wytrenowane modele ML z PyTorch Model Zoo są gotowe i mogą być łatwo używane jako część aplikacji ML. Konfigurowanie tych modeli ML jako punktu końcowego SageMaker lub Transformacja wsadowa SageMaker zadanie do wnioskowania online lub offline jest łatwe dzięki krokom opisanym w tym poście na blogu. użyjemy a Szybszy R-CNN model wykrywania obiektów do przewidywania ramek ograniczających dla predefiniowanych klas obiektów.

Przechodzimy przez kompleksowy przykład, od załadowania wag modelu wykrywania obiektów Faster R-CNN, do zapisania ich w Usługa Amazon Simple Storage (Amazon S3) wiadra, oraz do napisania pliku punktu wejścia i zrozumienia kluczowych parametrów w API PyTorchModel. Na koniec wdrożymy model ML, przeprowadzimy na nim wnioskowanie za pomocą SageMaker Batch Transform, sprawdzimy dane wyjściowe modelu ML i nauczymy się interpretować wyniki. To rozwiązanie można zastosować do dowolnego innego wstępnie wytrenowanego modelu w PyTorch Model Zoo. Aby uzyskać listę dostępnych modeli, zobacz Dokumentacja PyTorch Model Zoo.

Omówienie rozwiązania

Ten wpis na blogu przeprowadzi Cię przez następujące kroki. Aby uzyskać pełną wersję roboczą wszystkich kroków, zobacz create_pytorch_model_sagemaker.ipynb

• Krok 1: Konfiguracja
• Krok 2: Ładowanie modelu ML z PyTorch Model Zoo
• Krok 3 Zapisz i prześlij artefakty modelu ML do Amazon S3
• Krok 4: Budowanie skryptów wnioskowania o modelu ML
• Krok 5: Uruchomienie zadania transformacji wsadowej SageMaker
• Krok 6: Wizualizacja wyników

Schemat architektury

struktura katalogów

Kod tego bloga można znaleźć w this Repozytorium GitHub. Baza kodu zawiera wszystko, czego potrzebujemy do tworzenia artefaktów modelu ML, uruchamiania zadania transformacji i wizualizacji wyników.

To jest przepływ pracy, którego używamy. Wszystkie poniższe kroki będą odnosiły się do modułów w tej strukturze.

sagemaker_pytorch_model_zoo --> root directory
    |- inference.py --> entry point file
    |- create_pytorch_model_sagemaker.ipynb --> walks through all steps in this blog post
    |- cars.jpg --> input image

Połączenia sagemaker_torch_model_zoo folder powinien zawierać inference.py jako plik punktu wejścia i create_pytorch_model_sagemaker.ipynb, aby załadować i zapisać wagi modelu, utworzyć obiekt modelu SageMaker i ostatecznie przekazać go do zadania transformacji wsadowej SageMaker. Aby wprowadzić własne modele ML, zmień ścieżki w sekcji Krok 1: konfiguracja notebooka i załaduj nowy model w sekcji Krok 2: Ładowanie modelu ML z sekcji PyTorch Model Zoo. Pozostałe poniższe kroki pozostaną takie same.

Krok 1: Konfiguracja

Role IAM

SageMaker wykonuje operacje na infrastrukturze zarządzanej przez SageMaker. SageMaker może wykonywać tylko czynności dozwolone zgodnie z definicją w towarzyszącej notatnikowi roli wykonawczej IAM dla SageMaker. Aby uzyskać bardziej szczegółową dokumentację dotyczącą tworzenia ról IAM i zarządzania uprawnieniami IAM, zobacz Dokumentacja ról AWS SageMaker. Możemy stworzyć nową rolę, lub możemy dostać Notatnik SageMaker (Studio).domyślną rolę wykonawczą, uruchamiając następujące wiersze kodu:

import sagemaker

session = sagemaker.Session()

# Set a default S3 bucket
default_bucket = session.default_bucket()

# Get the region
region = boto3.Session().region_name

# Get the SageMaker Execution Role
role_arn = sagemaker.get_execution_role()

Powyższy kod pobiera rolę wykonawczą SageMaker dla instancji notatnika. To jest rola IAM, którą utworzyliśmy dla naszej instancji notatnika SageMaker lub SageMaker Studio.

Parametry konfigurowane przez użytkownika

Oto wszystkie konfigurowalne parametry potrzebne do zbudowania i uruchomienia naszego zadania transformacji wsadowej SageMaker:

INSTANCE_TYPE= "ml.m5.xlarge"
INSTANCE_COUNT= 1
BUCKET = os.path.join("s3://", default_bucket)

DATA_PATH= os.path.join(BUCKET, "images")
IMAGE_NAME = "cars.jpg"
RANDOM_STRING_LENGTH= 16
MODEL_NAME= "FasterRCNNResnet50"

# Needs to be set to version 1.2 or higher to enable automatic PyTorch model repackaging
FRAMEWORK_VERSION= "1.2"
ENTRY_POINT_FILE_NAME= "inference.py"

SAGEMAKER_EXECUTION_ROLE_ARN= role_arn
MODEL_ARTIFACTS_FILE_NAME= os.path.join(BUCKET, "modelzoo/fasterrcnn_resnet50_fpn/model.tar.gz")
IMAGE_URI= sagemaker.image_uris.retrieve(framework="pytorch",
region=region,
version="1.9.1",
py_version="py38",
image_scope='inference',
instance_type=INSTANCE_TYPE)

Krok 2: Ładowanie modelu ML z PyTorch Model Zoo

Następnie określamy model wykrywania obiektów z PyTorch Model Zoo i zapisujemy jego wagi modelu ML. Zazwyczaj zapisujemy model PyTorch z rozszerzeniem pliku .pt lub .pth. Poniższy fragment kodu pobiera wstępnie przeszkolony model Faster R-CNN ResNet50 ML z PyTorch Model Zoo:

model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)

Transformacja wsadowa SageMaker wymaga jako danych wejściowych pewnych wag modelu, więc zapiszemy wstępnie wytrenowany model ML jako model.pt. Jeśli chcemy załadować niestandardowy model, możemy zamiast tego zapisać wagi modelu z innego modelu PyTorch jako model.pt.

H = 1080
W = 1920
scripted_fn = torch.jit.script(model, torch.randn(1, 3, H, W))
scripted_fn.save("model.pt")

Krok 3: Zapisz i prześlij artefakty modelu ML do Amazon S3

Ponieważ będziemy używać SageMaker do wnioskowania ML, musimy przesłać wagi modelu do zasobnika S3. Możemy to zrobić za pomocą następujących poleceń lub pobierając i po prostu przeciągając i upuszczając plik bezpośrednio do S3. Następujące polecenia najpierw skompresują grupę plików w obrębie model.pt do tarballa i skopiuj wagi modelu z naszej lokalnej maszyny do zasobnika S3.

Note: Aby uruchomić następujące polecenia, musisz mieć Interfejs wiersza poleceń AWS (AWS CLI) zainstalowany.

tar -czvf model.tar.gz model.pt
aws s3 cp model.tar.gz $MODEL_ARTIFACTS_FILE_NAME

Następnie kopiujemy nasz obraz wejściowy do S3. Poniżej znajduje się pełna ścieżka S3 dla obrazu.

car_image_path = os.path.join(DATA_PATH, IMAGE_NAME)

Możemy skopiować ten obraz do S3 za pomocą innego polecenia aws s3 cp.

aws s3 cp cars.jpg $car_image_path

Krok 4: Budowanie skryptów wnioskowania o modelu ML

Teraz przejrzymy nasz plik punktu wejścia, inference.py moduł. Możemy wdrożyć model PyTorch przeszkolony poza SageMaker przy użyciu klasy PyTorchModel. Najpierw tworzymy instancję obiektu PyTorchModelZoo. Następnie skonstruujemy plik punktu wejścia inference.py, aby wykonać wnioskowanie ML przy użyciu transformacji wsadowej SageMaker na przykładowych danych hostowanych w Amazon S3.

Zrozumienie obiektu PyTorchModel

Połączenia Model PyTorch class w SageMaker Python API pozwala nam na wnioskowanie ML przy użyciu naszego pobranego artefaktu modelu.

Aby zainicjować klasę PyTorchModel, musimy zrozumieć następujące parametry wejściowe:

• name: Nazwa modelu; zalecamy użycie nazwy modelu + daty i godziny lub losowego ciągu znaków + daty i godziny w celu uzyskania wyjątkowości.
• model_data: Identyfikator URI S3 spakowanego artefaktu modelu ML.
• entry_point: Zdefiniowany przez użytkownika plik języka Python, który ma być używany przez wnioskowany obraz platformy Docker do definiowania programów obsługi dla żądań przychodzących. Kod definiuje ładowanie modelu, wstępne przetwarzanie danych wejściowych, logikę przewidywania i końcowe przetwarzanie danych wyjściowych.
• framework_version: Musi być ustawiona wersja 1.2 lub nowsza, aby włączyć automatyczne przepakowywanie modelu PyTorch.
• source_dir: katalog pliku entry_point.
• role: rola IAM do wysyłania żądań usług AWS.
• image_uri: Użyj tego obrazu kontenera Amazon ECR Docker jako bazy dla środowiska obliczeniowego modelu ML.
• sagemaker_session: Sesja SageMakera.
• py_version: Wersja języka Python, która ma być używana

Poniższy fragment kodu tworzy instancję klasy PyTorchModel w celu przeprowadzenia wnioskowania przy użyciu wstępnie wytrenowanego modelu PyTorch:

model = PyTorchModel(
               name=RANDOM_STRING,
               model_data=MODEL_ARTIFACTS_FILE_NAME,
               entry_point=ENTRY_POINT_FILE_NAME,
               framework_version=FRAMEWORK_VERSION,
               role=SAGEMAKER_EXECUTION_ROLE_ARN,
               sagemaker_session=sagemaker_session,
               image_uri=IMAGE_URI,
        )

Zrozumienie pliku punktu wejścia (inference.py)

Parametr entry_point wskazuje plik Pythona o nazwie inference.py. Ten punkt wejścia definiuje ładowanie modelu, wstępne przetwarzanie danych wejściowych, logikę przewidywania i końcowe przetwarzanie danych wyjściowych. Uzupełnia kod obsługujący model ML we wstępnie zbudowanym PyTorch Kontener głębokiego uczenia SageMaker obraz.

Inference.py będzie zawierał następujące funkcje. W naszym przykładzie implementujemy model_fn, input_fn, predict_fn i output_fn funkcje, aby zastąpić domyślna procedura obsługi wnioskowania PyTorch.

1. model_fn: pobiera katalog zawierający punkty kontrolne modelu statycznego w obrazie wnioskowania. Otwiera i ładuje model z określonej ścieżki i zwraca model PyTorch.
2. input_fn: Pobiera ładunek przychodzącego żądania (request_body) i typ zawartości przychodzącego żądania (request_content_type) jako dane wejściowe. Obsługuje dekodowanie danych. Ta funkcja musi być dostosowana do danych wejściowych oczekiwanych przez model.
3. predict_fn: Wywołuje model danych deserializowanych w input_fn. Wykonuje przewidywanie na deserializowanym obiekcie z załadowanym modelem ML.
4. output_fn: serializuje wynik przewidywania do żądanego typu zawartości odpowiedzi. Konwertuje prognozy uzyskane z funkcji przewidywania_fn na formaty JSON, CSV lub NPY.

Krok 5: Uruchomienie zadania transformacji wsadowej SageMaker

W tym przykładzie uzyskamy wyniki wnioskowania ML za pomocą zadania transformacji wsadowej SageMaker. Zadania przekształcania wsadowego są najbardziej przydatne, gdy chcemy jednorazowo uzyskać wnioski z zestawów danych, bez konieczności stosowania trwałego punktu końcowego. Tworzymy instancję a sagemaker.transformator.transformator obiekt do tworzenia i interakcji z zadaniami transformacji wsadowej SageMaker.

transformer = model.transformer(instance_type=INSTANCE_TYPE, 
                                instance_count=INSTANCE_COUNT
                                )
transformer.transform(data=DATA_PATH,
                      data_type="S3Prefix",
                      content_type="application/x-image",
                      wait=True
                      )

Zapoznaj się z dokumentacją dotyczącą tworzenia zadania transformacji wsadowej pod adresem UtwórzZadaniePrzekształć.

Krok 6: Wizualizacja wyników

Po zakończeniu zadania transformacji wsadowej SageMaker możemy załadować dane wyjściowe wnioskowania ML z Amazon S3. W tym celu przejdź do Konsola zarządzania AWS i wyszukaj Amazon SageMaker. Na lewym panelu pod Wnioskowanie, Patrz Zadania przekształcania wsadowego.

Po wybraniu Transformacja wsadowa, zobacz stronę internetową z listą wszystkich zadań transformacji wsadowej SageMaker. Możemy zobaczyć postęp naszej ostatniej realizacji zadania.

Po pierwsze, zadanie będzie miało status „W toku”. Po zakończeniu zobacz zmianę stanu na Ukończono.

Gdy status zostanie oznaczony jako ukończony, możemy kliknąć zadanie, aby wyświetlić wyniki. Ta strona internetowa zawiera podsumowanie zadania, w tym konfiguracje zadania, które właśnie wykonaliśmy.

Pod Konfiguracja danych wyjściowych, zobaczymy ścieżkę wyjściową S3. Tutaj znajdziemy dane wyjściowe wnioskowania ML.

Wybierz ścieżkę wyjściową S3 i zobacz plik [image_name].[file_type].out z naszymi danymi wyjściowymi. Nasz plik wyjściowy będzie zawierał listę mapowań. Przykładowe wyjście:

[
  {
    "boxes": [
      [
        214.32322692871094,
        192.18418884277344,
        830.3932495117188,
        521.6996459960938
      ],
      [
        235.6244354248047,
        301.3315734863281,
        253.6448516845703,
        312.3525695800781
      ],
      [
        183.92031860351562,
        291.7759704589844,
        207.28196716308594,
        312.1448669433594
      ],
    ],
    "labels": [
      3,
      3,
      9,
    ],
    "scores": [
      0.8823906183242798,
      0.7710548639297485,
      0.4969744384288788,
    ]
  }
]

Aby zwizualizować te przewidywania, najpierw odczytujemy ścieżkę wyjściową z naszego obiektu transformatora.

def get_output_from_s3(s3uri, file_name):
    parsed_url = urlparse(s3uri)
    bucket_name = parsed_url.netloc
    prefix = parsed_url.path[1:]
    s3 = boto3.resource('s3')
    obj = s3.Object(bucket_name, '{}/{}'.format(prefix, file_name))
    return obj.get()["Body"].read().decode('utf-8')
    
# Output path from Batch Transform job
output_path = transformer.output_path

# Get the output file from S3
predictions = get_output_from_s3(output_path, "car.jpg.out")

Następnie przetwarzamy ten plik wyjściowy i wizualizujemy nasze prognozy. Poniżej określamy nasz próg ufności. Otrzymujemy listę klas z Mapowanie obiektów zestawu danych COCO. Podczas wnioskowania model wymaga tylko tensorów wejściowych i zwraca predykcje po przetworzeniu jako List[Dict[Tensor]], po jednym dla każdego obrazu wejściowego. Pola Dict są następujące, gdzie N to liczba wykryć:

1. pudełka (FloatTensor[N, 4]): przewidywane pudełka w [x1, y1, x2, y2] format, z 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, Gdzie W jest szerokością obrazu i H to wysokość obrazu
2. etykiety (Int64Tensor[N]): przewidywane etykiety dla każdego wykrycia
3. wyniki (Tensor[N]): wyniki przewidywania dla każdego wykrycia

Aby uzyskać więcej informacji na temat wyjścia, patrz PyTorch Szybsza dokumentacja R-CNN FPN.

Dane wyjściowe modelu zawierają obwiednie z odpowiednimi wynikami ufności. Możemy zoptymalizować wyświetlanie fałszywych alarmów, usuwając obwiednie, dla których model nie jest pewny. Poniższe fragmenty kodu przetwarzają prognozy w pliku wyjściowym i rysują obwiednie na prognozach, w których wynik przekracza nasz próg ufności. Ustalamy próg prawdopodobieństwa, CONF_THRESH, do 75 w tym przykładzie.

def procress_batch_transform_output(predictions):
    predictions = eval(predictions)
    for pred in predictions[1:]:
        pred = pred[0]
        boxes = np.array(pred["boxes"])
        labels = np.array(pred["labels"])
        scores = np.array(pred["scores"])

        scores_idx = scores >= CONF_THRESH
        boxes_meet = boxes[scores_idx, :]
        labels_meet = labels[scores_idx]
        scores_meet = scores[scores_idx]

        labels_str = [CLASSES[i] for i in labels_meet]
        
        # Return a tuple containing labels, label index, score, and bounding box
        processed_predictions =  list(zip(labels_str, labels_meet, scores_meet, boxes_meet))
        return processed_predictions
    
    
def visualize_batch_transform_output(input_image, processed_predictions):
    # read input image from computer
    img = read_image(input_image)
    for label, label_index, score, box in processed_predictions:
        label = label + ", score: " + str(round(score, 2))
        # draw bounding box and fill color
        box = torch.tensor(box)
        box = box.unsqueeze(0)
        img = draw_bounding_boxes(img, box, width=5,labels=[label], font_size=16)

    # transform this image to PIL image
    img = torchvision.transforms.ToPILImage()(img)

    # display output
    img.show()

# Process the predictions in the output file
processed_predictions = procress_batch_transform_output(predictions)
visualize_batch_transform_output("car.jpg", processed_predictions)

Na koniec wizualizujemy te mapowania, aby zrozumieć nasze dane wyjściowe.

Note: jeśli obraz nie wyświetla się w twoim notatniku, znajdź go w drzewie katalogów po lewej stronie JupyterLab i otwórz go stamtąd.

Uruchamianie przykładowego kodu

Aby uzyskać pełny działający przykład, sklonuj kod w pliku amazon-sagemaker-przykłady GitHub i uruchomić komórki w create_pytorch_model_sagemaker.ipynb notatnik.

Wnioski

W tym poście na blogu zaprezentowaliśmy kompleksowy przykład przeprowadzania wnioskowania ML przy użyciu modelu wykrywania obiektów z PyTorch Model Zoo przy użyciu transformacji wsadowej SageMaker. Omówiliśmy ładowanie wag modelu wykrywania obiektów Faster R-CNN, zapisywanie ich w zasobniku S3, pisanie pliku punktu wejścia i zrozumienie kluczowych parametrów w interfejsie API PyTorchModel. Na koniec wdrożyliśmy model i przeprowadziliśmy wnioskowanie o modelu ML, zwizualizowaliśmy dane wyjściowe modelu i nauczyliśmy się interpretować wyniki.

O autorach

Dipika Khullar jest inżynierem ML w Laboratorium rozwiązań Amazon ML. Pomaga klientom integrować rozwiązania ML w celu rozwiązywania ich problemów biznesowych. Ostatnio budowała potoki szkoleniowe i wnioskowania dla klientów mediów oraz modele predykcyjne dla marketingu.

Marcelo Aberle jest inżynierem ML w organizacji AWS AI. Kieruje działaniami MLOps w Laboratorium rozwiązań Amazon ML, pomagając klientom projektować i wdrażać skalowalne systemy uczenia maszynowego. Jego misją jest prowadzenie klientów w ich podróży ML w przedsiębiorstwie i przyspieszenie ich ścieżki ML do produkcji.

Ninada Kulkarniego jest naukowcem stosowanym w Laboratorium rozwiązań Amazon ML. Pomaga klientom wdrażać ML i AI, tworząc rozwiązania rozwiązujące ich problemy biznesowe. Ostatnio budował modele predykcyjne dla klientów sportowych, motoryzacyjnych i medialnych.

Yash Shah jest kierownikiem naukowym w Laboratorium rozwiązań Amazon ML. On i jego zespół naukowców stosowanych i inżynierów ML pracują nad szeregiem przypadków użycia ML w opiece zdrowotnej, sporcie, motoryzacji i produkcji.