As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Introdução ao caderno de exemplo do Feature Store
**Importante**
Políticas personalizadas do IAM que permitem que o Amazon SageMaker SageMaker Studio ou o Amazon Studio Classic criem SageMaker recursos da Amazon também devem conceder permissões para adicionar tags a esses recursos. A permissão para adicionar tags aos recursos é necessária porque o Studio e o Studio Classic marcam automaticamente todos os recursos que eles criam. Se uma política do IAM permitir que o Studio e o Studio Classic criem recursos, mas não permitisse a marcação, erros AccessDenied "" podem ocorrer ao tentar criar recursos. Para obter mais informações, consulte [Forneça permissões para marcar recursos de SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS políticas gerenciadas para Amazon SageMaker AI](security-iam-awsmanpol.md)que dão permissões para criar SageMaker recursos já incluem permissões para adicionar tags ao criar esses recursos.
O código de exemplo nesta página se refere ao caderno de exemplo [Introdução à Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/feature_store_introduction.html). Recomendamos que você execute esse notebook no Studio Classic, em instâncias de notebook ou JupyterLab porque o código neste guia é conceitual e não é totalmente funcional se copiado.
Use o seguinte para clonar o amazon-sagemaker-examples GitHub repositório [aws/](https://github.com/aws/amazon-sagemaker-examples), contendo o notebook de exemplo:
+ **Para Studio Classic**
Execute o Studio Classic. Você pode abrir o Studio Classic se o Studio ou o Studio Classic estiverem habilitados como sua experiência padrão. Para obter instruções sobre como abrir o Studio Classic, consulte [Inicie o Amazon SageMaker Studio Classic usando o Amazon SageMaker AI Console](studio-launch.md#studio-launch-console).
Clone o amazon-sagemaker-examples GitHub repositório [aws/](https://github.com/aws/amazon-sagemaker-examples) no Studio Classic seguindo as etapas em. [Clone um repositório Git no SageMaker Amazon Studio Classic](studio-tasks-git.md)
+ **Para instâncias de SageMaker notebooks da Amazon**
Execute a instância do SageMaker notebook seguindo as instruções em[Acessar instâncias de caderno](howitworks-access-ws.md).
Agora que você tem os cadernos de exemplo de SageMaker IA, navegue até o `amazon-sagemaker-examples/sagemaker-featurestore` diretório e abra o caderno de exemplo de [Introdução ao Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/feature_store_introduction.html).
## Etapa 1: configurar sua sessão de SageMaker IA
Para começar a usar a Feature Store, crie uma sessão de SageMaker IA. Em seguida, configure o bucket do Amazon Simple Storage Service (Amazon S3) que deseja usar para seus atributos. O bucket do Amazon S3 é seu armazenamento offline. O código a seguir usa o bucket padrão do SageMaker AI e adiciona um prefixo personalizado a ele.
**nota**
A função que você usa para executar esse caderno deve ter as seguintes políticas gerenciadas anexadas: `AmazonS3FullAccess` e `AmazonSageMakerFeatureStoreAccess`. Para obter informações sobre como adicionar políticas ao seu perfil do IAM, consulte [Adicionar políticas ao seu perfil do 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()
```
## Etapa 2: inspecionar seus dados
Neste exemplo de notebook, ingerimos dados sintéticos do [GitHub repositório](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-featurestore/data) que hospeda o notebook completo.
```
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())
```
O diagrama a seguir ilustra as etapas pelas quais os dados passam antes de serem ingeridos no Feature Store. Neste caderno, ilustramos o caso de uso em que você tem dados de várias fontes e deseja armazená-los de forma independente em um Feature Store. Nosso exemplo considera dados de um data warehouse (dados do cliente) e dados de um serviço de streaming em tempo real (dados do pedido).
![\[Criação de grupos de atributos e ingestão de dados no Feature Store para o caderno de exemplo.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/feature-store/feature-store-intro-diagram.png)
## Etapa 3: criar grupos de atributos
Primeiro, começamos criando nomes de grupos de atributos para customer\$1data e orders\$1data. Depois disso, criamos dois grupos de atributos, um para `customer_data` e outro para `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())
```
Instancie um objeto `FeatureGroup` para `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"
```
Anexe um atributo `EventTime` ao seu quadro de dados. Esse parâmetro é obrigatório e marca a data e hora de cada ponto de dados.
```
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")
```
Carregue as definições dos atributos em seu grupo de atributos.
```
customers_feature_group.load_feature_definitions(data_frame=customer_data)
orders_feature_group.load_feature_definitions(data_frame=orders_data)
```
Abaixo, chamamos `create` para criar dois grupos de atributos, `customers_feature_group` e `orders_feature_group`, respectivamente:
```
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
)
```
Para confirmar que seu grupo de recursos foi criado, nós o exibimos usando `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
```
## Etapa 4: ingerir dados em um grupo de atributos
Depois que os grupos de atributos forem criados, podemos colocar dados neles. Se você estiver usando a SageMaker IA AWS SDK para Python (Boto3), use a chamada `ingest` da API. Se você estiver usando o SDK para Python (Boto3), use a API `PutRecord`. Levará menos de 1 minuto para ingerir dados em ambas as opções. Este exemplo usa o SDK de SageMaker IA para Python (Boto3), então ele usa a chamada de 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
)
```
Usando um ID de registro de cliente arbitrário, 573291, usamos `get_record` para verificar se os dados foram ingeridos no grupo de atributos.
```
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)
```
A seguir consta uma demonstração de como usar o `batch_get_record` para obter um lote de registros.
```
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)
```
## Etapa 5: limpar
Aqui, removemos os grupos de atributos que criamos.
```
customers_feature_group.delete()
orders_feature_group.delete()
```
## Etapa 6: próximas etapas
Neste caderno de exemplo, você aprendeu como começar rapidamente com o Feature Store, criar grupos de atributos e ingerir dados neles.
Para obter um exemplo avançado de como usar o Feature Store para um caso de uso de detecção de fraudes, consulte [Detecção de fraudes com o Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/sagemaker_featurestore_fraud_detection_python_sdk.html).
## Etapa 7: exemplos de código para programadores
Neste caderno, usamos uma variedade de chamadas de API diferentes. A maioria deles é acessível por meio do SDK do SageMaker Python, mas alguns só existem no Boto3. Você pode invocar as chamadas da API do SDK do SageMaker Python diretamente nos objetos da Feature Store, enquanto para invocar as chamadas de API que existem no Boto3, você deve primeiro acessar um cliente do Boto3 por meio de suas sessões de Boto3 e IA: por exemplo,. SageMaker `sagemaker_session.boto_session.client()`
Veja a seguir uma lista de chamadas de API para esse caderno. Essas chamadas existem dentro do SDK for Python e existem no Boto3, para sua referência:
**Chamadas de API do SDK para Python (Boto3)**
```
describe()
ingest()
delete()
create()
load_feature_definitions()
```
**Chamadas da API do Boto3**
```
list_feature_groups()
get_record()
```