Samouczek 2. Eksperymentowanie i trenowanie modeli przy użyciu funkcji

Artykuł
09/30/2024

W tej serii samouczków pokazano, jak funkcje bezproblemowo integrują wszystkie fazy cyklu życia uczenia maszynowego: tworzenie prototypów, trenowanie i operacjonalizacja.

W pierwszym samouczku pokazano, jak utworzyć specyfikację zestawu funkcji z przekształceniami niestandardowymi. Następnie pokazano, jak używać tego zestawu funkcji do generowania danych treningowych, włączania materializacji i wykonywania wypełniania. W tym samouczku pokazano, jak włączyć materializację i wykonać wypełnianie. Pokazuje również, jak eksperymentować z funkcjami jako sposób poprawy wydajności modelu.

Z tego samouczka dowiesz się, jak wykonywać następujące czynności:

Utwórz prototyp nowej accounts specyfikacji zestawu funkcji, używając istniejących wstępnie skompilowanych wartości jako funkcji. Następnie zarejestruj specyfikację lokalnego zestawu funkcji jako zestaw funkcji w magazynie funkcji. Ten proces różni się od pierwszego samouczka, w którym utworzono zestaw funkcji, który miał przekształcenia niestandardowe.
Wybierz funkcje modelu z transactions zestawów funkcji i accounts i i zapisz je jako specyfikację pobierania funkcji.
Uruchom potok trenowania, który używa specyfikacji pobierania funkcji do trenowania nowego modelu. Ten potok używa wbudowanego składnika pobierania funkcji do generowania danych treningowych.

Wymagania wstępne

Przed kontynuowaniem pracy z tym samouczkiem pamiętaj, aby ukończyć pierwszy samouczek z serii.

Konfiguruj

Konfigurowanie notesu platformy Spark usługi Azure Machine Learning.

Możesz utworzyć nowy notes i wykonać instrukcje opisane w tym samouczku krok po kroku. Możesz również otworzyć i uruchomić istniejący notes o nazwie 2.Experiment-train-models-using-features.ipynb z katalogu featurestore_sample/notebooks . Możesz wybrać sdk_only lub sdk_and_cli. Pozostaw ten samouczek otwarty i zapoznaj się z nim, aby uzyskać linki do dokumentacji i więcej wyjaśnień.
1. W górnym menu z listy rozwijanej Obliczenia wybierz pozycję Bezserwerowe obliczenia Spark w obszarze Bezserwerowa platforma Spark w usłudze Azure Machine Learning Serverless Spark.
2. Skonfiguruj sesję:
  1. Gdy na pasku narzędzi zostanie wyświetlona opcja Konfiguruj sesję, wybierz ją.
  2. Na karcie Pakiety języka Python wybierz pozycję Przekaż plik Conda.
  3. Przekaż plik conda.yml przekazany w pierwszym samouczku.
  4. W ramach opcji możesz zwiększyć limit czasu sesji (czas bezczynności), aby uniknąć częstych ponownych uruchomień wymagań wstępnych.

Uruchom sesję platformy Spark.

# run this cell to start the spark session (any code block will start the session ). This can take around 10 mins.
print("start spark session")

Skonfiguruj katalog główny dla przykładów.

import os

# please update the dir to ./Users/<your_user_alias> (or any custom directory you uploaded the samples to).
# You can find the name from the directory structure in the left nav
root_dir = "./Users/<your_user_alias>/featurestore_sample"

if os.path.isdir(root_dir):
    print("The folder exists.")
else:
    print("The folder does not exist. Please create or fix the path")

Konfigurowanie interfejsu wiersza polecenia.
- Zestaw SDK dla języka Python
- Interfejs wiersza polecenia platformy Azure
Nie dotyczy.
1. Zainstaluj rozszerzenie usługi Azure Machine Learning.
```
!az extension add --name ml
```
2. Uwierzytelniania.
```
!az login
```
3. Ustaw subskrypcję domyślną.
```
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```

Zainicjuj zmienne obszaru roboczego projektu.

Jest to bieżący obszar roboczy, a notes samouczka jest uruchamiany w tym zasobie.

### Initialize the MLClient of this project workspace
import os
from azure.ai.ml import MLClient
from azure.ai.ml.identity import AzureMLOnBehalfOfCredential

project_ws_sub_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
project_ws_rg = os.environ["AZUREML_ARM_RESOURCEGROUP"]
project_ws_name = os.environ["AZUREML_ARM_WORKSPACE_NAME"]

# connect to the project workspace
ws_client = MLClient(
    AzureMLOnBehalfOfCredential(), project_ws_sub_id, project_ws_rg, project_ws_name
)

