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à.
# Acquisizione di dati da endpoint in tempo reale
**Nota**
Per prevenire l'impatto sulle richieste di inferenza, Acquisizione dei dati interrompe l'acquisizione delle richieste a livelli elevati di utilizzo del disco. Si consiglia di mantenere l'utilizzo del disco al di sotto del 75% per garantire che l'acquisizione dei dati continui a ricevere le richieste.
Per acquisire dati per il tuo endpoint in tempo reale, devi implementare un modello utilizzando i servizi di hosting SageMaker AI. Ciò richiede la creazione di un modello di SageMaker intelligenza artificiale, la definizione di una configurazione degli endpoint e la creazione di un endpoint HTTPS.
I passaggi necessari per attivare l'acquisizione dei dati sono simili a prescindere dal fatto che si utilizzi Python SDK AWS SDK per Python (Boto) o SageMaker Python. Se utilizzi l' AWS SDK, definisci il [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dizionario, insieme ai campi obbligatori, all'interno del [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)metodo per attivare l'acquisizione dei dati. Se usi SageMaker Python SDK, importa la [DataCaptureConfig](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html#sagemaker.model_monitor.data_capture_config.DataCaptureConfig)classe e inizializza un'istanza da questa classe. Passa quindi questo oggetto al parametro `DataCaptureConfig` nel metodo `sagemaker.model.Model.deploy()`.
Per utilizzare i frammenti di codice precedenti, sostituisci il codice di esempio con *italicized placeholder text* le tue informazioni.
## Come abilitare l'acquisizione dei dati
Specifica una configurazione per l’acquisizione dei dati. Con questa configurazione puoi acquisire il payload di richiesta, il payload di risposta o entrambi. Il frammento di codice che segue dimostra come abilitare l'acquisizione dei dati utilizzando AWS SDK per Python (Boto) l'SDK Python AI SageMaker .
**Nota**
Non è necessario utilizzare il monitoraggio dei modelli per acquisire i payload di richiesta o risposta.
------
#### [ AWS SDK per Python (Boto) ]
Configura i dati che desideri acquisire con il [DataCaptureConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataCaptureConfig.html)dizionario quando crei un endpoint utilizzando il metodo. `CreateEndpointConfig` Imposta `EnableCapture` sul valore booleano True. Inoltre, fornisci i seguenti parametri obbligatori:
+ `EndpointConfigName`: il nome della configurazione di endpoint. Utilizzerai questo nome quando effettuerai una richiesta `CreateEndpoint`.
+ `ProductionVariants`: un elenco di modelli che si desidera ospitare su questo endpoint. Definisci un tipo di dati del dizionario per ogni modello.
+ `DataCaptureConfig`: tipo di dati del dizionario in cui si specifica un valore intero che corrisponde alla percentuale iniziale di dati da campionare (`InitialSamplingPercentage`), l'URI di Amazon S3 in cui si desidera archiviare i dati acquisiti e un elenco di opzioni di acquisizione (`CaptureOptions`). Specifica `Input` o `Output` per `CaptureMode` all'interno dell'elenco `CaptureOptions`.
Puoi facoltativamente specificare in che modo l' SageMaker IA deve codificare i dati acquisiti passando gli argomenti della coppia chiave-valore al dizionario. `CaptureContentTypeHeader`
```
# Create an endpoint config name.
endpoint_config_name = ''
# The name of the production variant.
variant_name = ''
# The name of the model that you want to host.
# This is the name that you specified when creating the model.
model_name = ''
instance_type = ''
#instance_type='ml.m5.xlarge' # Example
# Number of instances to launch initially.
initial_instance_count =
# Sampling percentage. Choose an integer value between 0 and 100
initial_sampling_percentage =
# The S3 URI containing the captured data
s3_capture_upload_path = 's3:///'
# Specify either Input, Output, or both
capture_modes = [ "Input", "Output" ]
#capture_mode = [ "Input"] # Example - If you want to capture input only
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": variant_name,
"ModelName": model_name,
"InstanceType": instance_type, # Specify the compute instance type.
"InitialInstanceCount": initial_instance_count # Number of instances to launch initially.
}
],
DataCaptureConfig= {
'EnableCapture': True, # Whether data should be captured or not.
'InitialSamplingPercentage' : initial_sampling_percentage,
'DestinationS3Uri': s3_capture_upload_path,
'CaptureOptions': [{"CaptureMode" : capture_mode} for capture_mode in capture_modes] # Example - Use list comprehension to capture both Input and Output
}
)
```
Per ulteriori informazioni su altre opzioni di configurazione degli endpoint, consulta l'[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API nella [Amazon SageMaker AI Service API Reference Guide](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html).
------
#### [ SageMaker Python SDK ]
Importa la classe `DataCaptureConfig` dal modulo [sagemaker.model\$1monitor](https://sagemaker.readthedocs.io/en/stable/api/inference/model_monitor.html). Abilita l'acquisizione dei dati impostando `EnableCapture` sul valore booleano `True`.
Fornisci facoltativamente argomenti per i seguenti parametri:
+ `SamplingPercentage`: un valore intero che corrisponde alla percentuale di dati da campionare. Se non fornisci una percentuale di campionamento, l' SageMaker IA campionerà per impostazione predefinita il 20 (20%) dei tuoi dati.
+ `DestinationS3Uri`: l'URI di Amazon S3 che l' SageMaker IA utilizzerà per archiviare i dati acquisiti. Se non ne fornisci uno, l' SageMaker IA memorizzerà i dati acquisiti in`"s3:/// model-monitor/data-capture"`.
```
from sagemaker.model_monitor import DataCaptureConfig
# Set to True to enable data capture
enable_capture = True
# Optional - Sampling percentage. Choose an integer value between 0 and 100
sampling_percentage =
# sampling_percentage = 30 # Example 30%
# Optional - The S3 URI of stored captured-data location
s3_capture_upload_path = 's3:///'
# Specify either Input, Output or both.
capture_modes = ['REQUEST','RESPONSE'] # In this example, we specify both
# capture_mode = ['REQUEST'] # Example - If you want to only capture input.
# Configuration object passed in when deploying Models to SM endpoints
data_capture_config = DataCaptureConfig(
enable_capture = enable_capture,
sampling_percentage = sampling_percentage, # Optional
destination_s3_uri = s3_capture_upload_path, # Optional
capture_options = ["REQUEST", "RESPONSE"],
)
```
------
## Distribuzione del modello
Distribuisci il tuo modello e crea un endpoint HTTPS con abilitato `DataCapture`.
------
#### [ AWS SDK per Python (Boto3) ]
Fornisci la configurazione degli endpoint all' SageMaker IA. Il servizio avvia le istanze di calcolo ML e distribuisce il modello o i modelli come specificato nella configurazione.
Una volta completata la configurazione del modello e dell'endpoint, utilizza l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)per creare l'endpoint. Il nome dell'endpoint deve essere univoco all'interno di una AWS regione del tuo AWS account.
L’esempio seguente crea un endpoint utilizzando la configurazione endpoint specificata nella richiesta. Amazon SageMaker AI utilizza l'endpoint per fornire risorse e distribuire modelli.
```
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name = ''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
```
Per ulteriori informazioni, consulta l'API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html).
------
#### [ SageMaker Python SDK ]
Definisci un nome per l'endpoint. Questa fase è facoltativa. Se non ne fornisci uno, SageMaker AI creerà un nome univoco per te:
```
from datetime import datetime
endpoint_name = f"DEMO-{datetime.utcnow():%Y-%m-%d-%H%M}"
print("EndpointName =", endpoint_name)
```
Distribuisci il modello su un endpoint HTTPS in tempo reale con il metodo integrato dell'oggetto `deploy()`. Fornisci il nome del tipo di istanza Amazon EC2 su cui distribuire questo modello nel campo `instance_type` insieme al numero iniziale di istanze su cui eseguire l'endpoint per il campo `initial_instance_count`:
```
initial_instance_count=
# initial_instance_count=1 # Example
instance_type=''
# instance_type='ml.m4.xlarge' # Example
# Uncomment if you did not define this variable in the previous step
#data_capture_config =
model.deploy(
initial_instance_count=initial_instance_count,
instance_type=instance_type,
endpoint_name=endpoint_name,
data_capture_config=data_capture_config
)
```
------
## Visualizzare i dati acquisiti
Crea un oggetto predittore dalla classe SageMaker Python [SDK](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html) Predictor. Utilizzerai l'oggetto restituito dalla classe `Predictor` per richiamare il tuo endpoint in una fase futura. Fornisci il nome del tuo endpoint (definito in precedenza come `endpoint_name`), insieme agli oggetti serializzatore e deserializzatore rispettivamente per il serializzatore e il deserializzatore. [Per informazioni sui tipi di serializzatori, consulta la classe [Serializers](https://sagemaker.readthedocs.io/en/stable/api/inference/serializers.html) nell'SDK AI SageMaker Python.](https://sagemaker.readthedocs.io/en/stable/index.html)
```
from sagemaker.predictor import Predictor
from sagemaker.serializers import
from sagemaker.deserializers import
predictor = Predictor(endpoint_name=endpoint_name,
serializer = ,
deserializer = )
# Example
#from sagemaker.predictor import Predictor
#from sagemaker.serializers import CSVSerializer
#from sagemaker.deserializers import JSONDeserializer
#predictor = Predictor(endpoint_name=endpoint_name,
# serializer=CSVSerializer(),
# deserializer=JSONDeserializer())
```
Nel seguente scenario di esempio di codice, richiamiamo l'endpoint con dati di convalida di esempio che abbiamo archiviato in locale in un file CSV denominato `validation_with_predictions`. Il nostro set di convalida di esempio contiene etichette per ogni input.
Le prime righe delle istruzioni aprono innanzitutto il file CSV del set di convalida, quindi dividono ogni riga all'interno del file in base alla virgola `","` e quindi memorizzano i due oggetti restituiti in un’etichetta e variabili input\$1cols. Per ogni riga, l'input (`input_cols`) viene passato al metodo integrato degli oggetti (`predictor`) della variabile predittore `Predictor.predict()`.
Supponiamo che il modello restituisca una probabilità. Le probabilità sono comprese tra i valori interi 0 e 1,0. Se la probabilità restituita dal modello è maggiore dell'80% (0,8), assegniamo alla previsione un'etichetta di valore intero pari a 1. Altrimenti, assegniamo alla previsione un'etichetta di valore intero pari a 0.
```
from time import sleep
validate_dataset = "validation_with_predictions.csv"
# Cut off threshold of 80%
cutoff = 0.8
limit = 200 # Need at least 200 samples to compute standard deviations
i = 0
with open(f"test_data/{validate_dataset}", "w") as validation_file:
validation_file.write("probability,prediction,label\n") # CSV header
with open("test_data/validation.csv", "r") as f:
for row in f:
(label, input_cols) = row.split(",", 1)
probability = float(predictor.predict(input_cols))
prediction = "1" if probability > cutoff else "0"
baseline_file.write(f"{probability},{prediction},{label}\n")
i += 1
if i > limit:
break
print(".", end="", flush=True)
sleep(0.5)
print()
print("Done!")
```
Poiché nelle fasi precedenti è stata abilitata l'acquisizione dei dati, i payload della richiesta e della risposta, insieme ad alcuni metadati aggiuntivi, vengono salvati nel percorso Amazon S3 specificato in `DataCaptureConfig`. La consegna dei dati di acquisizione ad Amazon S3 può richiedere qualche minuto.
Visualizzazione dei dati acquisiti tramite elenco dei file di acquisizione dei dati archiviati in Amazon S3. Il formato del percorso Amazon S3 è: `s3:///{endpoint-name}/{variant-name}/yyyy/mm/dd/hh/filename.jsonl`.
Potrai visualizzare file differenti relativi a periodi diversi, organizzati in base all'ora in cui sono stati richiamati. Esegui quanto segue per stampare il contenuto di un singolo file di acquisizione:
```
print("\n".join(capture_file[-3:-1]))
```
Ciò restituirà un file in formato JSON-Line specifico per l'IA SageMaker . Di seguito è riportato un esempio di risposta tratto da un endpoint in tempo reale che abbiamo richiamato utilizzando i dati `csv/text`:
```
{"captureData":{"endpointInput":{"observedContentType":"text/csv","mode":"INPUT",
"data":"69,0,153.7,109,194.0,105,256.1,114,14.1,6,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0\n",
"encoding":"CSV"},"endpointOutput":{"observedContentType":"text/csv; charset=utf-8","mode":"OUTPUT","data":"0.0254181120544672","encoding":"CSV"}},
"eventMetadata":{"eventId":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","inferenceTime":"2022-02-14T17:25:49Z"},"eventVersion":"0"}
{"captureData":{"endpointInput":{"observedContentType":"text/csv","mode":"INPUT",
"data":"94,23,197.1,125,214.5,136,282.2,103,9.5,5,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1\n",
"encoding":"CSV"},"endpointOutput":{"observedContentType":"text/csv; charset=utf-8","mode":"OUTPUT","data":"0.07675473392009735","encoding":"CSV"}},
"eventMetadata":{"eventId":"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee","inferenceTime":"2022-02-14T17:25:49Z"},"eventVersion":"0"}
```
Nell'esempio precedente, l'oggetto `capture_file` è un tipo di elenco. Indicizza il primo elemento dell'elenco per visualizzare una singola richiesta di inferenza.
```
# The capture_file object is a list. Index the first element to view a single inference request
print(json.dumps(json.loads(capture_file[0]), indent=2))
```
Ciò restituisce una risposta simile alla seguente. I valori restituiti differiranno in base alla configurazione dell'endpoint, al modello di intelligenza artificiale e SageMaker ai dati acquisiti:
```
{
"captureData": {
"endpointInput": {
"observedContentType": "text/csv", # data MIME type
"mode": "INPUT",
"data": "50,0,188.9,94,203.9,104,151.8,124,11.6,8,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,0\n",
"encoding": "CSV"
},
"endpointOutput": {
"observedContentType": "text/csv; charset=character-encoding",
"mode": "OUTPUT",
"data": "0.023190177977085114",
"encoding": "CSV"
}
},
"eventMetadata": {
"eventId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
"inferenceTime": "2022-02-14T17:25:06Z"
},
"eventVersion": "0"
}
```