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 l'etichettatura, possono verificarsi errori AccessDenied "" durante il tentativo di creare risorse. Per ulteriori informazioni, consulta [Fornisci le autorizzazioni per etichettare SageMaker le risorse AI](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS politiche gestite per Amazon SageMaker AI](security-iam-awsmanpol.md)che danno i permessi 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). Si consiglia di eseguire questo notebook in Studio Classic, nelle istanze di notebook o JupyterLab perché il codice contenuto in questa guida è concettuale e non completamente funzionale se copiato.
Usa quanto segue per clonare il amazon-sagemaker-examples GitHub repository [aws/, contenente](https://github.com/aws/amazon-sagemaker-examples) 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 amazon-sagemaker-examples GitHub repository [aws/ su Studio Classic](https://github.com/aws/amazon-sagemaker-examples) seguendo i passaggi indicati. [Clona un repository Git in Amazon Studio Classic SageMaker](studio-tasks-git.md)
+ **Per le istanze di SageMaker notebook Amazon**
Avvia l'istanza del SageMaker notebook seguendo le istruzioni riportate in[Accesso alle istanze del notebook](howitworks-access-ws.md).
Ora che hai i notebook di esempio SageMaker AI, vai alla `amazon-sagemaker-examples/sagemaker-featurestore` directory e apri il notebook di esempio [Introduction to Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/feature_store_introduction.html).
## Passaggio 1: configura la 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 2.x is required
import sagemaker
import sys
```
```
import boto3
import pandas as pd
import numpy as np
import io
from sagemaker.session import Session
from sagemaker import get_execution_role
prefix = 'sagemaker-featurestore-introduction'
role = get_execution_role()
sagemaker_session = sagemaker.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())
```
Crea un’istanza di un oggetto `FeatureGroup` per `customers_data` e `orders_data`:
```
from sagemaker.feature_store.feature_group import FeatureGroup
customers_feature_group = FeatureGroup(
name=customers_feature_group_name, sagemaker_session=sagemaker_session
)
orders_feature_group = FeatureGroup(
name=orders_feature_group_name, sagemaker_session=sagemaker_session
)
```
```
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à:
```
customers_feature_group.load_feature_definitions(data_frame=customer_data)
orders_feature_group.load_feature_definitions(data_frame=orders_data)
```
Il codice seguente chiama `create` per creare due gruppi di funzionalità, rispettivamente `customers_feature_group` e `orders_feature_group`:
```
customers_feature_group.create(
s3_uri=f"s3://{s3_bucket_name}/{prefix}",
record_identifier_name=record_identifier_feature_name,
event_time_feature_name="EventTime",
role_arn=role,
enable_online_store=True
)
orders_feature_group.create(
s3_uri=f"s3://{s3_bucket_name}/{prefix}",
record_identifier_name=record_identifier_feature_name,
event_time_feature_name="EventTime",
role_arn=role,
enable_online_store=True
)
```
Per confermare che il tuo gruppo di funzionalità è stato creato, lo visualizziamo utilizzando `DescribeFeatureGroup` e: `ListFeatureGroups` APIs
```
customers_feature_group.describe()
```
```
orders_feature_group.describe()
```
```
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 utilizzi l' SageMaker intelligenza artificiale AWS SDK per Python (Boto3), usa la chiamata `ingest` API. 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' SageMaker AI SDK for 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)
```
```
customers_feature_group.ingest(
data_frame=customer_data, max_workers=3, wait=True
)
```
```
orders_feature_group.ingest(
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.
```
customers_feature_group.delete()
orders_feature_group.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 del 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()
```