Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Introduzione al notebook di esempio Feature Store
**Importante**
Le politiche IAM personalizzate che consentono ad Amazon SageMaker Studio o Amazon SageMaker Studio Classic di creare SageMaker risorse Amazon devono inoltre concedere le autorizzazioni per aggiungere tag a tali risorse. L’autorizzazione per aggiungere tag alle risorse è necessaria perché Studio e Studio Classic applicano automaticamente tag a tutte le risorse che creano. Se una policy IAM consente a Studio e Studio Classic di creare risorse ma non consente il tagging, possono verificarsi errori durante il tentativo di creare risorse. AccessDenied Per ulteriori informazioni, consulta [Fornisci le autorizzazioni per l'etichettatura delle risorse SageMaker AI](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS politiche gestite per Amazon AI SageMaker](security-iam-awsmanpol.md)che forniscono le autorizzazioni per creare SageMaker risorse includono già le autorizzazioni per aggiungere tag durante la creazione di tali risorse.
Il codice esemplificativo in questa pagina si riferisce al notebook di esempio [Introduzione al Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/feature_store_introduction.html). Ti consigliamo di eseguire questo notebook in Studio Classic, nelle istanze del notebook o JupyterLab perché il codice di questa guida è concettuale e non completamente funzionante se copiato.
Usa quanto segue per clonare il repository [ aws/amazon ](https://github.com/aws/amazon-sagemaker-examples) GitHub -sagemaker-examples, contenente il notebook di esempio:
+ **Per Studio Classic**
Avvia Studio Classic. Puoi aprire Studio Classic se l’esperienza predefinita è impostata su Studio o Studio Classic. Per ricevere istruzioni su come aprire Studio Classic, consulta [Avvia Amazon SageMaker Studio Classic utilizzando la console Amazon SageMaker AI](studio-launch.md#studio-launch-console).
Clona il repository [ aws/amazon ](https://github.com/aws/amazon-sagemaker-examples) GitHub -sagemaker-examples in Studio Classic seguendo i passaggi indicati. [Clona un repository Git in Amazon Studio Classic SageMaker](studio-tasks-git.md)
+ **Per SageMaker le istanze di notebook Amazon **
Avvia l'istanza del SageMaker notebook seguendo le istruzioni in[Accesso alle istanze del notebook](howitworks-access-ws.md).
Ora che hai i taccuini di esempio SageMaker AI, vai alla `amazon-sagemaker-examples/sagemaker-featurestore` directory e apri il taccuino di esempio [ Introduction to Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/feature_store_introduction.html).
## Passaggio 1: configura la tua sessione di intelligenza artificiale SageMaker
Per iniziare a utilizzare Feature Store, crea una sessione SageMaker AI. Quindi, configura il bucket Amazon Simple Storage Service (Amazon S3) da utilizzare per le funzionalità. Il bucket Amazon S3 è rappresentato dall’archivio offline. Il codice seguente utilizza il bucket SageMaker AI predefinito e vi aggiunge un prefisso personalizzato.
**Nota**
Al ruolo utilizzato per eseguire il notebook devono essere collegate le seguenti policy gestite: `AmazonS3FullAccess` e `AmazonSageMakerFeatureStoreAccess`. Per informazioni sull’aggiunta di policy al ruolo IAM, consulta [Aggiunta di policy al ruolo IAM](feature-store-adding-policies.md).
```
# SageMaker Python SDK version 3.x is required
import sagemaker
import sys
```
```
import boto3
import pandas as pd
import numpy as np
import io
from sagemaker.core.helper.session_helper import Session
from sagemaker.core.helper.session_helper import get_execution_role
prefix = 'sagemaker-featurestore-introduction'
role = get_execution_role()
sagemaker_session = Session()
region = sagemaker_session.boto_region_name
s3_bucket_name = sagemaker_session.default_bucket()
```
## Fase 2: verifica dei dati
In questo esempio di notebook, inseriamo dati sintetici dal [ GitHub repository ](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-featurestore/data) che ospita l'intero notebook.
```
customer_data = pd.read_csv("data/feature_store_introduction_customer.csv")
orders_data = pd.read_csv("data/feature_store_introduction_orders.csv")
print(customer_data.head())
print(orders_data.head())
```
Il diagramma seguente illustra le fasi eseguite sui dati prima di poterli inserire nell’archivio delle caratteristiche. Nel caso d’uso descritto in questo notebook, disponi di dati provenienti da più origini che vuoi archiviare in modo indipendente in un archivio delle caratteristiche. L’esempio considera i dati di un data warehouse (dati dei clienti) e i dati di un servizio di streaming in tempo reale (dati degli ordini).
## Fase 3: creazione di gruppi di funzionalità
Per iniziare, vengono creati i nomi dei gruppi di funzionalità per customer\_data e orders\_data. Successivamente, crea due gruppi di funzionalità, uno per `customer_data` e l’altro per `orders_data`:
```
import time
from time import strftime, gmtime
customers_feature_group_name = 'customers-feature-group-' + strftime('%d-%H-%M-%S', gmtime())
orders_feature_group_name = 'orders-feature-group-' + strftime('%d-%H-%M-%S', gmtime())
```
Nella V3, `FeatureGroup.create()` è un metodo di classe che crea e restituisce direttamente il gruppo di funzionalità, quindi non è necessaria alcuna fase di creazione di istanze separata.
```
from sagemaker.mlops.feature_store import FeatureGroup
# No separate instantiation needed in v3; FeatureGroup.create() is called directly below
```
```
import time
current_time_sec = int(round(time.time()))
record_identifier_feature_name = "customer_id"
```
Aggiungi funzionalità `EventTime` al data frame. Questo parametro è obbligatorio e inserisce un timestamp di ogni punto dati:
```
customer_data["EventTime"] = pd.Series([current_time_sec]*len(customer_data), dtype="float64")
orders_data["EventTime"] = pd.Series([current_time_sec]*len(orders_data), dtype="float64")
```
Carica le definizioni delle funzionalità nel tuo gruppo di funzionalità:
```
from sagemaker.mlops.feature_store import load_feature_definitions_from_dataframe
customer_feature_defs = load_feature_definitions_from_dataframe(customer_data)
order_feature_defs = load_feature_definitions_from_dataframe(orders_data)
```
Il codice seguente chiama `create` per creare due gruppi di funzionalità, rispettivamente `customers_feature_group` e `orders_feature_group`:
```
from sagemaker.mlops.feature_store import OnlineStoreConfig, OfflineStoreConfig, S3StorageConfig
FeatureGroup.create(
feature_group_name=customers_feature_group_name,
feature_definitions=customer_feature_defs,
record_identifier_feature_name=record_identifier_feature_name,
event_time_feature_name="EventTime",
role_arn=role,
online_store_config=OnlineStoreConfig(enable_online_store=True),
offline_store_config=OfflineStoreConfig(
s3_storage_config=S3StorageConfig(s3_uri=f"s3://{s3_bucket_name}/{prefix}")
),
)
FeatureGroup.create(
feature_group_name=orders_feature_group_name,
feature_definitions=order_feature_defs,
record_identifier_feature_name=record_identifier_feature_name,
event_time_feature_name="EventTime",
role_arn=role,
online_store_config=OnlineStoreConfig(enable_online_store=True),
offline_store_config=OfflineStoreConfig(
s3_storage_config=S3StorageConfig(s3_uri=f"s3://{s3_bucket_name}/{prefix}")
),
)
```
Per confermare la creazione del gruppo di funzionalità, puoi visualizzarlo utilizzando le API `DescribeFeatureGroup` e `ListFeatureGroups`:
```
customers_fg = FeatureGroup.get(feature_group_name=customers_feature_group_name)
```
```
orders_fg = FeatureGroup.get(feature_group_name=orders_feature_group_name)
```
```
sagemaker_session.boto_session.client('sagemaker', region_name=region).list_feature_groups() # We use the boto client to list FeatureGroups
```
## Fase 4: inserimento di dati in un gruppo di funzionalità
Dopo aver creato i gruppi di funzionalità, puoi inserirvi dati. Se stai usando l' SageMaker IA AWS SDK per Python (Boto3), usa la chiamata API. `ingest` Se stai utilizzando SDK per Python (Boto3), utilizza l’API `PutRecord`. Occorre meno di 1 minuto per inserire i dati in entrambe le opzioni. Questo esempio utilizza l'SDK SageMaker AI per Python (Boto3), quindi utilizza la chiamata API: `ingest`
```
def check_feature_group_status(feature_group):
status = feature_group.describe().get("FeatureGroupStatus")
while status == "Creating":
print("Waiting for Feature Group to be Created")
time.sleep(5)
status = feature_group.describe().get("FeatureGroupStatus")
print(f"FeatureGroup {feature_group.name} successfully created.")
check_feature_group_status(customers_feature_group)
check_feature_group_status(orders_feature_group)
```
```
from sagemaker.mlops.feature_store import ingest_dataframe
ingest_dataframe(
feature_group_name=customers_feature_group_name, data_frame=customer_data, max_workers=3, wait=True
)
```
```
ingest_dataframe(
feature_group_name=orders_feature_group_name, data_frame=orders_data, max_workers=3, wait=True
)
```
Con un ID record cliente arbitrario, 573291, si usa `get_record` per verificare che i dati siano stati inseriti nel gruppo di funzionalità.
```
customer_id = 573291
sample_record = sagemaker_session.boto_session.client('sagemaker-featurestore-runtime', region_name=region).get_record(FeatureGroupName=customers_feature_group_name, RecordIdentifierValueAsString=str(customer_id))
```
```
print(sample_record)
```
Di seguito viene illustrato come utilizzare `batch_get_record` per ottenere un batch di record.
```
all_records = sagemaker_session.boto_session.client(
"sagemaker-featurestore-runtime", region_name=region
).batch_get_record(
Identifiers=[
{
"FeatureGroupName": customers_feature_group_name,
"RecordIdentifiersValueAsString": ["573291", "109382", "828400", "124013"],
},
{
"FeatureGroupName": orders_feature_group_name,
"RecordIdentifiersValueAsString": ["573291", "109382", "828400", "124013"],
},
]
)
```
```
print(all_records)
```
## Fase 5: rimozione
In questa fase, vengono rimossi i gruppi di funzionalità creati.
```
FeatureGroup(feature_group_name=customers_feature_group_name).delete()
FeatureGroup(feature_group_name=orders_feature_group_name).delete()
```
## Fase 6: fasi successive
In questo notebook di esempio, hai appreso come iniziare a utilizzare l’archivio delle caratteristiche, creare gruppi di funzionalità e inserirvi dati.
Per un esempio avanzato su come utilizzare Feature Store per un caso d’uso relativo al rilevamento delle frodi, consulta la pagina che spiega come [rilevare le frodi con Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/sagemaker_featurestore_fraud_detection_python_sdk.html).
## Fase 7. Esempi di codice per programmatori
In questo notebook è stata utilizzata un’ampia varietà di chiamate API. La maggior parte di essi è accessibile tramite SageMaker Python SDK, tuttavia alcuni esistono solo all'interno di Boto3. Puoi richiamare le chiamate API SageMaker Python SDK direttamente sugli oggetti Feature Store, mentre per richiamare le chiamate API esistenti all'interno di Boto3, devi prima accedere a un client Boto3 tramite le tue sessioni Boto3 e AI: ad esempio,. SageMaker `sagemaker_session.boto_session.client()`
Di seguito è riportato un elenco di chiamate API per questo notebook. Queste chiamate sono disponibili all’interno dell’SDK for Python e in Boto3:
**Chiamate API per l’SDK per Python (Boto3)**
```
describe()
ingest()
delete()
create()
load_feature_definitions()
```
**Chiamate API boto3**
```
list_feature_groups()
get_record()
```