Zainicjuj zmienne magazynu funkcji.

Pamiętaj, aby zaktualizować featurestore_name wartości i featurestore_location , aby odzwierciedlić to, co zostało utworzone w pierwszym samouczku.

from azure.ai.ml import MLClient
from azure.ai.ml.identity import AzureMLOnBehalfOfCredential

# feature store
featurestore_name = (
    "<FEATURESTORE_NAME>"  # use the same name from part #1 of the tutorial
)
featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

# feature store ml client
fs_client = MLClient(
    AzureMLOnBehalfOfCredential(),
    featurestore_subscription_id,
    featurestore_resource_group_name,
    featurestore_name,
)

Zainicjuj klienta użycia magazynu funkcji.

# feature store client
from azureml.featurestore import FeatureStoreClient
from azure.ai.ml.identity import AzureMLOnBehalfOfCredential

featurestore = FeatureStoreClient(
    credential=AzureMLOnBehalfOfCredential(),
    subscription_id=featurestore_subscription_id,
    resource_group_name=featurestore_resource_group_name,
    name=featurestore_name,
)

Utwórz klaster obliczeniowy o nazwie cpu-cluster w obszarze roboczym projektu.

Ten klaster obliczeniowy jest potrzebny podczas uruchamiania zadań trenowania/wnioskowania wsadowego.

from azure.ai.ml.entities import AmlCompute

cluster_basic = AmlCompute(
    name="cpu-cluster-fs",
    type="amlcompute",
    size="STANDARD_F4S_V2",  # you can replace it with other supported VM SKUs
    location=ws_client.workspaces.get(ws_client.workspace_name).location,
    min_instances=0,
    max_instances=1,
    idle_time_before_scale_down=360,
)
ws_client.begin_create_or_update(cluster_basic).result()

Tworzenie zestawu funkcji kont w środowisku lokalnym

W pierwszym samouczku utworzono transactions zestaw funkcji zawierający przekształcenia niestandardowe. W tym miejscu utworzysz accounts zestaw funkcji, który używa wstępnie skompilowanych wartości.

Aby dołączyć wstępnie skompilowane funkcje, można utworzyć specyfikację zestawu funkcji bez konieczności pisania kodu przekształcenia. Używasz specyfikacji zestawu funkcji do tworzenia i testowania zestawu funkcji w w pełni lokalnym środowisku projektowym.

Nie musisz łączyć się z magazynem funkcji. W tej procedurze utworzysz lokalnie specyfikację zestawu funkcji, a następnie próbkujesz z niej wartości. Aby skorzystać z możliwości magazyn zarządzanych funkcji, należy użyć definicji zasobów funkcji, aby zarejestrować specyfikację zestawu funkcji w magazynie funkcji. Dalsze kroki opisane w tym samouczku zawierają więcej szczegółów.

Eksplorowanie danych źródłowych dla kont.

Uwaga

W tym notesie są używane przykładowe dane hostowane w publicznie dostępnym kontenerze obiektów blob. wasbs Tylko sterownik może go odczytać na platformie Spark. Podczas tworzenia zestawów funkcji przy użyciu własnych danych źródłowych hostuj te zestawy funkcji na koncie usługi Azure Data Lake Storage Gen2 i użyj abfss sterownika w ścieżce danych.
```
accounts_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet"
accounts_df = spark.read.parquet(accounts_data_path)

display(accounts_df.head(5))
```

Utwórz specyfikację accounts zestawu funkcji lokalnie na podstawie tych wstępnie skompilowanych funkcji.

W tym miejscu nie potrzebujesz żadnego kodu przekształcenia, ponieważ odwołujesz się do wstępnie skompilowanych funkcji.

from azureml.featurestore import create_feature_set_spec, FeatureSetSpec
from azureml.featurestore.contracts import (
    DateTimeOffset,
    Column,
    ColumnType,
    SourceType,
    TimestampColumn,
)
from azureml.featurestore.feature_source import ParquetFeatureSource


accounts_featureset_spec = create_feature_set_spec(
    source=ParquetFeatureSource(
        path="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
    ),
    index_columns=[Column(name="accountID", type=ColumnType.string)],
    # account profiles in the source are updated once a year. set temporal_join_lookback to 365 days
    temporal_join_lookback=DateTimeOffset(days=365, hours=0, minutes=0),
    infer_schema=True,
)

Eksportuj jako specyfikację zestawu funkcji.

Aby zarejestrować specyfikację zestawu funkcji w magazynie funkcji, należy zapisać specyfikację zestawu funkcji w określonym formacie.

Po uruchomieniu następnej komórki sprawdź wygenerowaną accounts specyfikację zestawu funkcji. Aby wyświetlić specyfikację, otwórz plik featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml z drzewa plików.

Specyfikacja ma następujące ważne elementy:
- source: odwołanie do zasobu magazynu. W takim przypadku jest to plik Parquet w zasobie magazynu obiektów blob.
- features: lista funkcji i ich typów danych. W przypadku dostarczonego kodu przekształcenia kod musi zwracać ramkę danych, która jest mapowania na funkcje i typy danych. Bez podanego kodu transformacji system tworzy zapytanie, aby mapować funkcje i typy danych na źródło. W tym przypadku wygenerowana accounts specyfikacja zestawu funkcji nie zawiera kodu przekształcenia, ponieważ funkcje są wstępnie skompilowane.
- index_columns: klucze sprzężenia wymagane do uzyskania dostępu do wartości z zestawu funkcji.
Aby dowiedzieć się więcej, odwiedź stronę Understanding top-level entities in magazyn zarządzanych funkcji and the CLI (v2) feature set specification YAML schema resources (Informacje o jednostkach najwyższego poziomu w magazyn zarządzanych funkcji i zasobach schematu zestawu funkcji interfejsu wiersza polecenia (wersja 2).

Dodatkową korzyścią jest obsługa kontroli źródła.

W tym miejscu nie potrzebujesz żadnego kodu przekształcenia, ponieważ odwołujesz się do wstępnie skompilowanych funkcji.
```
import os

# create a new folder to dump the feature set spec
accounts_featureset_spec_folder = root_dir + "/featurestore/featuresets/accounts/spec"

# check if the folder exists, create one if not
if not os.path.exists(accounts_featureset_spec_folder):
    os.makedirs(accounts_featureset_spec_folder)

accounts_featureset_spec.dump(accounts_featureset_spec_folder, overwrite=True)
```

Lokalnie poeksperymentuj z niezarejestrowanych funkcji i zarejestruj się w magazynie funkcji, gdy wszystko będzie gotowe

Podczas opracowywania funkcji warto przetestować je lokalnie i zweryfikować, zanim zarejestrujesz je w magazynie funkcji lub uruchom potoki trenowania w chmurze. Kombinacja lokalnego niezarejestrowanego zestawu funkcji (accounts) i zestawu funkcji zarejestrowanego w magazynie funkcji (transactions) generuje dane szkoleniowe dla modelu uczenia maszynowego.

Wybierz funkcje modelu.

# get the registered transactions feature set, version 1
transactions_featureset = featurestore.feature_sets.get("transactions", "1")
# Notice that account feature set spec is in your local dev environment (this notebook): not registered with feature store yet
features = [
    accounts_featureset_spec.get_feature("accountAge"),
    accounts_featureset_spec.get_feature("numPaymentRejects1dPerUser"),
    transactions_featureset.get_feature("transaction_amount_7d_sum"),
    transactions_featureset.get_feature("transaction_amount_3d_sum"),
    transactions_featureset.get_feature("transaction_amount_7d_avg"),
]

Lokalne generowanie danych treningowych.

Ten krok generuje dane treningowe w celach ilustracyjnych. W tym miejscu możesz trenować modele lokalnie. W kolejnych krokach tego samouczka wyjaśniono, jak wytrenować model w chmurze.

from azureml.featurestore import get_offline_features

# Load the observation data. To understand observatio ndata, refer to part 1 of this tutorial
observation_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/train/*.parquet"
observation_data_df = spark.read.parquet(observation_data_path)
obs_data_timestamp_column = "timestamp"

# generate training dataframe by using feature data and observation data
training_df = get_offline_features(
    features=features,
    observation_data=observation_data_df,
    timestamp_column=obs_data_timestamp_column,
)

# Ignore the message that says feature set is not materialized (materialization is optional). We will enable materialization in the next part of the tutorial.
display(training_df)
# Note: display(training_df.head(5)) displays the timestamp column in a different format. You can can call training_df.show() to see correctly formatted value

Zarejestruj zestaw funkcji w accounts magazynie funkcji.

Po lokalnym eksperymencie z definicjami funkcji i jeśli wydają się uzasadnione, możesz zarejestrować definicję zasobu zestawu funkcji w magazynie funkcji.

from azure.ai.ml.entities import FeatureSet, FeatureSetSpecification

accounts_fset_config = FeatureSet(
    name="accounts",
    version="1",
    description="accounts featureset",
    entities=[f"azureml:account:1"],
    stage="Development",
    specification=FeatureSetSpecification(path=accounts_featureset_spec_folder),
    tags={"data_type": "nonPII"},
)

poller = fs_client.feature_sets.begin_create_or_update(accounts_fset_config)
print(poller.result())

Pobierz zarejestrowany zestaw funkcji i przetestuj go.

# look up the featureset by providing name and version
accounts_featureset = featurestore.feature_sets.get("accounts", "1")

Uruchamianie eksperymentu szkoleniowego

W tych krokach wybierz listę funkcji, uruchom potok trenowania i zarejestrujesz model. Te kroki można powtórzyć, dopóki model nie będzie działać zgodnie z potrzebami.

Opcjonalnie możesz odnajdywać funkcje z poziomu interfejsu użytkownika magazynu funkcji.

Pierwszy samouczek obejmował ten krok po zarejestrowaniu transactions zestawu funkcji. Ponieważ masz accounts również zestaw funkcji, możesz przeglądać dostępne funkcje:
1. Przejdź do globalnej strony docelowej usługi Azure Machine Learning.
2. W okienku po lewej stronie wybierz pozycję Magazyny funkcji.
3. Na liście magazynów funkcji wybierz utworzony wcześniej magazyn funkcji.
W interfejsie użytkownika są wyświetlane zestawy funkcji i utworzona jednostka. Wybierz zestawy funkcji, aby przeglądać definicje funkcji. Możesz użyć globalnego pola wyszukiwania, aby wyszukać zestawy funkcji w różnych magazynach funkcji.

Opcjonalnie możesz odnajdywać funkcje z zestawu SDK.

# List available feature sets
all_featuresets = featurestore.feature_sets.list()
for fs in all_featuresets:
    print(fs)

# List of versions for transactions feature set
all_transactions_featureset_versions = featurestore.feature_sets.list(
    name="transactions"
)
for fs in all_transactions_featureset_versions:
    print(fs)

# See properties of the transactions featureset including list of features
featurestore.feature_sets.get(name="transactions", version="1").features

Wybierz funkcje modelu i wyeksportuj model jako specyfikację pobierania funkcji.

W poprzednich krokach wybrano funkcje z kombinacji zarejestrowanych i niezarejestrowanych zestawów funkcji na potrzeby eksperymentowania lokalnego i testowania. Teraz możesz eksperymentować w chmurze. Elastyczność wysyłki modelu zwiększa się, jeśli zapiszesz wybrane funkcje jako specyfikację pobierania funkcji, a następnie użyj specyfikacji w operacjach uczenia maszynowego (MLOps) lub ciągłej integracji i ciągłego dostarczania (CI/CD) na potrzeby trenowania i wnioskowania.
1. Wybierz funkcje modelu.
```
# you can select features in pythonic way
features = [
    accounts_featureset.get_feature("accountAge"),
    transactions_featureset.get_feature("transaction_amount_7d_sum"),
    transactions_featureset.get_feature("transaction_amount_3d_sum"),
]

# you can also specify features in string form: featurestore:featureset:version:feature
more_features = [
    f"accounts:1:numPaymentRejects1dPerUser",
    f"transactions:1:transaction_amount_7d_avg",
]

more_features = featurestore.resolve_feature_uri(more_features)

features.extend(more_features)
```
2. Wyeksportuj wybrane funkcje jako specyfikację pobierania funkcji.
  
  Specyfikacja pobierania funkcji to przenośna definicja listy funkcji skojarzonej z modelem. Może to pomóc usprawnić opracowywanie i operacjonalizacja modelu uczenia maszynowego. Staje się to danymi wejściowymi potoku trenowania, który generuje dane szkoleniowe. Następnie jest on spakowany przy użyciu modelu.
  
  Faza wnioskowania używa pobierania funkcji w celu wyszukania funkcji. Integruje wszystkie fazy cyklu życia uczenia maszynowego. Zmiany potoku trenowania/wnioskowania mogą pozostać co najmniej podczas eksperymentowania i wdrażania.
  
  Korzystanie ze specyfikacji pobierania funkcji i wbudowanego składnika pobierania funkcji jest opcjonalne. Możesz bezpośrednio użyć interfejsu get_offline_features() API, jak pokazano wcześniej. Nazwa specyfikacji powinna być feature_retrieval_spec.yaml podczas tworzenia pakietu za pomocą modelu. Dzięki temu system może go rozpoznać.
```
# Create feature retrieval spec
feature_retrieval_spec_folder = root_dir + "/project/fraud_model/feature_retrieval_spec"

# check if the folder exists, create one if not
if not os.path.exists(feature_retrieval_spec_folder):
    os.makedirs(feature_retrieval_spec_folder)

featurestore.generate_feature_retrieval_spec(feature_retrieval_spec_folder, features)
```

Trenowanie w chmurze przy użyciu potoków i rejestrowanie modelu

W tej procedurze ręcznie wyzwolisz potok trenowania. W scenariuszu produkcyjnym potok ciągłej integracji/ciągłego wdrażania może go wyzwolić na podstawie zmian specyfikacji pobierania funkcji w repozytorium źródłowym. Jeśli model jest zadowalający, możesz zarejestrować go.

Uruchom potok trenowania.

Potok trenowania obejmuje następujące kroki:
1. Pobieranie funkcji: w przypadku danych wejściowych ten wbudowany składnik przyjmuje specyfikację pobierania funkcji, dane obserwacji i nazwę kolumny sygnatury czasowej . Następnie generuje dane treningowe jako dane wyjściowe. Te kroki są uruchamiane jako zarządzane zadanie platformy Spark.
2. Trenowanie: na podstawie danych treningowych ten krok trenuje model, a następnie generuje model (jeszcze niezarejestrowany).
3. Ocena: ten krok sprawdza, czy wydajność i jakość modelu mieszczą się w progu. (W tym samouczku jest to krok zastępczy dla celów ilustracyjnych).
4. Zarejestruj model: ten krok rejestruje model.
  
  Uwaga
  
  W drugim samouczku uruchomiono zadanie wypełniania w celu zmaterializowania danych dla transactions zestawu funkcji. Krok pobierania funkcji odczytuje wartości funkcji ze sklepu offline dla tego zestawu funkcji. Zachowanie jest takie samo, nawet jeśli używasz interfejsu get_offline_features() API.
```
from azure.ai.ml import load_job  # will be used later

training_pipeline_path = (
    root_dir + "/project/fraud_model/pipelines/training_pipeline.yaml"
)
training_pipeline_definition = load_job(source=training_pipeline_path)
training_pipeline_job = ws_client.jobs.create_or_update(training_pipeline_definition)
ws_client.jobs.stream(training_pipeline_job.name)
# Note: First time it runs, each step in pipeline can take ~ 15 mins. However subsequent runs can be faster (assuming spark pool is warm - default timeout is 30 mins)
```
5. Sprawdź potok trenowania i model.
  - Aby wyświetlić kroki potoku, wybierz hiperlink potoku Widok internetowy i otwórz go w nowym oknie.
Użyj specyfikacji pobierania funkcji w artefaktach modelu:
1. W lewym okienku bieżącego obszaru roboczego wybierz pozycję Modele z prawym przyciskiem myszy.
2. Wybierz pozycję Otwórz na nowej karcie lub w oknie.
3. Wybierz pozycję fraud_model.
4. Wybierz pozycję Artefakty.
Specyfikacja pobierania funkcji jest spakowana wraz z modelem. Krok rejestracji modelu w potoku trenowania obsłużył ten krok. Podczas eksperymentowania utworzono specyfikację pobierania funkcji. Teraz jest to część definicji modelu. W następnym samouczku zobaczysz, jak używa tego procesu wnioskowania.

Wyświetlanie zestawu funkcji i zależności modelu

Wyświetl listę zestawów funkcji skojarzonych z modelem.

Na tej samej stronie Modele wybierz kartę Zestawy funkcji. Na tej karcie są wyświetlane zestawy transactions funkcji i accounts . Ten model zależy od tych zestawów funkcji.
Wyświetl listę modeli korzystających z zestawów funkcji:
1. Otwórz interfejs użytkownika magazynu funkcji (objaśniony wcześniej w tym samouczku).
2. W okienku po lewej stronie wybierz pozycję Zestawy funkcji.
3. Wybierz zestaw funkcji.
4. Wybierz kartę Modele .
Specyfikacja pobierania funkcji określiła tę listę podczas rejestrowania modelu.

Czyszczenie

Piąty samouczek z serii opisuje sposób usuwania zasobów.

Następne kroki

Przejdź do następnego samouczka z serii: Włącz rekursywną materializację i uruchom wnioskowanie wsadowe.
Dowiedz się więcej o pojęciach dotyczących magazynu funkcji i jednostkach najwyższego poziomu w magazyn zarządzanych funkcji.
Dowiedz się więcej na temat tożsamości i kontroli dostępu dla magazyn zarządzanych funkcji.
Zapoznaj się z przewodnikiem rozwiązywania problemów dla magazyn zarządzanych funkcji.
Wyświetl dokumentację YAML.

Udostępnij za pośrednictwem