`, una [notifica Amazon S3 richiama la funzione Lambda](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html). `data-ingestion-processor`
1. La funzione Lambda si `data-ingestion-processor` basa su un'immagine Docker memorizzata nel repository Amazon Elastic Container Registry (Amazon ECR). `bedrock-rag-template`
[La funzione utilizza [LangChain S3 FileLoader](https://python.langchain.com/v0.1/docs/integrations/document_loaders/aws_s3_file/) per leggere il file come documento. LangChain ](https://api.python.langchain.com/en/v0.0.339/schema/langchain.schema.document.Document.html) Quindi, i [LangChain RecursiveCharacterTextSplitter](https://python.langchain.com/v0.1/docs/modules/data_connection/document_transformers/recursive_text_splitter/)blocchi di ogni documento, con una `CHUNK_SIZE` e una `CHUNK_OVERLAP` che dipendono dalla dimensione massima del token del modello di incorporamento Amazon Titan Text Embedding V2. Successivamente, la funzione Lambda richiama il modello di incorporamento su Amazon Bedrock per incorporare i blocchi in rappresentazioni vettoriali numeriche. Infine, questi vettori sono archiviati nel database Aurora PostgreSQL. Per accedere al database, la funzione Lambda recupera innanzitutto il nome utente e la password da. Gestione dei segreti AWS
1. Sull'[istanza del notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html) Amazon SageMaker AI`aws-sample-bedrock-rag-template`, l'utente può scrivere un prompt di domande. Il codice richiama Claude 3 su Amazon Bedrock e aggiunge le informazioni della knowledge base al contesto del prompt. Di conseguenza, Claude 3 fornisce risposte utilizzando le informazioni contenute nei documenti.
L'approccio di questo modello alla rete e alla sicurezza è il seguente:
+ La funzione Lambda `data-ingestion-processor` si trova in una sottorete privata all'interno del cloud privato virtuale (VPC). La funzione Lambda non è autorizzata a inviare traffico alla rete Internet pubblica a causa del suo gruppo di sicurezza. Di conseguenza, il traffico verso Amazon S3 e Amazon Bedrock viene instradato solo attraverso gli endpoint VPC. Di conseguenza, il traffico non attraversa la rete Internet pubblica, il che riduce la latenza e aggiunge un ulteriore livello di sicurezza a livello di rete.
+ Tutte le risorse e i dati vengono crittografati laddove applicabile utilizzando la chiave AWS Key Management Service (AWS KMS) con l'alias. `aws-sample/bedrock-rag-template`
**Automazione e scalabilità**
Questo modello utilizza Terraform per distribuire l'infrastruttura dal repository di codice in un. Account AWS
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Aurora PostgreSQL Compatible Edition è un motore](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html) di database relazionale completamente gestito e conforme ad ACID che ti aiuta a configurare, gestire e scalare le distribuzioni PostgreSQL. In questo modello, Aurora PostgreSQL Compatible utilizza il plugin pgvector come database vettoriale.
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) è un servizio completamente gestito che rende disponibili per l'uso modelli di base ad alte prestazioni (FMs) delle principali startup di intelligenza artificiale e di Amazon tramite un'API unificata.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che ti aiuta a interagire Servizi AWS tramite comandi nella shell della riga di comando.
+ [Amazon Elastic Container Registry (Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile. In questo modello, Amazon ECR ospita l'immagine Docker per la funzione Lambda`data-ingestion-processor`.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) ti aiuta a creare e controllare chiavi crittografiche per proteggere i tuoi dati.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di elaborazione che utilizzi. In questo modello, Lambda inserisce i dati nell'archivio vettoriale.
+ [Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/?id=docs_gateway) è un servizio di machine learning (ML) gestito che ti aiuta a creare e addestrare modelli di machine learning per poi distribuirli in un ambiente ospitato pronto per la produzione.
+ Con [Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) puoi sostituire le credenziali nel codice,incluse le password, con una chiamata API a Secrets Manager in modo da recuperare il segreto a livello di codice.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
+ [Amazon Virtual Private Cloud (Amazon VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ti aiuta a lanciare AWS risorse in una rete virtuale che hai definito. Questa rete virtuale è simile a una comune rete da gestire all'interno del proprio data center, ma con i vantaggi dell'infrastruttura scalabile di AWS. Il VPC include sottoreti e tabelle di routing per controllare il flusso di traffico.
**Altri strumenti**
+ [Docker](https://docs.docker.com/manuals/) è un insieme di prodotti Platform as a Service (PaaS) che utilizzano la virtualizzazione a livello di sistema operativo per fornire software in container.
+ [HashiCorp Terraform](https://www.terraform.io/docs) è uno strumento Infrastructure as Code (IaC) che consente di utilizzare il codice per fornire e gestire l'infrastruttura e le risorse cloud.
+ [Poetry](https://pypi.org/project/poetry/) è uno strumento per la gestione delle dipendenze e la creazione di pacchetti in Python.
+ [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico.
**Archivio di codice**
Il codice per questo pattern è disponibile nel repository GitHub [terraform-rag-template-using-amazon-bedrock](https://github.com/aws-samples/terraform-rag-template-using-amazon-bedrock).
## Best practice
+ Sebbene questo esempio di codice possa essere distribuito in qualsiasi ambiente Regione AWS, ti consigliamo di utilizzare Stati Uniti orientali (Virginia settentrionale) `us-east-1` o Stati Uniti occidentali (California settentrionale). `us-west-1` Questa raccomandazione si basa sulla disponibilità di modelli di base e di incorporamento in Amazon Bedrock al momento della pubblicazione di questo modello. Per un up-to-date elenco dei modelli Amazon Bedrock Foundation supportati in Regioni AWS, consulta [Model support by Regione AWS](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) nella documentazione di Amazon Bedrock. [Per informazioni sulla distribuzione di questo esempio di codice in altre regioni, consulta Informazioni aggiuntive.](#deploy-rag-use-case-on-aws-additional)
+ Questo modello fornisce solo una demo proof-of-concept (PoC) o pilota. Se vuoi portare il codice in produzione, assicurati di utilizzare le seguenti best practice:
+ Abilita la registrazione degli accessi al server per Amazon S3.
+ Imposta il [monitoraggio e gli avvisi](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html) per la funzione Lambda.
+ Se il tuo caso d'uso richiede un'API, prendi in considerazione l'aggiunta di Amazon API Gateway con una funzione Lambda che esegue attività di recupero e risposta alle domande.
+ Segui il principio del privilegio minimo e concedi le autorizzazioni minime necessarie per eseguire un'attività. Per ulteriori informazioni, consulta le [best practice relative alla [concessione dei privilegi minimi](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) e alla sicurezza nella documentazione](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPracticesAndUseCases.html) IAM.
## Epiche
### Implementa la soluzione in un Account AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare il repository. | Per clonare il GitHub repository fornito con questo pattern, utilizzate il seguente comando:git clone https://github.com/aws-samples/terraform-rag-template-using-amazon-bedrock
| AWS DevOps |
| Configura le variabili. | Per configurare i parametri per questo pattern, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html) | AWS DevOps |
| Distribuire la soluzione. | Per distribuire la soluzione, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html)L'implementazione dell'infrastruttura fornisce un'istanza SageMaker AI all'interno del VPC e con le autorizzazioni per accedere al database Aurora PostgreSQL. | AWS DevOps |
### Test della soluzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esegui la demo. | Una volta completata la precedente installazione dell'infrastruttura, segui i seguenti passaggi per eseguire la demo su un notebook Jupyter:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html)Il notebook Jupyter ti guida attraverso il seguente processo:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-rag-use-case-on-aws.html) | Informazioni generali su AWS |
### Pulisci l'infrastruttura
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Pulisci l'infrastruttura. | Per rimuovere tutte le risorse che hai creato quando non sono più necessarie, usa il seguente comando:terraform destroy -var-file=commons.tfvars
| AWS DevOps |
## Risorse correlate
**AWS resources**
+ [Creazione di funzioni Lambda con Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Parametri di inferenza per i modelli di base](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Accesso ai modelli Amazon Bedrock Foundation](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Il ruolo dei database vettoriali nelle applicazioni di intelligenza artificiale generativa](https://aws.amazon.com/blogs/database/the-role-of-vector-datastores-in-generative-ai-applications/) (AWS Database Blog)
+ [Lavorare con Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html)
**Altre risorse**
+ [documentazione pgvector](https://github.com/pgvector/pgvector)
## Informazioni aggiuntive
**Implementazione di un database vettoriale**
Questo modello utilizza la compatibilità con Aurora PostgreSQL per implementare un database vettoriale per RAG. In alternativa ad Aurora PostgreSQL, AWS offre altre funzionalità e servizi per RAG, come Amazon Bedrock Knowledge Bases e Amazon Service. OpenSearch Puoi scegliere la soluzione più adatta alle tue esigenze specifiche:
+ [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html) fornisce motori di ricerca e analisi distribuiti che puoi utilizzare per archiviare e interrogare grandi volumi di dati.
+ [Amazon Bedrock Knowledge Bases](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html) è progettato per creare e distribuire basi di conoscenza come astrazione aggiuntiva per semplificare il processo di acquisizione e recupero di RAG. Le Knowledge Base di Amazon Bedrock possono funzionare sia con Aurora PostgreSQL che con Amazon Service. OpenSearch
**Distribuzione su altri Regioni AWS**
Come descritto in [Architettura](#deploy-rag-use-case-on-aws-architecture), si consiglia di utilizzare la regione Stati Uniti orientali (Virginia settentrionale) `us-east-1` o Stati Uniti occidentali (California settentrionale) `us-west-1` per distribuire questo esempio di codice. Tuttavia, esistono due modi possibili per distribuire questo esempio di codice in regioni diverse da and. `us-east-1` `us-west-1` È possibile configurare la regione di distribuzione nel `commons.tfvars` file. Per l'accesso al modello di base interregionale, considera le seguenti opzioni:
+ **Attraversamento della rete Internet pubblica**: se il traffico può attraversare la rete Internet pubblica, aggiungi gateway Internet al VPC. Quindi, modifica il gruppo di sicurezza assegnato alla funzione Lambda `data-ingestion-processor` e all'istanza del notebook SageMaker AI per consentire il traffico in uscita verso la rete Internet pubblica.
+ **Non utilizzare la rete Internet pubblica**: per distribuire questo esempio in una regione diversa da `us-east-1` o`us-west-1`, procedi come segue:
1. Nella `us-west-1` regione `us-east-1` o, crea un VPC aggiuntivo che includa un endpoint VPC per. `bedrock-runtime`
1. Crea una connessione peering utilizzando il peering [VPC](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html) o [un gateway di transito](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-peering.html) verso il VPC dell'applicazione.
1. Quando configuri il client `bedrock-runtime` boto3 in qualsiasi funzione Lambda al di fuori di `us-east-1` o`us-west-1`, passa il nome DNS privato dell'endpoint VPC per `bedrock-runtime` in `us-east-1` o us-west-1 come nome al client boto3. `endpoint_url`
# Implementa la logica di preelaborazione in un modello ML in un singolo endpoint utilizzando una pipeline di inferenza in Amazon SageMaker
*Mohan Gowda Purushothama, Gabriel Rodriguez Garcia e Mateusz Zaremba, Amazon Web Services*
## Riepilogo
Questo modello spiega come distribuire più oggetti del modello di pipeline in un singolo endpoint utilizzando una [pipeline di inferenza](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) in Amazon. SageMaker L'oggetto del modello di pipeline rappresenta diverse fasi del flusso di lavoro di machine learning (ML), come la preelaborazione, l'inferenza del modello e la postelaborazione. [Per illustrare la distribuzione di oggetti del modello di pipeline connessi in serie, questo modello mostra come implementare un contenitore [Scikit-learn](https://docs.aws.amazon.com/sagemaker/latest/dg/sklearn.html) di preelaborazione e un modello di regressione basato sull'algoritmo di apprendimento lineare integrato.](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) SageMaker L'implementazione SageMaker è ospitata dietro un singolo endpoint in.
**Nota**
La distribuzione in questo modello utilizza il tipo di istanza ml.m4.2xlarge. Ti consigliamo di utilizzare un tipo di istanza in linea con i requisiti di dimensione dei dati e la complessità del flusso di lavoro. Per ulteriori informazioni, consulta la pagina [ SageMaker dei prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/). Questo modello utilizza [immagini Docker predefinite per Scikit-learn](https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-docker-containers-scikit-learn-spark.html), ma puoi usare i tuoi contenitori Docker e integrarli nel tuo flusso di lavoro.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo
+ [Python 3.9](https://www.python.org/downloads/release/python-390/)
+ [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/) [e libreria Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
+ [Ruolo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) [AWS Identity and Access Management (AWS IAM) con SageMaker [autorizzazioni di base e autorizzazioni](https://docs.aws.amazon.com/sagemaker/latest/dg/api-permissions-reference.html) Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-policy-language-overview.html)
**Versioni del prodotto**
+ [SDK Amazon SageMaker Python 2.49.2](https://sagemaker.readthedocs.io/en/v2.49.2/)
## Architecture
**Stack tecnologico Target**
+ Amazon Elastic Container Registry (Amazon ECR)
+ Amazon SageMaker
+ Amazon SageMaker Studio
+ Amazon Simple Storage Service (Amazon S3)
+ Endpoint di [inferenza in tempo reale](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) per Amazon SageMaker
**Architettura Target**
Il diagramma seguente mostra l'architettura per la distribuzione di un oggetto del modello Amazon SageMaker Pipeline.
![\[Architettura per la distribuzione di oggetti del modello di SageMaker pipeline\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/1105d51b-752f-46d7-962c-acef1fb3399f/images/12f06715-b1c2-4de0-b277-99ce87308152.png)
Il diagramma mostra il flusso di lavoro seguente:
1. Un SageMaker notebook implementa un modello di pipeline.
1. Un bucket S3 memorizza gli artefatti del modello.
1. Amazon ECR ottiene le immagini del contenitore di origine dal bucket S3.
## Tools (Strumenti)
**Strumenti AWS**
+ [Amazon Elastic Container Registry (Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile.
+ [Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) è un servizio di machine learning gestito che ti aiuta a creare e addestrare modelli di machine learning per poi distribuirli in un ambiente ospitato pronto per la produzione.
+ [Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) è un ambiente di sviluppo integrato (IDE) basato sul Web per il machine learning che ti consente di creare, addestrare, eseguire il debug, distribuire e monitorare i tuoi modelli di machine learning.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
**Codice**
Il codice per questo pattern è disponibile nel repository GitHub [Inference Pipeline con Scikit-learn e Linear Learner](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-python-sdk/scikit_learn_inference_pipeline/Inference%20Pipeline%20with%20Scikit-learn%20and%20Linear%20Learner.ipynb).
## Epiche
### Prepara il set di dati
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Prepara il set di dati per l'attività di regressione. | [Apri un notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-create-open.html#notebooks-open) in Amazon SageMaker Studio.Per importare tutte le librerie necessarie e inizializzare l'ambiente di lavoro, usa il seguente codice di esempio nel tuo notebook:import sagemaker
from sagemaker import get_execution_role
sagemaker_session = sagemaker.Session()
# Get a SageMaker-compatible role used by this Notebook Instance.
role = get_execution_role()
# S3 prefix
bucket = sagemaker_session.default_bucket()
prefix = "Scikit-LinearLearner-pipeline-abalone-example"
Per scaricare un set di dati di esempio, aggiungi il seguente codice al tuo taccuino:! mkdir abalone_data
! aws s3 cp s3://sagemaker-sample-files/datasets/tabular/uci_abalone/abalone.csv ./abalone_data
****L'esempio in questo modello utilizza l'[Abalone Data Set](https://archive.ics.uci.edu/ml/datasets/abalone) dell'UCI Machine Learning Repository. | Data Scientist |
| Carica il set di dati in un bucket S3. | Nel taccuino in cui hai preparato il set di dati in precedenza, aggiungi il codice seguente per caricare i dati di esempio in un bucket S3:WORK_DIRECTORY = "abalone_data"
train_input = sagemaker_session.upload_data(
path="{}/{}".format(WORK_DIRECTORY, "abalone.csv"),
bucket=bucket,
key_prefix="{}/{}".format(prefix, "train"),
)
| Data Scientist |
### Crea il preprocessore di dati utilizzando SKLearn
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Preparare lo script preprocessor.py. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-preprocessing-logic-into-an-ml-model-in-a-single-endpoint-using-an-inference-pipeline-in-amazon-sagemaker.html) | Data Scientist |
| Create l'oggetto SKLearn del preprocessore. | Per creare un oggetto SKLearn preprocessore (chiamato SKLearn Estimator) da incorporare nella pipeline di inferenza finale, esegui il codice seguente nel tuo taccuino: SageMaker from sagemaker.sklearn.estimator import SKLearn
FRAMEWORK_VERSION = "0.23-1"
script_path = "sklearn_abalone_featurizer.py"
sklearn_preprocessor = SKLearn(
entry_point=script_path,
role=role,
framework_version=FRAMEWORK_VERSION,
instance_type="ml.c4.xlarge",
sagemaker_session=sagemaker_session,
)
sklearn_preprocessor.fit({"train": train_input})
| Data Scientist |
| Verifica l'inferenza del preprocessore. | Per confermare che il preprocessore sia definito correttamente, avviate un [processo di trasformazione in batch](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html) inserendo il seguente codice nel notebook: SageMaker # Define a SKLearn Transformer from the trained SKLearn Estimator
transformer = sklearn_preprocessor.transformer(
instance_count=1, instance_type="ml.m5.xlarge", assemble_with="Line", accept="text/csv"
)
# Preprocess training input
transformer.transform(train_input, content_type="text/csv")
print("Waiting for transform job: " + transformer.latest_transform_job.job_name)
transformer.wait()
preprocessed_train = transformer.output_path
| |
### Crea un modello di apprendimento automatico
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un oggetto modello. | Per creare un oggetto modello basato sull'algoritmo Linear Learner, inserisci il seguente codice nel tuo SageMaker taccuino:import boto3
from sagemaker.image_uris import retrieve
ll_image = retrieve("linear-learner", boto3.Session().region_name)
s3_ll_output_key_prefix = "ll_training_output"
s3_ll_output_location = "s3://{}/{}/{}/{}".format(
bucket, prefix, s3_ll_output_key_prefix, "ll_model"
)
ll_estimator = sagemaker.estimator.Estimator(
ll_image,
role,
instance_count=1,
instance_type="ml.m4.2xlarge",
volume_size=20,
max_run=3600,
input_mode="File",
output_path=s3_ll_output_location,
sagemaker_session=sagemaker_session,
)
ll_estimator.set_hyperparameters(feature_dim=10, predictor_type="regressor", mini_batch_size=32)
ll_train_data = sagemaker.inputs.TrainingInput(
preprocessed_train,
distribution="FullyReplicated",
content_type="text/csv",
s3_data_type="S3Prefix",
)
data_channels = {"train": ll_train_data}
ll_estimator.fit(inputs=data_channels, logs=True)
Il codice precedente recupera l'immagine Docker Amazon ECR pertinente dal registro Amazon ECR pubblico per il modello, crea un oggetto estimatore e quindi utilizza quell'oggetto per addestrare il modello di regressione. | Data Scientist |
### Implementa la pipeline finale
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Implementa il modello di pipeline. | Per creare un oggetto del modello di pipeline (ovvero un oggetto preprocessore) e distribuire l'oggetto, inserite il codice seguente nel vostro taccuino: SageMaker from sagemaker.model import Model
from sagemaker.pipeline import PipelineModel
import boto3
from time import gmtime, strftime
timestamp_prefix = strftime("%Y-%m-%d-%H-%M-%S", gmtime())
scikit_learn_inferencee_model = sklearn_preprocessor.create_model()
linear_learner_model = ll_estimator.create_model()
model_name = "inference-pipeline-" + timestamp_prefix
endpoint_name = "inference-pipeline-ep-" + timestamp_prefix
sm_model = PipelineModel(
name=model_name, role=role, models= [scikit_learn_inferencee_model, linear_learner_model]
)
sm_model.deploy(initial_instance_count=1, instance_type="ml.c4.xlarge", endpoint_name=endpoint_name)
È possibile modificare il tipo di istanza utilizzato nell'oggetto del modello in base alle proprie esigenze. | Data Scientist |
| Verificate l'inferenza. | Per confermare che l'endpoint funzioni correttamente, esegui il seguente codice di inferenza di esempio sul tuo notebook: SageMaker from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer
payload = "M, 0.44, 0.365, 0.125, 0.516, 0.2155, 0.114, 0.155"
actual_rings = 10
predictor = Predictor(
endpoint_name=endpoint_name, sagemaker_session=sagemaker_session, serializer=CSVSerializer()
)
print(predictor.predict(payload))
| Data Scientist |
## Risorse correlate
+ [Preelabora i dati di input prima di fare previsioni utilizzando le pipeline di SageMaker inferenza di Amazon e Scikit-learn (AWS Machine](https://aws.amazon.com/blogs/machine-learning/preprocess-input-data-before-making-predictions-using-amazon-sagemaker-inference-pipelines-and-scikit-learn/) Learning Blog)
+ [Machine Learning end-to-end con Amazon SageMaker](https://github.com/aws-samples/amazon-sagemaker-build-train-deploy) (GitHub)
# Implementa la convalida della sicurezza della codifica in tempo reale utilizzando un server MCP con Kiro e altri assistenti di codifica
*Ivan Girardi e Iker Reina Fuente, Amazon Web Services*
## Riepilogo
Questo modello descrive come implementare un server Model Context Protocol (MCP) che integri tre strumenti di scansione di sicurezza standard del settore per fornire un'analisi completa della sicurezza del codice. Il server consente agli assistenti di codifica AI (come Kiro, Amazon Q Developer e Cline) di scansionare automaticamente frammenti di codice e configurazioni Infrastructure as Code (IaC). Con queste scansioni, gli assistenti di codifica possono aiutare a identificare vulnerabilità di sicurezza, configurazioni errate e violazioni della conformità.
I generatori di codice AI addestrati su milioni di frammenti di codice creano un punto cieco in materia di sicurezza: quanto erano sicuri i dati di addestramento? Questo modello fornisce una convalida della sicurezza in tempo reale durante la generazione del codice, aiutando gli sviluppatori a identificare e comprendere potenziali problemi di sicurezza durante la codifica. Questo approccio aiuta gli sviluppatori a risolvere sia le vulnerabilità dirette che i rischi ereditari derivanti dalle dipendenze. Colmando il divario tra efficienza dell'IA e conformità alla sicurezza, questo modello aiuta a consentire l'adozione sicura di strumenti di sviluppo basati sull'intelligenza artificiale.
Questo modello aiuta le organizzazioni a migliorare le proprie pratiche di sicurezza dello sviluppo attraverso strumenti di codifica assistiti dall'intelligenza artificiale, fornendo funzionalità di scansione di sicurezza continue su più linguaggi di programmazione e definizioni di infrastruttura. La soluzione combina le funzionalità dei seguenti strumenti:
+ Checkov per la scansione di file IAC, inclusi Terraform e Kubernetes AWS CloudFormation manifest
+ Semgrep per l'analisi di più linguaggi di programmazione come Python, JavaScript Java e altri
+ Bandit per la scansione di sicurezza specializzata in Python
Le caratteristiche principali di questa soluzione includono quanto segue:
+ Scansione delta di nuovi segmenti di codice, con riduzione del sovraccarico computazionale
+ Ambienti isolati per strumenti di sicurezza, che impediscono la contaminazione tra strumenti
+ Perfetta integrazione con gli assistenti di codifica AI (Kiro, Amazon Q Developer, Cline e altri)
+ Feedback sulla sicurezza in tempo reale durante la generazione del codice
+ Regole di scansione personalizzabili per la conformità organizzativa
Il modello fornisce un'interfaccia unificata per la scansione di sicurezza con formati di risposta standardizzati, che semplificano l'integrazione dei controlli di sicurezza nei flussi di lavoro di sviluppo. Il modello utilizza Python e il framework MCP per fornire feedback automatici sulla sicurezza. Questo approccio aiuta gli sviluppatori a identificare e risolvere i problemi di sicurezza nelle prime fasi del processo di sviluppo, apprendendo al contempo le migliori pratiche di sicurezza attraverso risultati dettagliati.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un programma attivo Account AWS con accesso all'utilizzo di Kiro o Amazon Q Developer, se desideri utilizzare uno di questi assistenti di codifica
+ [Python versione 3.10 o successiva installata](https://www.python.org/downloads/)
+ `uv`[gestore di pacchetti installato](https://docs.astral.sh/uv/getting-started/installation/)
+ Familiarità con gli strumenti e i concetti di scansione di sicurezza
+ Conoscenza di base di IaC e sicurezza delle applicazioni
**Limitazioni**
+ La scansione Bandit è limitata ai soli file Python.
+ La scansione in tempo reale potrebbe influire sulle prestazioni di basi di codice di grandi dimensioni.
+ Le limitazioni specifiche degli strumenti si basano sui formati di file e sui linguaggi supportati.
+ La revisione manuale è necessaria per convalidare i risultati di sicurezza.
+ I risultati della scansione di sicurezza richiedono competenze in materia di sicurezza per una corretta interpretazione.
+ Alcuni Servizi AWS non sono disponibili in tutti Regioni AWS. Per la disponibilità regionale, vedi [AWS Servizi per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
**Versioni del prodotto**
+ Python versione 3.10 o successiva
+ Checkov versione 3.0.0 o successiva
+ Semgrep versione 1.45.0 o successiva
+ Bandit versione 1.7.5 o successiva
+ MCP [cli] versione 1.11.0 o successiva
+ Pydantic versione 1.10.0 o successiva
+ Loguru versione 0.6.0 o successiva
## Architecture
Il diagramma seguente mostra l'architettura di questa soluzione.
![\[Gli assistenti AI inviano il codice al server dello scanner di sicurezza MCP per indirizzarlo a scanner specializzati; i risultati della scansione vengono inviati allo sviluppatore.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/fa623544-4d54-48af-a4e4-9b6a0624e776/images/9c881f95-76d0-40f6-983e-d987fd2097b8.png)
Il diagramma mostra il flusso di lavoro seguente:
1. Lo sviluppatore utilizza assistenti AI (ad esempio, Kiro, Cline, Amazon Q Developer o Roo Code) per generare o analizzare il codice. L'assistente AI invia il codice per la scansione di sicurezza.
1. Il server dello scanner di sicurezza MCP elabora la richiesta indirizzandola allo scanner specializzato appropriato: Checkov per i file IaC, Semgrep per l'analisi di più linguaggi di programmazione o Bandit per la scansione di sicurezza specifica di Python.
1. I risultati dello scanner con risultati di sicurezza, livelli di gravità, descrizioni dettagliate e correzioni suggerite vengono inviati allo sviluppatore tramite l'assistente AI.
1. Viene stabilito un ciclo di feedback continuo in cui lo sviluppatore riceve una convalida di sicurezza in tempo reale, abilita correzioni automatiche tramite assistenti AI e promuove le migliori pratiche di sicurezza durante lo sviluppo.
L'architettura mitiga i seguenti rischi comuni per la sicurezza:
+ Iniezione di comandi
+ Iniezione rapida
+ Attraversamento del percorso
+ Attacchi di dipendenza
+ Esaurimento delle risorse
L'architettura mitiga questi rischi comuni per la sicurezza implementando le seguenti best practice:
+ Tutti gli input dell'utente e del modello AI vengono scritti in file temporanei.
+ Non vengono forniti input diretti ai comandi dell'interfaccia a riga di comando (CLI).
+ L'accesso al file system è limitato solo alle directory e ai file temporanei.
+ I file temporanei vengono puliti automaticamente.
+ Le risposte di scansione vengono disinfettate.
+ Viene applicato l'isolamento del processo che limita le capacità del processo.
+ Tutte le attività di scansione vengono registrate.
**Automazione e scalabilità**
Il modello supporta l'automazione tramite le seguenti funzionalità:
+ Integrazione con assistenti di codifica AI per la scansione automatica del codice
+ Risposte API standardizzate per l'elaborazione automatizzata
+ Configurazione tramite file di configurazione MCP
+ Support per l'elaborazione in batch di più file
+ Scansione scalabile su più linguaggi di programmazione e formati IAc
Il processo di scansione può essere automatizzato tramite gli endpoint API forniti:
+ `scan_with_checkov`per la scansione IAC
+ `scan_with_semgrep`per la scansione di codici multilingue
+ `scan_with_bandit`per la scansione specifica di Python
+ `get_supported_formats`per la convalida del formato
Quando estendete gli strumenti di scansione, seguite i principi di progettazione e le best practice descritti in precedenza in questa sezione. Vedi anche [Best practice](#deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants-best-practices).
## Tools (Strumenti)
**Servizi AWS**
+ [Kiro](https://aws.amazon.com/documentation-overview/kiro/) è un servizio di codifica agentica che collabora con gli sviluppatori per trasformare le istruzioni in specifiche dettagliate, quindi in codice funzionante, documenti e test. Gli agenti Kiro aiutano gli sviluppatori a risolvere problemi complessi e ad automatizzare attività come la generazione di documentazione e i test unitari.
+ [Amazon Q Developer](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/what-is.html) è un assistente conversazionale generativo basato sull'intelligenza artificiale che può aiutarti a comprendere, creare, estendere e utilizzare le applicazioni. AWS
**Altri strumenti**
+ [Bandit](https://bandit.readthedocs.io/en/latest/) è uno strumento di scansione di sicurezza Python specializzato. Rileva problemi di sicurezza comuni in Python come funzioni non sicure, segreti codificati e vulnerabilità di iniezione. Bandit fornisce valutazioni dettagliate di confidenza e gravità.
+ [Checkov](https://github.com/bridgecrewio/checkov) è uno strumento statico di analisi del codice che verifica la presenza di configurazioni errate di sicurezza e conformità in IaC. Inoltre, Checkov rileva le violazioni della conformità e le migliori pratiche di sicurezza.
+ [Cline](https://cline.bot/) è un assistente di codifica basato sull'intelligenza artificiale che funziona in VS Code.
+ [Loguru](https://loguru.readthedocs.io/en/stable/) è una libreria di convalida dei dati per Python.
+ [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro) è un framework open source per la creazione di strumenti di sviluppo assistiti dall'intelligenza artificiale.
+ [Pydantic](https://docs.pydantic.dev/latest/) è una libreria di convalida dei dati per Python.
+ [Semgrep](https://semgrep.dev/docs/introduction) analizza il codice sorgente alla ricerca di vulnerabilità e bug di sicurezza. Supporta più linguaggi di programmazione. Semgrep utilizza set di regole incentrati sulla sicurezza per un'analisi completa. Fornisce valutazioni dettagliate di confidenza e gravità.
**Archivio di codice**
Il codice di questo pattern è disponibile nell'archivio GitHub [MCP Security Scanner: Real-Time Protection for AI Code Assistants](https://github.com/aws-samples/sample-mcp-security-scanner). L'archivio include l'implementazione del server MCP, dettagli sulla configurazione MCP per Kiro, Amazon Q Developer, Cline e altri, esempi di configurazione e utilità di test.
La struttura del repository include:
+ `security_scanner_mcp_server/`- Implementazione del server principale
+ `docs/`- Documentazione e materiali dimostrativi
+ `tests/`- File di test
+ `mcp-config-example.json`- Esempio di configurazione MCP
+ `requirements.txt`- Dipendenze del progetto
## Best practice
**Implementazione della scansione di**
+ Esamina i risultati di sicurezza per convalidare e dare priorità ai problemi.
+ Mantieni gli strumenti di scansione (Checkov, Semgrep e Bandit) aggiornati alle versioni più recenti.
+ Utilizzate lo strumento di sicurezza MCP di questo pattern insieme ad altre misure e strumenti di sicurezza.
+ Aggiorna regolarmente i set di regole e le politiche di sicurezza.
**Gestione della configurazione**
+ Utilizza i file di configurazione MCP nel codice sorgente ufficiale di controllo della versione.
+ Documenta regole e configurazioni personalizzate.
**Integration**
+ Integra la scansione di sicurezza nelle prime fasi del ciclo di sviluppo.
+ Imposta la scansione automatica in hook pre-commit o in pipeline di integrazione continua e distribuzione continua (CI/CD).
+ Configura le soglie di gravità appropriate per il tuo ambiente.
+ Stabilisci procedure chiare per la gestione dei risultati di sicurezza.
**Considerazioni operative**
+ Monitora le prestazioni di scansione e l'utilizzo delle risorse.
+ Implementa la corretta gestione e registrazione degli errori.
+ Conserva la documentazione delle configurazioni personalizzate.
+ Stabilisci un processo per la revisione e l'aggiornamento delle regole di sicurezza.
Inoltre, tieni presente le seguenti best practice:
+ Convalida sempre i risultati di sicurezza nel tuo contesto specifico.
+ Mantieni aggiornati gli strumenti di sicurezza e le dipendenze.
+ Utilizza più strumenti di sicurezza per una copertura completa.
+ Segui le migliori pratiche di sicurezza nel tuo processo di sviluppo.
## Epiche
### (Utenti Kiro) Configura il server dello scanner di sicurezza MCP
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configurare le impostazioni MCP. | Puoi modificare i file di configurazione in Kiro (Opzione 1) localizzando manualmente i file di configurazione o (Opzione 2) utilizzando l'IDE Kiro.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html){
"mcpServers": {
"security-scanner": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
"security_scanner_mcp_server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
},
"disabled": false,
"autoApprove": []
}
}
} | Sviluppatore di app |
### (Utenti Amazon Q Developer) Configura il server dello scanner di sicurezza MCP
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configurare le impostazioni MCP. | Per configurare manualmente le impostazioni MCP, effettuate le seguenti operazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html){
"mcpServers": {
"security-scanner": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
"security_scanner_mcp_server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
}
}
}
} | Sviluppatore di app |
### (Utenti Cline) Configurate il server dello scanner di sicurezza MCP
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configurare le impostazioni MCP. | Per configurare manualmente le impostazioni MCP, effettuate le seguenti operazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html){
"mcpServers": {
"security-scanner": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
"security_scanner_mcp_server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
},
"disabled": false,
"autoApprove": []
}
}
} | Sviluppatore di app |
### Esempio di analisi del codice con Python e Bandit
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esegui l'analisi del codice. | Per eseguire l'analisi del codice utilizzando Python e Bandit, utilizzate i seguenti passaggi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | Sviluppatore di app |
### Esempio di analisi del codice utilizzando Terraform e Checkov
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esegui l'analisi del codice. | Per eseguire l'analisi del codice utilizzando Terraform e Checkov, utilizza i seguenti passaggi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | Sviluppatore di app |
### Esempio di funzionalità di scansione avanzate
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esegui scansioni mirate. | Di seguito sono riportati alcuni esempi di richieste che è possibile utilizzare per eseguire una scansione mirata:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | Sviluppatore di app |
| Usa la scansione di sicurezza con la generazione di codice. | Per risolvere i problemi di sicurezza utilizzando i loop di generazione del codice, utilizza i seguenti passaggi (questo esempio utilizza Kiro come assistente di codifica):[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) | Sviluppatore di app |
## Risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| Problemi di configurazione dell'ambiente | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Problemi con lo scanner | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Problemi di integrazione | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
| Supporto aggiuntivo | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/deploy-real-time-coding-security-validation-by-using-an-mcp-server-with-kiro-and-other-coding-assistants.html) |
## Risorse correlate
**AWS documentazione**
+ [Infrastruttura come codice](https://docs.aws.amazon.com/whitepapers/latest/introduction-devops-aws/infrastructure-as-code.html) (AWS Whitepaper *Introduzione* a on) DevOps AWS
**Altre risorse AWS **
+ [Best practice per sicurezza, identità e conformità.](https://aws.amazon.com/architecture/security-identity-compliance/)
**Altre risorse**
+ [Documentazione Bandit](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [Documentazione Checkov](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [Documentazione del Model Context Protocol (MCP)](https://aws.amazon.com/architecture/security-identity-compliance/)
+ [OWASP Secure Coding Practices (sito web della OWASP Foundation](https://owasp.org/www-project-secure-coding-practices-quick-reference-guide/))
+ [Documentazione Semgrep](https://aws.amazon.com/architecture/security-identity-compliance/)
## Informazioni aggiuntive
**Esempio di configurazione MCP con approvazione automatica abilitata**
Se non è `autoApprove` configurato, l'utente deve concedere l'approvazione per inviare il codice al server di sicurezza MCP per la scansione. Una volta `autoApprove` configurato, l'assistente al codice può richiamare gli strumenti senza l'approvazione dell'utente. Questi strumenti vengono eseguiti localmente sulla macchina, non viene inviato alcun dato e viene eseguita solo una scansione del codice.
La seguente configurazione consente l'esecuzione automatica di tutte le funzioni di scansione di sicurezza:
```
{
"mcpServers": {
"security-scanner": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/aws-samples/sample-mcp-security-scanner.git@main",
"security_scanner_mcp_server"
],
"env": {
"FASTMCP_LOG_LEVEL": "ERROR"
},
"disabled": false,
"autoApprove": [
"scan_with_checkov",
"scan_with_semgrep",
"scan_with_bandit",
"get_supported_formats"
]
}
}
}
```
Per abilitare la registrazione di debug, impostare su`"FASTMCP_LOG_LEVEL"`. `"DEBUG"`
**Formati di file supportati dagli strumenti di scansione di sicurezza**
Ogni strumento di scansione di sicurezza di questa soluzione supporta i seguenti formati di file:
*Checkov (IaC)*
+ Terraform: .tf, .tfvars, .tfstate
+ CloudFormation — .yaml, .yml, .json, .template
+ Kubernetes: .yaml, .yml
+ Dockerfile — Dockerfile
+ ARM — .json (Gestore delle risorse di Azure)
+ Bicipite — .bicipite
+ Senza server: .yml, .yaml
+ Timone: .yaml, .yml, .tpl
+ GitHub Azioni: .yml, .yaml
+ GitLab\$1ci — .yml, .yaml
+ Ansible: .yml, .yaml
*Semgrep (codice sorgente)*
+ Python — .py
+ JavaScript — .js
+ TypeScript — .ts
+ Giava — .java
+ Vai — .go
+ C — c.
+ C\$1\$1 — .cpp
+ C\$1 — .cs
+ Rubino — .rb
+ PHP — .php
+ Scala — .scala
+ Kotlin — .kt
+ Rust — .rs
*Bandit (solo Python)*
+ Python — .py
**Demo**
Per la scansione del codice, prova i seguenti esempi di istruzioni con il tuo assistente AI:
+ «Scansiona lo script corrente e dimmi i risultati».
+ «Scansiona le righe da 20 a 60 e dimmi i risultati».
+ «Scansiona questa risorsa della tabella Amazon DynamoDB e dimmi il risultato».
Per ulteriori informazioni, consulta questa [demo sulla scansione del codice](https://github.com/aws-samples/sample-mcp-security-scanner/blob/main/docs/demo_code_scan.gif) nell'archivio di GitHub questo pattern.
Per generare codice sicuro, prova i seguenti prompt di esempio:
+ «Genera una configurazione Terraform per creare una tabella DynamoDB con crittografia abilitata e scansionala per problemi di sicurezza».
+ «Crea una funzione Python Lambda che scriva su DynamoDB e scansionala per individuare eventuali vulnerabilità».
+ «Genera un CloudFormation modello per un bucket S3 con impostazioni di sicurezza adeguate e verifica che superi i controlli di sicurezza».
+ «Scrivi uno script Python per interrogare DynamoDB con impaginazione e scansiona le migliori pratiche di sicurezza».
+ «Crea un manifesto di distribuzione Kubernetes per un microservizio con un rafforzamento della sicurezza e convalidalo».
Per ulteriori informazioni, guarda questa demo sulla [generazione di codice con scansione di sicurezza](https://github.com/aws-samples/sample-mcp-security-scanner/blob/main/docs/demo_code_generation.gif) nell'archivio di questo pattern. GitHub
# Sviluppa assistenti avanzati basati sull'intelligenza artificiale generativa utilizzando RAG e suggerimenti ReAct
*Praveen Kumar Jeyarajan, Shuai Cao, Noah Hamilton, Kiowa Jackson, Jundong Qiao e Kara Yang, Amazon Web Services*
## Riepilogo
Un'azienda tipica ha il 70 percento dei propri dati intrappolati in sistemi isolati. Puoi utilizzare assistenti generativi basati su chat basati sull'intelligenza artificiale per sbloccare informazioni e relazioni tra questi silos di dati attraverso interazioni in linguaggio naturale. Per ottenere il massimo dall'intelligenza artificiale generativa, i risultati devono essere affidabili, accurati e includere i dati aziendali disponibili. Il successo degli assistenti basati sulla chat dipende da quanto segue:
+ Modelli di intelligenza artificiale generativa (come Anthropic Claude 2)
+ Vettorizzazione delle fonti di dati
+ Tecniche di ragionamento avanzate, come il [ReAct framework, per suggerire il modello](https://www.promptingguide.ai/techniques/react)
Questo modello fornisce approcci per il recupero dei dati da fonti di dati come bucket Amazon Simple Storage Service (Amazon S3), AWS Glue e Amazon Relational Database Service (Amazon RDS). [Si ottiene valore da tali dati combinando Retrieval Augmented Generation (RAG) con i metodi.](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html) chain-of-thought I risultati supportano complesse conversazioni con assistenti basate su chat che attingono alla totalità dei dati archiviati dall'azienda.
Questo modello utilizza i SageMaker manuali di Amazon e le tabelle dei dati dei prezzi come esempio per esplorare le funzionalità di un assistente generativo basato sull'intelligenza artificiale basato su chat. Creerai un assistente basato su chat che aiuterà i clienti a valutare il SageMaker servizio rispondendo a domande sui prezzi e sulle funzionalità del servizio. La soluzione utilizza una libreria Streamlit per la creazione dell'applicazione frontend e il LangChain framework per lo sviluppo del backend dell'applicazione basato su un modello di linguaggio di grandi dimensioni (LLM).
Le richieste all'assistente basato sulla chat vengono soddisfatte con una classificazione iniziale degli intenti per il routing verso uno dei tre possibili flussi di lavoro. Il flusso di lavoro più sofisticato combina una consulenza generale con un'analisi complessa dei prezzi. È possibile adattare il modello ai casi d'uso aziendali, aziendali e industriali.
## Prerequisiti e limitazioni
**Prerequisiti**
+ [AWS Command Line Interface (AWS CLI) installata](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e configurata
+ [AWS Cloud Development Kit (AWS CDK) Toolkit 2.114.1 o versione successiva installato](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) e configurato
+ Familiarità di base con Python e AWS CDK
+ [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) installato
+ [Docker installato](https://docs.docker.com/get-docker/)
+ [Python 3.11 o successivo](https://www.python.org/downloads/) [installato e configurato (per maggiori informazioni, consulta la sezione Strumenti)](#develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting-tools)
+ [Un [account AWS attivo](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-creating.html) avviato utilizzando AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)
+ [Accesso ai modelli](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#add-model-access) Amazon Titan e Anthropic Claude abilitato nel servizio Amazon Bedrock
+ [Credenziali di sicurezza AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html)`AWS_ACCESS_KEY_ID`, incluse quelle configurate correttamente nell'ambiente terminale
**Limitazioni**
+ LangChain non supporta tutti i LLM per lo streaming. I modelli Anthropic Claude sono supportati, ma i modelli di AI21 Labs no.
+ Questa soluzione viene distribuita su un singolo account AWS.
+ Questa soluzione può essere distribuita solo nelle regioni AWS in cui sono disponibili Amazon Bedrock e Amazon Kendra. Per informazioni sulla disponibilità, consulta la documentazione per [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html#bedrock-regions) e [Amazon Kendra](https://docs.aws.amazon.com/general/latest/gr/kendra.html).
**Versioni del prodotto**
+ Python versione 3.11 o successiva
+ Streamlit versione 1.30.0 o successiva
+ Streamlit-chat versione 0.1.1 o successiva
+ LangChain versione 0.1.12 o successiva
+ AWS CDK versione 2.132.1 o successiva
## Architecture
**Stack tecnologico Target**
+ Amazon Athena
+ Amazon Bedrock
+ Amazon Elastic Container Service (Amazon ECS)
+ AWS Glue
+ AWS Lambda
+ Simple Storage Service (Amazon S3)
+ Amazon Kendra
+ Elastic Load Balancing
**Architettura di destinazione**
Il codice CDK AWS distribuirà tutte le risorse necessarie per configurare l'applicazione di assistenza basata su chat in un account AWS. L'applicazione di assistenza basata sulla chat mostrata nel diagramma seguente è progettata per rispondere alle domande correlate degli utenti. SageMaker Gli utenti si connettono tramite un Application Load Balancer a un VPC che contiene un cluster Amazon ECS che ospita l'applicazione Streamlit. Una funzione Lambda di orchestrazione si connette all'applicazione. Le sorgenti dati dei bucket S3 forniscono dati alla funzione Lambda tramite Amazon Kendra e AWS Glue. La funzione Lambda si connette ad Amazon Bedrock per rispondere alle domande (domande) degli utenti assistenti basati sulla chat.
![\[Diagramma architetturale.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/b4df6405-76ab-4493-a722-15ceca067254/images/4e5856cf-9489-41f8-a411-e3b8d8a50748.png)
1. La funzione di orchestrazione Lambda invia la richiesta di prompt LLM al modello Amazon Bedrock (Claude 2).
1. Amazon Bedrock invia la risposta LLM alla funzione di orchestrazione Lambda.
**Flusso logico all'interno della funzione Lambda di orchestrazione**
Quando gli utenti fanno una domanda tramite l'applicazione Streamlit, richiama direttamente la funzione di orchestrazione Lambda. Il diagramma seguente mostra il flusso logico quando viene richiamata la funzione Lambda.
![\[Diagramma architetturale.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/b4df6405-76ab-4493-a722-15ceca067254/images/70ae4736-06a6-4d3a-903a-edc5c10d78a0.png)
+ Fase 1 — L'input `query` (domanda) viene classificato in uno dei tre intenti:
+ Domande generali di SageMaker orientamento
+ Domande generali SageMaker sui prezzi (formazione/inferenza)
+ Domande complesse relative ai prezzi SageMaker
+ Fase 2 — L'input `query` avvia uno dei tre servizi:
+ `RAG Retrieval service`, che recupera il contesto pertinente dal database vettoriale [Amazon Kendra](https://aws.amazon.com/kendra/) e richiama l'LLM [tramite Amazon](https://aws.amazon.com/bedrock/) Bedrock per riepilogare il contesto recuperato come risposta.
+ `Database Query service`, che utilizza il LLM, i metadati del database e le righe di esempio delle tabelle pertinenti per convertire l'input in una query SQL. `query` Il servizio Database Query esegue la query SQL sul database SageMaker dei prezzi tramite [Amazon Athena](https://aws.amazon.com/athena/) e riassume i risultati della query come risposta.
+ `In-context ReACT Agent service`, che suddivide l'input `query` in più fasi prima di fornire una risposta. L'agente utilizza `RAG Retrieval service` e `Database Query service` come strumenti per recuperare le informazioni pertinenti durante il processo di ragionamento. Una volta completati i processi di ragionamento e azione, l'agente genera la risposta finale come risposta.
+ Fase 3 — La risposta della funzione Lambda di orchestrazione viene inviata all'applicazione Streamlit come output.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) è un servizio di query interattivo che ti aiuta ad analizzare i dati direttamente in Amazon Simple Storage Service (Amazon S3) utilizzando SQL standard.
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) è un servizio completamente gestito che rende disponibili per l'uso modelli di base ad alte prestazioni (FMs) delle principali startup di intelligenza artificiale e di Amazon tramite un'API unificata.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) è un framework di sviluppo software che aiuta a definire e fornire l'infrastruttura cloud AWS in codice.
+ [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento open source che ti aiuta a interagire con i servizi AWS tramite comandi nella tua shell a riga di comando.
+ [Amazon Elastic Container Service (Amazon ECS)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) è un servizio rapido e scalabile di gestione dei container che ti aiuta a eseguire, arrestare e gestire container in un cluster.
+ [AWS Glue](https://docs.aws.amazon.com/glue/) è un servizio di estrazione, trasformazione e caricamento (ETL) completamente gestito. Ti aiuta a classificare, pulire, arricchire e spostare i dati in modo affidabile tra archivi di dati e flussi di dati. Questo modello utilizza un crawler AWS Glue e una tabella AWS Glue Data Catalog.
+ [Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html) è un servizio di ricerca intelligente che utilizza l'elaborazione del linguaggio naturale e algoritmi avanzati di apprendimento automatico per restituire risposte specifiche alle domande di ricerca dai tuoi dati.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di elaborazione che ti aiuta a eseguire codice senza dover fornire o gestire server. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di calcolo che utilizzi.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
+ [Elastic Load Balancing (ELB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) distribuisce il traffico di applicazioni o di rete in entrata su più destinazioni. Ad esempio, puoi distribuire il traffico tra istanze Amazon Elastic Compute Cloud (Amazon EC2), contenitori e indirizzi IP in una o più zone di disponibilità.
**Repository di codice**
Il codice per questo pattern è disponibile nel GitHub [genai-bedrock-chatbot](https://github.com/awslabs/genai-bedrock-chatbot)repository.
L'archivio del codice contiene i seguenti file e cartelle:
+ `assets`cartella: le risorse statiche, il diagramma dell'architettura e il set di dati pubblico
+ `code/lambda-container`folder — Il codice Python eseguito nella funzione Lambda
+ `code/streamlit-app`folder — Il codice Python che viene eseguito come immagine del contenitore in Amazon ECS
+ `tests`folder — I file Python che vengono eseguiti per testare unitariamente i costrutti CDK di AWS
+ `code/code_stack.py`— Il CDK AWS costruisce i file Python utilizzati per creare risorse AWS
+ `app.py`— I file Python dello stack CDK di AWS utilizzati per distribuire le risorse AWS nell'account AWS di destinazione
+ `requirements.txt`— L'elenco di tutte le dipendenze Python che devono essere installate per AWS CDK
+ `requirements-dev.txt`— L'elenco di tutte le dipendenze Python che devono essere installate affinché AWS CDK esegua la suite unit-test
+ `cdk.json`— Il file di input per fornire i valori necessari per avviare le risorse
|
|
| Nota: il codice CDK di AWS utilizza [costrutti L3 (livello 3) e policy AWS](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html) [Identity and Access Management (IAM) gestite da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) per distribuire la soluzione. |
| --- |
## Best practice
+ L'esempio di codice fornito qui è solo per una demo proof-of-concept (PoC) o pilota. Se vuoi portare il codice in Production, assicurati di utilizzare le seguenti best practice:
+ La [registrazione degli accessi di Amazon S3 è abilitata.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html)
+ I [log di flusso VPC sono abilitati.](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html)
+ L'indice [Amazon Kendra Enterprise Edition](https://docs.aws.amazon.com/whitepapers/latest/how-aws-pricing-works/amazon-kendra.html) è abilitato.
+ Imposta il monitoraggio e gli avvisi per la funzione Lambda. Per ulteriori informazioni, consulta [Monitoraggio e risoluzione dei problemi delle funzioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html). Per le best practice generali relative all'utilizzo delle funzioni Lambda, consulta la documentazione [AWS](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html).
## Epiche
### Configura le credenziali AWS sul tuo computer locale
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esporta le variabili per l'account e la regione AWS in cui verrà distribuito lo stack. | Per fornire le credenziali AWS per AWS CDK utilizzando variabili di ambiente, esegui i seguenti comandi.export CDK_DEFAULT_ACCOUNT=<12 Digit AWS Account Number>
export CDK_DEFAULT_REGION=
| DevOps ingegnere, AWS DevOps |
| Configura il profilo AWS CLI. | Per configurare il profilo AWS CLI per l'account, segui le istruzioni nella documentazione [AWS](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/keys-profiles-credentials.html). | DevOps ingegnere, AWS DevOps |
### Configurare l'ambiente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona il repository sul tuo computer locale. | Per clonare il repository, esegui il seguente comando nel tuo terminale.git clone https://github.com/awslabs/genai-bedrock-chatbot.git
| DevOps ingegnere, AWS DevOps |
| Configura l'ambiente virtuale Python e installa le dipendenze richieste. | Per configurare l'ambiente virtuale Python, esegui i seguenti comandi.cd genai-bedrock-chatbot
python3 -m venv .venv
source .venv/bin/activate
Per configurare le dipendenze richieste, esegui il comando seguente.pip3 install -r requirements.txt
| DevOps ingegnere, AWS DevOps |
| Configura l'ambiente AWS CDK e sintetizza il codice CDK AWS. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html) | DevOps ingegnere, AWS DevOps |
### Configura e distribuisci l'applicazione di assistenza basata sulla chat
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Fornire l'accesso al modello Claude. | Per abilitare l'accesso al modello Anthropic Claude per il tuo account AWS, segui le istruzioni nella documentazione di [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#add-model-access). | AWS DevOps |
| Distribuisci risorse nell'account. | Per distribuire risorse nell'account AWS utilizzando il CDK AWS, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)**Una volta completata la distribuzione, puoi accedere all'applicazione di assistenza basata sulla chat utilizzando l'URL fornito nella sezione Output. CloudFormation ** | AWS DevOps, DevOps ingegnere |
| Esegui il crawler AWS Glue e crea la tabella Data Catalog. | Un [crawler AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) viene utilizzato per mantenere dinamico lo schema dei dati. La soluzione crea e aggiorna le partizioni nella [tabella del catalogo dati di AWS Glue](https://docs.aws.amazon.com/athena/latest/ug/querying-glue-catalog.html) eseguendo il crawler su richiesta. Dopo aver copiato i file del set di dati CSV nel bucket S3, esegui il crawler AWS Glue e crea lo schema della tabella Data Catalog per i test:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)Il codice CDK AWS configura il crawler AWS Glue per l'esecuzione su richiesta, ma puoi anche [pianificarne](https://docs.aws.amazon.com/glue/latest/dg/schedule-crawler.html) l'esecuzione periodica. | DevOps ingegnere, AWS DevOps |
| Avvia l'indicizzazione dei documenti. | Dopo aver copiato i file nel bucket S3, usa Amazon Kendra per scansionarli e indicizzarli:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html)[Il codice CDK AWS configura la sincronizzazione dell'indice Amazon Kendra per l'esecuzione su richiesta, ma puoi anche eseguirla periodicamente utilizzando il parametro Schedule.](https://docs.aws.amazon.com/kendra/latest/dg/data-source.html#cron) | AWS DevOps, DevOps ingegnere |
### Pulisci tutte le risorse AWS nella soluzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Rimuovi le risorse AWS. | Dopo aver testato la soluzione, pulisci le risorse:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.html) | DevOps ingegnere, AWS DevOps |
## Risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| AWS CDK restituisce errori. | Per assistenza con i problemi di AWS CDK, consulta [Risoluzione dei problemi comuni di AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html). |
## Risorse correlate
+ Amazon Base:
+ [Accesso al modello](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Parametri di inferenza per i modelli di base](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Creazione di funzioni Lambda con Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Inizia a usare il CDK AWS](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Lavorare con il CDK AWS in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Generative AI Application Builder su AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
+ [LangChain documentazione](https://python.langchain.com/docs/get_started/introduction)
+ [Documentazione semplificata](https://docs.streamlit.io/)
## Informazioni aggiuntive
**Comandi AWS CDK**
Quando lavori con AWS CDK, tieni presente i seguenti comandi utili:
+ Elenca tutti gli stack presenti nell'app
```
cdk ls
```
+ Emette il modello AWS sintetizzato CloudFormation
```
cdk synth
```
+ Distribuisce lo stack nell'account e nella regione AWS predefiniti
```
cdk deploy
```
+ Confronta lo stack distribuito con lo stato attuale
```
cdk diff
```
+ Apre la documentazione di AWS CDK
```
cdk docs
```
+ Elimina lo CloudFormation stack e rimuove le risorse distribuite da AWS
```
cdk destroy
```
# Sviluppa un assistente basato su chat completamente automatizzato utilizzando gli agenti e le knowledge base di Amazon Bedrock
*Jundong Qiao, Shuai Cao, Noah Hamilton, Kiowa Jackson, Praveen Kumar Jeyarajan e Kara Yang, Amazon Web Services*
## Riepilogo
Molte organizzazioni incontrano difficoltà nella creazione di un assistente basato su chat in grado di orchestrare diverse fonti di dati per offrire risposte complete. Questo modello presenta una soluzione per lo sviluppo di un assistente basato su chat in grado di rispondere alle domande provenienti sia dalla documentazione che dai database, con un'implementazione semplice.
A partire [da Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html), questo servizio di intelligenza artificiale generativa (AI) completamente gestito offre un'ampia gamma di modelli di base avanzati (FMs). Ciò facilita la creazione efficiente di applicazioni di intelligenza artificiale generativa con una forte attenzione alla privacy e alla sicurezza. Nel contesto del recupero della documentazione, il [Retrieval Augmented Generation (](https://docs.aws.amazon.com/sagemaker/latest/dg/jumpstart-foundation-models-customize-rag.html)RAG) è una funzionalità fondamentale. Utilizza [basi di conoscenza](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html) per arricchire i prompt FM con informazioni contestualmente rilevanti provenienti da fonti esterne. Un indice [Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html) funge da database vettoriale alla base delle knowledge base per Amazon Bedrock. Questa integrazione è migliorata attraverso un'attenta progettazione tempestiva per ridurre al minimo le imprecisioni e garantire che le risposte siano ancorate a una documentazione fattuale. Per le query sui database, Amazon Bedrock trasforma le FMs richieste testuali in query SQL strutturate, incorporando parametri specifici. [Ciò consente il recupero preciso dei dati dai database gestiti dai database.AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/define-database.html) [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) viene utilizzato per queste query.
Per gestire interrogazioni più complesse, ottenere risposte complete richiede informazioni provenienti sia dalla documentazione che dai database. [Agents for Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html) è una funzionalità di intelligenza artificiale generativa che ti aiuta a creare agenti autonomi in grado di comprendere attività complesse e suddividerle in attività più semplici da orchestrare. La combinazione di informazioni ricavate dalle attività semplificate, facilitata dagli agenti autonomi di Amazon Bedrock, migliora la sintesi delle informazioni, portando a risposte più complete ed esaustive. Questo modello dimostra come creare un assistente basato su chat utilizzando Amazon Bedrock e i relativi servizi e funzionalità di intelligenza artificiale generativa all'interno di una soluzione automatizzata.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS
+ [Docker, installato](https://docs.docker.com/engine/install/)
+ AWS Cloud Development Kit (AWS CDK), [installato](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_tools) e [avviato in o](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_bootstrap) `us-east-1` `us-west-2` Regioni AWS
+ AWS CDK [Toolkit versione 2.114.1 o successiva, installata](https://docs.aws.amazon.com/cdk/v2/guide/cli.html)
+ AWS Command Line Interface [https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Python versione 3.11 o successiva, installata](https://www.python.org/downloads/)
+ In Amazon Bedrock, [abilita l'accesso](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html) a Claude 2, Claude 2.1, Claude Instant e Titan Embeddings G1 — Text
**Limitazioni**
+ Questa soluzione viene distribuita su un unico dispositivo. Account AWS
+ Questa soluzione può essere implementata solo Regioni AWS dove sono supportati Amazon Bedrock e Amazon OpenSearch Serverless. Per ulteriori informazioni, consulta la documentazione per [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) e [Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html#serverless-regions).
**Versioni del prodotto**
+ Llama-index versione 0.10.6 o successiva
+ Sqlalchemy versione 2.0.23 o successiva
+ OpenSearch-PY versione 2.4.2 o successiva
+ Requests\$1AWS4Auth versione 1.2.3 o successiva
+ AWS SDK per Python (Boto3) versione 1.34.57 o successiva
## Architecture
**Stack tecnologico Target**
[AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html)È un framework di sviluppo software open source per definire l'infrastruttura cloud in codice e fornirla tramite. AWS CloudFormation Lo AWS CDK stack utilizzato in questo modello distribuisce le seguenti risorse: AWS
+ AWS Key Management Service (AWS KMS)
+ Amazon Simple Storage Service (Amazon S3)
+ AWS Glue Data Catalog, per il componente del database AWS Glue
+ AWS Lambda
+ AWS Identity and Access Management (IAM)
+ Amazon OpenSearch Serverless
+ Amazon Elastic Container Registry (Amazon ECR)
+ Amazon Elastic Container Service (Amazon ECS)
+ AWS Fargate
+ Amazon Virtual Private Cloud (Amazon VPC) (Amazon VPC)
+ [Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)
**Architettura Target**
![\[Diagramma di architettura utilizzando una knowledge base e un agente Amazon Bedrock\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/15372718-3a5d-4918-9cfa-422c455f288d/images/ff19152e-0bb6-4758-a6dd-4f6140e55113.png)
Il diagramma mostra una configurazione AWS nativa del cloud completa all'interno di un'unica configurazione, utilizzandone più di una. Regione AWS Servizi AWS L'interfaccia principale per l'assistente basato sulla chat è un'applicazione [Streamlit](https://docs.streamlit.io/) ospitata su un cluster Amazon ECS. Un [Application Load Balancer](https://aws.amazon.com/elasticloadbalancing/application-load-balancer/) gestisce l'accessibilità. Le interrogazioni effettuate tramite questa interfaccia attivano la funzione `Invocation` Lambda, che si interfaccia quindi con gli agenti per Amazon Bedrock. Questo agente risponde alle richieste degli utenti consultando le knowledge base per Amazon Bedrock o richiamando una funzione Lambda. `Agent executor` Questa funzione attiva una serie di azioni associate all'agente, seguendo uno schema API predefinito. Le knowledge base di Amazon Bedrock utilizzano un indice OpenSearch Serverless come base per il database vettoriale. Inoltre, la `Agent executor` funzione genera query SQL che vengono eseguite sul AWS Glue database tramite Amazon Athena.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/what-is.html) è un servizio di query interattivo che ti aiuta ad analizzare i dati direttamente in Amazon Simple Storage Service (Amazon S3) utilizzando SQL standard.
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) è un servizio completamente gestito che rende disponibili per l'uso modelli di base ad alte prestazioni (FMs) delle principali startup di intelligenza artificiale e di Amazon tramite un'API unificata.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)è un framework di sviluppo software che ti aiuta a definire e fornire l'infrastruttura AWS Cloud in codice.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che consente di interagire Servizi AWS tramite comandi nella shell della riga di comando.
+ [Amazon Elastic Container Service (Amazon ECS)](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) è un servizio rapido e scalabile di gestione dei container che ti aiuta a eseguire, arrestare e gestire container in un cluster.
+ [Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) distribuisce il traffico di applicazioni o di rete in entrata su più destinazioni. Ad esempio, puoi distribuire il traffico tra istanze Amazon Elastic Compute Cloud (Amazon EC2), contenitori e indirizzi IP in una o più zone di disponibilità.
+ [AWS Glue](https://docs.aws.amazon.com/glue/)è un servizio di estrazione, trasformazione e caricamento (ETL) completamente gestito. Ti aiuta a classificare, pulire, arricchire e spostare i dati in modo affidabile tra archivi di dati e flussi di dati. Questo modello utilizza un AWS Glue crawler e una tabella. AWS Glue Data Catalog
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di elaborazione che utilizzi.
+ [Amazon OpenSearch Serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-overview.html) è una configurazione serverless su richiesta per Amazon Service. OpenSearch In questo modello, un indice OpenSearch Serverless funge da database vettoriale per le knowledge base di Amazon Bedrock.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
**Altri strumenti**
+ [Streamlit](https://docs.streamlit.io/) è un framework Python open source per creare applicazioni di dati.
**Deposito di codice**
Il codice per questo pattern è disponibile nel GitHub [genai-bedrock-agent-chatbot](https://github.com/awslabs/genai-bedrock-agent-chatbot/)repository. L'archivio del codice contiene i seguenti file e cartelle:
+ `assets`cartella: le risorse statiche, come il diagramma dell'architettura e il set di dati pubblico.
+ `code/lambdas/action-lambda`folder — Il codice Python per la funzione Lambda che funge da azione per l'agente Amazon Bedrock.
+ `code/lambdas/create-index-lambda`folder — Il codice Python per la funzione Lambda che crea l'indice Serverless. OpenSearch
+ `code/lambdas/invoke-lambda`folder — Il codice Python per la funzione Lambda che richiama l'agente Amazon Bedrock, chiamato direttamente dall'applicazione Streamlit.
+ `code/lambdas/update-lambda`folder — Il codice Python per la funzione Lambda che aggiorna o elimina le risorse dopo che le risorse sono state distribuite tramite. AWS AWS CDK
+ `code/layers/boto3_layer`folder: lo AWS CDK stack che crea un livello Boto3 condiviso tra tutte le funzioni Lambda.
+ `code/layers/opensearch_layer`folder: lo AWS CDK stack che crea un livello OpenSearch Serverless che installa tutte le dipendenze per creare l'indice.
+ `code/streamlit-app`folder — Il codice Python che viene eseguito come immagine del contenitore in Amazon ECS.
+ `code/code_stack.py`— I file di AWS CDK costruzione in Python che AWS creano risorse.
+ `app.py`— I file Python AWS CDK dello stack che AWS distribuiscono le risorse nell'account di destinazione. AWS
+ `requirements.txt`— L'elenco di tutte le dipendenze Python che devono essere installate per. AWS CDK
+ `cdk.json`— Il file di input per fornire i valori necessari per creare risorse. Inoltre, nei `context/config` campi, è possibile personalizzare la soluzione di conseguenza. Per ulteriori informazioni sulla personalizzazione, vedere la sezione [Informazioni aggiuntive](#develop-a-fully-automated-chat-based-assistant-by-using-amazon-bedrock-agents-and-knowledge-bases-additional).
## Best practice
+ L'esempio di codice fornito qui è solo a scopo proof-of-concept (PoC) o pilota. Se vuoi portare il codice in produzione, assicurati di utilizzare le seguenti best practice:
+ Abilita la registrazione degli [accessi ad Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html)
+ Abilita i log di [flusso VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html)
+ Imposta il monitoraggio e gli avvisi per le funzioni Lambda. Per ulteriori informazioni, consulta [Monitoraggio e risoluzione dei problemi delle funzioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-monitoring.html). Per le best practice, consulta le [Best practice per l'utilizzo AWS Lambda delle funzioni](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html).
## Epiche
### Imposta AWS le credenziali sulla tua workstation locale
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esporta le variabili per l'account e la regione. | Per fornire AWS le credenziali AWS CDK utilizzando le variabili di ambiente, esegui i seguenti comandi.export CDK_DEFAULT_ACCOUNT=<12-digit AWS account number>
export CDK_DEFAULT_REGION=
| AWS DevOps, DevOps ingegnere |
| Configura il profilo AWS CLI denominato. | Per configurare il profilo AWS CLI denominato per l'account, segui le istruzioni in [Configurazione e impostazioni del file di credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). | AWS DevOps, DevOps ingegnere |
### Configurare l'ambiente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona il repository sulla tua workstation locale. | Per clonare il repository, esegui il seguente comando nel tuo terminale.git clone https://github.com/awslabs/genai-bedrock-agent-chatbot.git
| DevOps ingegnere, AWS DevOps |
| Configura l'ambiente virtuale Python. | Per configurare l'ambiente virtuale Python, esegui i seguenti comandi.cd genai-bedrock-agent-chatbot
python3 -m venv .venv
source .venv/bin/activate
Per configurare le dipendenze richieste, esegui il comando seguente.pip3 install -r requirements.txt
| DevOps ingegnere, AWS DevOps |
| Configura l' AWS CDK ambiente. | Per convertire il codice in un AWS CloudFormation modello, esegui il comando`cdk synth`. | AWS DevOps, DevOps ingegnere |
### Configura e distribuisci l'applicazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Distribuisci risorse nell'account. | Per distribuire risorse Account AWS utilizzando il AWS CDK, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/develop-a-fully-automated-chat-based-assistant-by-using-amazon-bedrock-agents-and-knowledge-bases.html)Una volta completata la distribuzione, puoi accedere all'applicazione di assistenza basata sulla chat utilizzando l'URL fornito nella scheda **Output** della console. CloudFormation | DevOps ingegnere, AWS DevOps |
### Pulisci tutte AWS le risorse della soluzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Rimuovi le AWS risorse. | Dopo aver testato la soluzione, per ripulire le risorse, esegui il comando`cdk destroy`. | AWS DevOps, DevOps ingegnere |
## Risorse correlate
**AWS documentazione**
+ Risorse Amazon Bedrock:
+ [Accesso al modello](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Parametri di inferenza per i modelli di base](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ [Agenti per Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/agents.html)
+ [Basi di conoscenza per Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/knowledge-base.html)
+ [Creazione di funzioni Lambda con Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ AWS CDK risorse:
+ [Inizia con AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Risoluzione dei AWS CDK problemi più comuni](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html)
+ [Lavorare con il AWS CDK in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Generative AI Application Builder attivo AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
**Altre risorse AWS **
+ [Motore vettoriale per Amazon Serverless OpenSearch ](https://aws.amazon.com/opensearch-service/serverless-vector-engine/)
**Altre risorse**
+ [LlamaIndex documentazione](https://docs.llamaindex.ai/en/stable/)
+ [Documentazione semplificata](https://docs.streamlit.io/)
## Informazioni aggiuntive
**Personalizza l'assistente basato sulla chat con i tuoi dati**
Per integrare i dati personalizzati per l'implementazione della soluzione, segui queste linee guida strutturate. Questi passaggi sono progettati per garantire un processo di integrazione semplice ed efficiente, che ti consenta di implementare la soluzione in modo efficace con i tuoi dati personalizzati.
*Per l'integrazione dei dati nella knowledge base*
**Preparazione dei dati**
1. Individua la `assets/knowledgebase_data_source/` cartella.
1. Posiziona il tuo set di dati in questa cartella.
**Modifiche alla configurazione**
1. Apri il file `cdk.json`.
1. Vai al `context/configure/paths/knowledgebase_file_name` campo, quindi aggiornalo di conseguenza.
1. Passa al `bedrock_instructions/knowledgebase_instruction` campo, quindi aggiornalo per riflettere accuratamente le sfumature e il contesto del nuovo set di dati.
*Per l'integrazione strutturale dei dati*
**Organizzazione dei dati**
1. All'interno della `assets/data_query_data_source/` directory, crea una sottodirectory, ad esempio`tabular_data`.
1. Inserisci il tuo set di dati strutturato (i formati accettabili includono CSV, JSON, ORC e Parquet) in questa sottocartella appena creata.
1. Se ti stai connettendo a un database esistente, aggiorna la funzione per connetterti `create_sql_engine()` `code/lambda/action-lambda/build_query_engine.py` al tuo database.
**Aggiornamenti della configurazione e del codice**
1. Nel `cdk.json` file, aggiorna il `context/configure/paths/athena_table_data_prefix` campo per allinearlo al nuovo percorso dei dati.
1. Esegui la revisione `code/lambda/action-lambda/dynamic_examples.csv` incorporando nuovi text-to-SQL esempi che corrispondono al tuo set di dati.
1. Esegui la revisione `code/lambda/action-lambda/prompt_templates.py` per rispecchiare gli attributi del tuo set di dati strutturato.
1. Nel `cdk.json` file, aggiorna il `context/configure/bedrock_instructions/action_group_description` campo per spiegare lo scopo e la funzionalità della funzione `Action group` Lambda.
1. Nel `assets/agent_api_schema/artifacts_schema.json` file, spiega le nuove funzionalità della tua funzione `Action group` Lambda.
*Aggiornamento generale*
Nel `cdk.json` file, nella `context/configure/bedrock_instructions/agent_instruction` sezione, fornisci una descrizione completa della funzionalità e dello scopo di progettazione previsti per l'agente Amazon Bedrock, tenendo conto dei nuovi dati integrati.
# Documenta le conoscenze istituzionali utilizzando input vocali utilizzando Amazon Bedrock e Amazon Transcribe
*Praveen Kumar Jeyarajan, Jundong Qiao, Rajiv Upadhyay e Megan Wu, Amazon Web Services*
## Riepilogo
L'acquisizione della conoscenza istituzionale è fondamentale per garantire il successo e la resilienza organizzativi. La conoscenza istituzionale rappresenta la saggezza, le intuizioni e le esperienze collettive accumulate dai dipendenti nel tempo, spesso di natura tacita e tramandate in modo informale. Questa ricchezza di informazioni comprende approcci unici, best practice e soluzioni a problemi complessi che potrebbero non essere documentati altrove. Formalizzando e documentando queste conoscenze, le aziende possono preservare la memoria istituzionale, promuovere l'innovazione, migliorare i processi decisionali e accelerare le curve di apprendimento per i nuovi dipendenti. Inoltre, promuove la collaborazione, dà potere alle persone e coltiva una cultura del miglioramento continuo. In definitiva, lo sfruttamento delle conoscenze istituzionali aiuta le aziende a utilizzare la loro risorsa più preziosa, l'intelligenza collettiva della forza lavoro, per affrontare le sfide, promuovere la crescita e mantenere il vantaggio competitivo in ambienti aziendali dinamici.
Questo modello spiega come acquisire le conoscenze istituzionali attraverso le registrazioni vocali dei dipendenti senior. Utilizza [Amazon Transcribe e Amazon](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html) [Bedrock per la documentazione e](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) la verifica sistematiche. Documentando queste conoscenze informali, puoi preservarle e condividerle con le successive coorti di dipendenti. Questo impegno sostiene l'eccellenza operativa e migliora l'efficacia dei programmi di formazione attraverso l'integrazione delle conoscenze pratiche acquisite attraverso l'esperienza diretta.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo
+ [Docker, installato](https://docs.docker.com/engine/install/)
+ AWS Cloud Development Kit (AWS CDK) versione 2.114.1 o successiva, [installato](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_tools) e [avviato](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_bootstrap) nelle regioni AWS `us-east-1` `us-west-2`
+ [AWS CDK Toolkit versione 2.114.1 o successiva, installato](https://docs.aws.amazon.com/cdk/v2/guide/cli.html)
+ [AWS Command Line Interface (AWS CLI)[,](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) installata e configurata](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
+ [Python versione 3.12 o successiva, installata](https://www.python.org/downloads/)
+ Autorizzazioni per creare risorse Amazon Transcribe, Amazon Bedrock, Amazon Simple Storage Service (Amazon S3) e AWS Lambda
**Limitazioni**
+ Questa soluzione viene distribuita su un singolo account AWS.
+ Questa soluzione può essere distribuita solo nelle regioni AWS in cui sono disponibili Amazon Bedrock e Amazon Transcribe. Per informazioni sulla disponibilità, consulta la documentazione per [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) e [Amazon Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html#tsc-regions).
+ I file audio devono essere in un formato supportato da Amazon Transcribe. Per un elenco dei formati supportati, consulta [Formati multimediali](https://docs.aws.amazon.com/transcribe/latest/dg/how-input.html#how-input-audio) nella documentazione Transcribe.
**Versioni del prodotto**
+ SDK AWS per Python (Boto3) versione 1.34.57 o successiva
+ LangChain versione 0.1.12 o successiva
## Architecture
L'architettura rappresenta un flusso di lavoro serverless su AWS. [AWS Step Functions orchestra le funzioni](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) Lambda per l'elaborazione audio, l'analisi del testo e la generazione di documenti. Il diagramma seguente mostra il flusso di lavoro Step Functions, noto anche come *macchina a stati*.
![\[Diagramma dell'architettura della macchina a stati Step Functions che genera un documento\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/f1e0106d-b046-4adc-9718-c299efb7b436/images/e90298ca-1b7f-4c3e-97bd-311a9d5a4997.png)
Ogni fase della macchina a stati è gestita da una funzione Lambda distinta. Di seguito sono riportati i passaggi del processo di generazione dei documenti:
1. La funzione `preprocess` Lambda convalida l'input passato a Step Functions ed elenca tutti i file audio presenti nel percorso della cartella URI Amazon S3 fornito. Le funzioni Lambda a valle del flusso di lavoro utilizzano l'elenco di file per convalidare, riepilogare e generare il documento.
1. La funzione `transcribe` Lambda utilizza Amazon Transcribe per convertire i file audio in trascrizioni di testo. Questa funzione Lambda è responsabile dell'avvio del processo di trascrizione e della trasformazione accurata del parlato in testo, che viene quindi memorizzato per l'elaborazione successiva.
1. La funzione `validate` Lambda analizza le trascrizioni del testo, determinando la pertinenza delle risposte alle domande iniziali. Utilizzando un modello linguistico di grandi dimensioni (LLM) tramite Amazon Bedrock, identifica e separa le risposte sull'argomento da quelle fuori tema.
1. La funzione `summarize` Lambda utilizza Amazon Bedrock per generare un riepilogo coerente e conciso delle risposte sull'argomento.
1. La funzione `generate` Lambda riunisce i riepiloghi in un documento ben strutturato. Può formattare il documento in base a modelli predefiniti e includere qualsiasi contenuto o dato aggiuntivo necessario.
1. Se una delle funzioni Lambda non funziona, ricevi una notifica e-mail tramite Amazon Simple Notification Service (Amazon SNS).
Durante questo processo, AWS Step Functions si assicura che ogni funzione Lambda venga avviata nella sequenza corretta. Questa macchina a stati ha la capacità di elaborazione parallela per migliorare l'efficienza. Un bucket Amazon S3 funge da archivio di archiviazione centrale, supportando il flusso di lavoro gestendo i vari formati multimediali e di documenti coinvolti.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) è un servizio completamente gestito che rende disponibili per l'uso modelli di base ad alte prestazioni (FMs) delle principali startup di intelligenza artificiale e di Amazon tramite un'API unificata.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di elaborazione che ti aiuta a eseguire codice senza dover fornire o gestire server. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di calcolo che utilizzi.
+ [Amazon Simple Notification Service (Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)) ti aiuta a coordinare e gestire lo scambio di messaggi tra editori e clienti, inclusi server Web e indirizzi e-mail.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) è un servizio di orchestrazione serverless che ti aiuta a combinare le funzioni AWS Lambda e altri servizi AWS per creare applicazioni aziendali critiche.
+ [Amazon Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/what-is.html) è un servizio di riconoscimento vocale automatico che utilizza modelli di apprendimento automatico per convertire l'audio in testo.
**Altri strumenti**
+ [LangChain](https://python.langchain.com/docs/get_started/introduction/)è un framework per lo sviluppo di applicazioni basate su modelli linguistici di grandi dimensioni (LLMs).
**Archivio di codice**
Il codice per questo pattern è disponibile nel GitHub [genai-knowledge-capture](https://github.com/aws-samples/genai-knowledge-capture)repository.
L'archivio del codice contiene i seguenti file e cartelle:
+ `assets`cartella: le risorse statiche per la soluzione, ad esempio il diagramma di architettura e il set di dati pubblico
+ `code/lambdas`folder — Il codice Python per tutte le funzioni Lambda
+ `code/lambdas/generate`folder - Il codice Python che genera un documento dai dati riepilogati nel bucket S3
+ `code/lambdas/preprocess`folder - Il codice Python che elabora gli input per la macchina a stati Step Functions
+ `code/lambdas/summarize`folder - Il codice Python che riassume i dati trascritti utilizzando il servizio Amazon Bedrock
+ `code/lambdas/transcribe`folder - Il codice Python che converte i dati vocali (file audio) in testo utilizzando Amazon Transcribe
+ `code/lambdas/validate`folder - Il codice Python che verifica se tutte le risposte riguardano lo stesso argomento
+ `code/code_stack.py`— Il file di costruzione in Python del CDK AWS utilizzato per creare risorse AWS
+ `app.py`— Il file Python dell'app AWS CDK utilizzato per distribuire le risorse AWS nell'account AWS di destinazione
+ `requirements.txt`— L'elenco di tutte le dipendenze Python che devono essere installate per il CDK AWS
+ `cdk.json`— Il file di input per fornire i valori necessari per creare risorse
## Best practice
L'esempio di codice fornito è destinato esclusivamente a scopi proof-of-concept (PoC) o pilota. Se desideri portare la soluzione in produzione, utilizza le seguenti best practice:
+ Abilita la registrazione degli [accessi ad Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html)
+ Abilita i log di [flusso VPC](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html)
## Epiche
### Configura le credenziali AWS sulla tua workstation locale
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esporta le variabili per l'account e la regione AWS. | Per fornire le credenziali AWS per il CDK AWS utilizzando variabili di ambiente, esegui i seguenti comandi.export CDK_DEFAULT_ACCOUNT=<12-digit AWS account number>
export CDK_DEFAULT_REGION=
| AWS DevOps, DevOps ingegnere |
| Configura il profilo denominato AWS CLI. | Per configurare il profilo denominato AWS CLI per l'account, segui le istruzioni in [Configurazione e impostazioni del file di credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). | AWS DevOps, DevOps ingegnere |
### Configurare l'ambiente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona il repository sulla tua workstation locale. | Per clonare il [genai-knowledge-capture](https://github.com/aws-samples/genai-knowledge-capture)repository, esegui il seguente comando nel tuo terminale.git clone https://github.com/aws-samples/genai-knowledge-capture
| AWS DevOps, DevOps ingegnere |
| (Facoltativo) Sostituisci i file audio. | Per personalizzare l'applicazione di esempio in modo da incorporare i tuoi dati, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps ingegnere |
| Configura l'ambiente virtuale Python. | Per configurare l'ambiente virtuale Python, esegui i seguenti comandi.cd genai-knowledge-capture
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
| AWS DevOps, DevOps ingegnere |
| Sintetizza il codice CDK AWS. | Per convertire il codice in una configurazione CloudFormation dello stack AWS, esegui il comando seguente.cdk synth
| AWS DevOps, DevOps ingegnere |
### Configura e distribuisci la soluzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Fornire l'accesso al modello di base. | Abilita l'accesso al modello Anthropic Claude 3 Sonnet per il tuo account AWS. Per istruzioni, consulta [Aggiungere l'accesso al modello](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#model-access-add) nella documentazione di Bedrock. | AWS DevOps |
| Distribuisci risorse nell'account. | Per distribuire risorse nell'account AWS utilizzando il CDK AWS, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps ingegnere |
| Iscriviti all'argomento Amazon SNS. | Per iscriverti all'argomento di notifica di Amazon SNS, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | Informazioni generali su AWS |
### Test della soluzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Avvia la macchina a stati. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | Sviluppatore di app, General AWS |
### Pulisci tutte le risorse AWS nella soluzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Rimuovi le risorse AWS. | Dopo aver testato la soluzione, pulisci le risorse:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/document-institutional-knowledge-from-voice-inputs-by-using-amazon-bedrock-and-amazon-transcribe.html) | AWS DevOps, DevOps ingegnere |
## Risorse correlate
**Documentazione AWS**
+ Risorse Amazon Bedrock:
+ [Accesso al modello](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html)
+ [Parametri di inferenza per i modelli di base](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html)
+ Risorse CDK AWS:
+ [Inizia a usare il CDK AWS](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)
+ [Lavorare con il CDK AWS in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Risoluzione dei problemi più comuni di AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/troubleshooting.html)
+ [Comandi Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-commands)
+ Risorse AWS Step Functions:
+ [Guida introduttiva a AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started-with-sfn.html)
+ [Risoluzione dei problemi](https://docs.aws.amazon.com/step-functions/latest/dg/troubleshooting.html)
+ [Creazione di funzioni Lambda con Python](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ [Generative AI Application Builder su AWS](https://docs.aws.amazon.com/solutions/latest/generative-ai-application-builder-on-aws/solution-overview.html)
**Altre risorse**
+ [LangChain documentazione](https://python.langchain.com/docs/get_started/introduction)
# Genera consigli personalizzati e riclassificati con Amazon Personalize
*Mason Cahill, Matthew Chasse e Tayo Olajide, Amazon Web Services*
## Riepilogo
Questo modello mostra come utilizzare Amazon Personalize per generare consigli personalizzati, inclusi consigli riclassificati, per i tuoi utenti in base all'acquisizione di dati di interazione utente in tempo reale da tali utenti. Lo scenario di esempio utilizzato in questo modello si basa su un sito Web dedicato all'adozione di animali domestici che genera consigli per gli utenti in base alle loro interazioni (ad esempio, quali animali domestici visita un utente). Seguendo lo scenario di esempio, impari a utilizzare Amazon Kinesis Data Streams per importare dati di interazione, AWS Lambda per generare consigli e riclassificarli e Amazon Data Firehose per archiviare i dati in un bucket Amazon Simple Storage Service (Amazon S3). Imparerai anche a usare AWS Step Functions per creare una macchina a stati che gestisca la versione della soluzione (ovvero un modello addestrato) che genera i tuoi consigli.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un [account AWS](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) attivo con un AWS Cloud Development Kit ([AWS CDK) avviato](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)
+ [AWS Command Line Interface (AWS CLI) con credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) configurate
+ [Python 3.9](https://www.python.org/downloads/release/python-390/)
**Versioni del prodotto**
+ Python 3.9
+ AWS CDK 2.23.0 o versione successiva
+ AWS CLI 2.7.27 o versione successiva
## Architecture
**Stack tecnologico**
+ Amazon Data Firehose
+ Flusso di dati Amazon Kinesis
+ Amazon Personalize
+ Amazon Simple Storage Service (Amazon S3)
+ AWS Cloud Development Kit (CDK AWS)
+ Interfaccia a riga di comando di AWS (CLI AWS)
+ AWS Lambda
+ AWS Step Functions
**Architettura Target**
Il diagramma seguente illustra una pipeline per l'acquisizione di dati in tempo reale in Amazon Personalize. La pipeline utilizza quindi tali dati per generare consigli personalizzati e riclassificati per gli utenti.
![\[Architettura di inserimento dati per Amazon Personalize\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/42eb193b-2347-408a-8b25-46beeb3b29ca/images/786dbd56-7d7f-41bb-90f6-d4485d73fe15.png)
Il diagramma mostra il flusso di lavoro seguente:
1. Kinesis Data Streams acquisisce i dati degli utenti in tempo reale (ad esempio, eventi come animali domestici visitati) per l'elaborazione da parte di Lambda e Firehose.
1. Una funzione Lambda elabora i record di Kinesis Data Streams ed effettua una chiamata API per aggiungere l'interazione dell'utente nel record a un tracker di eventi in Amazon Personalize.
1. Una regola basata sul tempo richiama una macchina a stati Step Functions e genera nuove versioni della soluzione per i modelli di raccomandazione e riclassificazione utilizzando gli eventi dell'event tracker in Amazon Personalize.
1. Le [campagne](https://docs.aws.amazon.com/personalize/latest/dg/campaigns.html) Amazon Personalize vengono aggiornate dalla macchina a stati per utilizzare la nuova versione della [soluzione](https://docs.aws.amazon.com/personalize/latest/dg/creating-a-solution-version.html).
1. Lambda riordina l'elenco degli articoli consigliati avviando la campagna di riclassificazione di Amazon Personalize.
1. Lambda recupera l'elenco degli articoli consigliati chiamando la campagna di consigli di Amazon Personalize.
1. Firehose salva gli eventi in un bucket S3 dove è possibile accedervi come dati storici.
## Tools (Strumenti)
**Strumenti AWS**
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html) è un framework di sviluppo software che aiuta a definire e fornire l'infrastruttura cloud AWS in codice.
+ [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento open source che ti aiuta a interagire con i servizi AWS tramite comandi nella tua shell a riga di comando.
+ [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) ti aiuta a distribuire [dati di streaming](https://aws.amazon.com/streaming-data/) in tempo reale ad altri servizi AWS, endpoint HTTP personalizzati ed endpoint HTTP di proprietà di provider di servizi terzi supportati.
+ [Amazon Kinesis Data](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) Streams ti aiuta a raccogliere ed elaborare grandi flussi di record di dati in tempo reale.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di elaborazione che ti aiuta a eseguire codice senza dover fornire o gestire server. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di calcolo che utilizzi.
+ [Amazon Personalize](https://docs.aws.amazon.com/personalize/latest/dg/what-is-personalize.html) è un servizio di machine learning (ML) completamente gestito che ti aiuta a generare consigli sugli articoli per i tuoi utenti in base ai tuoi dati.
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) è un servizio di orchestrazione senza server che ti aiuta a combinare funzioni Lambda e altri servizi AWS per creare applicazioni aziendali critiche.
**Altri strumenti**
+ [pytest](https://docs.pytest.org/en/7.2.x/index.html) è un framework Python per scrivere test piccoli e leggibili.
+ [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico.
**Codice**
Il codice per questo modello è disponibile nel repository GitHub [Animal](https://github.com/aws-samples/personalize-pet-recommendations) Recommender. Puoi utilizzare il CloudFormation modello AWS di questo repository per distribuire le risorse per la soluzione di esempio.
**Nota**
Le versioni della soluzione Amazon Personalize, l'event tracker e le campagne sono supportate da [risorse personalizzate](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-custom-resources.html) (all'interno dell'infrastruttura) che si espandono su risorse native. CloudFormation
## Epiche
### Crea l'infrastruttura
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un ambiente Python isolato. | **Configurazione Mac/Linux**[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/generate-personalized-and-re-ranked-recommendations-using-amazon-personalize.html)**Configurazione di Windows**Per creare manualmente un ambiente virtuale, esegui il `% .venv\Scripts\activate.bat` comando dal tuo terminale. | DevOps ingegnere |
| Sintetizza il modello. CloudFormation | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/generate-personalized-and-re-ranked-recommendations-using-amazon-personalize.html)Nel passaggio 2, `CDK_ENVIRONMENT` fa riferimento al `config/{env}.yml` file. | DevOps ingegnere |
| Implementa risorse e crea infrastrutture. | Per distribuire le risorse della soluzione, esegui il `./deploy.sh` comando dal tuo terminale.Questo comando installa le dipendenze Python richieste. Uno script Python crea un bucket S3 e una chiave AWS Key Management Service (AWS KMS), quindi aggiunge i dati iniziali per le creazioni iniziali del modello. Infine, lo script viene eseguito per creare l'infrastruttura rimanente`cdk deploy`.L'addestramento iniziale del modello avviene durante la creazione dello stack. Il completamento della creazione dello stack può richiedere fino a due ore. | DevOps ingegnere |
## Risorse correlate
+ [Consigliere per animali](https://github.com/aws-samples/personalize-pet-recommendations) () GitHub
+ [Documentazione di riferimento per AWS CDK](https://docs.aws.amazon.com/cdk/api/v2/)
+ [Documentazione Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
+ [Ottimizza i consigli personalizzati per una metrica aziendale a tua scelta con Amazon](https://aws.amazon.com/blogs/machine-learning/optimize-personalized-recommendations-for-a-business-metric-of-your-choice-with-amazon-personalize/) Personalize (AWS Machine Learning Blog)
## Informazioni aggiuntive
**Esempi di payload e risposte**
*Raccomandazione: funzione Lambda*
Per recuperare i consigli, invia una richiesta alla funzione Lambda delle raccomandazioni con un payload nel seguente formato:
```
{
"userId": "3578196281679609099",
"limit": 6
}
```
Il seguente esempio di risposta contiene un elenco di gruppi di animali:
```
[{"id": "1-domestic short hair-1-1"},
{"id": "1-domestic short hair-3-3"},
{"id": "1-domestic short hair-3-2"},
{"id": "1-domestic short hair-1-2"},
{"id": "1-domestic short hair-3-1"},
{"id": "2-beagle-3-3"},
```
Se si omette il `userId` campo, la funzione restituisce raccomandazioni generali.
*Riclassificazione della funzione Lambda*
Per utilizzare la riclassificazione, invia una richiesta alla funzione di riclassificazione Lambda. Il payload contiene tutti gli elementi da riclassificare e i IDs relativi metadati. `userId` I seguenti dati di esempio utilizzano le classi Oxford Pets for `animal_species_id` (1=cat, 2=dog) e i numeri interi 1-5 per e: `animal_age_id` `animal_size_id`
```
{
"userId":"12345",
"itemMetadataList":[
{
"itemId":"1",
"animalMetadata":{
"animal_species_id":"2",
"animal_primary_breed_id":"Saint_Bernard",
"animal_size_id":"3",
"animal_age_id":"2"
}
},
{
"itemId":"2",
"animalMetadata":{
"animal_species_id":"1",
"animal_primary_breed_id":"Egyptian_Mau",
"animal_size_id":"1",
"animal_age_id":"1"
}
},
{
"itemId":"3",
"animalMetadata":{
"animal_species_id":"2",
"animal_primary_breed_id":"Saint_Bernard",
"animal_size_id":"3",
"animal_age_id":"2"
}
}
]
}
```
La funzione Lambda riclassifica questi articoli e quindi restituisce un elenco ordinato che include l'articolo IDs e la risposta diretta di Amazon Personalize. Questo è un elenco classificato dei gruppi di animali a cui appartengono gli articoli e del relativo punteggio. Amazon Personalize utilizza le ricette di [personalizzazione degli utenti](https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-new-item-USER_PERSONALIZATION.html) e di [classificazione personalizzata](https://docs.aws.amazon.com/personalize/latest/dg/native-recipe-search.html) per includere un punteggio per ogni articolo nei consigli. Questi punteggi rappresentano la certezza relativa di Amazon Personalize in merito all'articolo successivo che l'utente sceglierà. I punteggi più alti rappresentano una maggiore certezza.
```
{
"ranking":[
"1",
"3",
"2"
],
"personalizeResponse":{
"ResponseMetadata":{
"RequestId":"a2ec0417-9dcd-4986-8341-a3b3d26cd694",
"HTTPStatusCode":200,
"HTTPHeaders":{
"date":"Thu, 16 Jun 2022 22:23:33 GMT",
"content-type":"application/json",
"content-length":"243",
"connection":"keep-alive",
"x-amzn-requestid":"a2ec0417-9dcd-4986-8341-a3b3d26cd694"
},
"RetryAttempts":0
},
"personalizedRanking":[
{
"itemId":"2-Saint_Bernard-3-2",
"score":0.8947961
},
{
"itemId":"1-Siamese-1-1",
"score":0.105204
}
],
"recommendationId":"RID-d97c7a87-bd4e-47b5-a89b-ac1d19386aec"
}
}
```
*Carico utile Amazon Kinesis*
Il payload da inviare ad Amazon Kinesis ha il seguente formato:
```
{
"Partitionkey": "randomstring",
"Data": {
"userId": "12345",
"sessionId": "sessionId4545454",
"eventType": "DetailView",
"animalMetadata": {
"animal_species_id": "1",
"animal_primary_breed_id": "Russian_Blue",
"animal_size_id": "1",
"animal_age_id": "2"
},
"animal_id": "98765"
}
}
```
**Nota**
Il `userId` campo viene rimosso per un utente non autenticato.
# Semplifica i flussi di lavoro di machine learning dallo sviluppo locale agli esperimenti scalabili utilizzando SageMaker AI e Hydra
*David Sauerwein, Marco Geiger e Julian Ferdinand Grueber, Amazon Web Services*
## Riepilogo
Questo modello fornisce un approccio unificato alla configurazione e all'esecuzione di algoritmi di machine learning (ML) dai test locali alla produzione su Amazon AI. SageMaker Gli algoritmi ML sono al centro di questo modello, ma il suo approccio si estende all'ingegneria delle funzionalità, all'inferenza e a intere pipeline ML. Questo modello dimostra la transizione dallo sviluppo di script locali ai lavori di formazione sull' SageMaker intelligenza artificiale attraverso un esempio di caso d'uso.
Un tipico flusso di lavoro ML consiste nello sviluppare e testare soluzioni su un computer locale, eseguire esperimenti su larga scala (ad esempio, con parametri diversi) nel cloud e distribuire la soluzione approvata nel cloud. Quindi, la soluzione implementata deve essere monitorata e gestita. Senza un approccio unificato a questo flusso di lavoro, gli sviluppatori devono spesso rifattorizzare il codice in ogni fase. Se la soluzione dipende da un gran numero di parametri che potrebbero cambiare in qualsiasi fase di questo flusso di lavoro, può diventare sempre più difficile rimanere organizzati e coerenti.
Questo modello affronta queste sfide. Innanzitutto, elimina la necessità di rifattorizzare il codice tra gli ambienti fornendo un flusso di lavoro unificato che rimane coerente indipendentemente dal fatto che venga eseguito su macchine locali, in contenitori o sull'intelligenza artificiale. SageMaker In secondo luogo, semplifica la gestione dei parametri tramite il sistema di configurazione di Hydra, in cui i parametri sono definiti in file di configurazione separati che possono essere facilmente modificati e combinati, con registrazione automatica della configurazione di ogni esecuzione. [Per ulteriori dettagli su come questo modello affronta queste sfide, consulta Informazioni aggiuntive.](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-additional)
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS
+ Un [ruolo utente AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) (IAM) per l'implementazione e l'avvio dei lavori di formazione sull' SageMaker intelligenza artificiale
+ AWS Command Line Interface [(AWS CLI) versione 2.0 o successiva [installata e configurata](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
+ Installata la versione 1.8 o successiva di [Poetry](https://python-poetry.org/), ma precedente alla 2.0
+ [Docker installato](https://www.docker.com/)
+ [Python versione 3.10.x](https://www.python.org/downloads/release/python-31011/)
**Limitazioni**
+ Il codice attualmente si rivolge solo ai lavori di formazione sull' SageMaker intelligenza artificiale. Estenderlo ai processi di elaborazione e a intere pipeline di SageMaker intelligenza artificiale è semplice.
+ Per una configurazione SageMaker AI completamente prodotta, è necessario disporre di ulteriori dettagli. Alcuni esempi potrebbero essere le chiavi custom AWS Key Management Service (AWS KMS) per l'elaborazione e lo storage o le configurazioni di rete. È inoltre possibile configurare queste opzioni aggiuntive utilizzando Hydra in una sottocartella dedicata della cartella. `config`
+ Alcune Servizi AWS non sono disponibili in tutte. Regioni AWS Per la disponibilità regionale, vedi [AWS Servizi per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
## Architecture
Il diagramma seguente illustra l'architettura della soluzione.
![\[Flusso di lavoro per creare ed eseguire corsi di formazione SageMaker sull'intelligenza artificiale o lavori HPO.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/1db57484-f85c-49a6-b870-471dade02b26/images/d80e7474-a975-4d92-8f66-2d34e33053fd.png)
Il diagramma mostra il flusso di lavoro seguente:
1. Il data scientist può eseguire iterazioni sull'algoritmo su piccola scala in un ambiente locale, regolare i parametri e testare rapidamente lo script di addestramento senza bisogno di Docker o AI. SageMaker (Per maggiori dettagli, consulta l'attività «Esegui localmente per test rapidi» in [Epics](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-epics).)
1. Una volta soddisfatto dell'algoritmo, il data scientist crea e invia l'immagine Docker al repository Amazon Elastic Container Registry (Amazon ECR) denominato. `hydra-sm-artifact` [(Per maggiori dettagli, consulta «Esegui flussi di lavoro sull' SageMaker intelligenza artificiale» in Epics.)](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-epics)
1. Il data scientist avvia lavori di formazione sull' SageMaker intelligenza artificiale o lavori di ottimizzazione degli iperparametri (HPO) utilizzando script Python. Per i normali lavori di formazione, la configurazione modificata viene scritta nel bucket Amazon Simple Storage Service (Amazon S3) denominato. `hydra-sample-config` Per i lavori HPO, viene applicato il set di configurazione predefinito che si trova nella `config` cartella.
1. Il processo di formazione SageMaker AI estrae l'immagine Docker, legge i dati di input dal bucket Amazon S3 e recupera la configurazione dal bucket `hydra-sample-data` Amazon S3 o utilizza la configurazione predefinita. `hydra-sample-config` Dopo l'addestramento, il processo salva i dati di output nel bucket Amazon S3. `hydra-sample-data`
**Automazione e scalabilità**
+ [Per la formazione, la riqualificazione o l'inferenza automatizzate, puoi integrare il AWS CLI codice con servizi come [AWS Lambda[AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html), o Amazon. EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html)
+ La scalabilità può essere ottenuta modificando le configurazioni, ad esempio le dimensioni, o aggiungendo configurazioni per la formazione distribuita.
## Tools (Strumenti)
**Servizi AWS**
+ [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ti aiuta a configurare AWS le risorse, fornirle in modo rapido e coerente e gestirle durante tutto il loro ciclo di vita tra e. Account AWS Regioni AWS
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che consente di interagire Servizi AWS tramite comandi nella shell della riga di comando. Per questo modello, AWS CLI è utile sia per la configurazione iniziale delle risorse che per il test.
+ [Amazon Elastic Container Registry (Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) è un servizio di registro di immagini di container gestito sicuro, scalabile e affidabile.
+ [Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/?id=docs_gateway) è un servizio di machine learning (ML) gestito che ti aiuta a creare e addestrare modelli di machine learning per poi distribuirli in un ambiente ospitato pronto per la produzione. SageMaker AI Training è un servizio di machine learning completamente gestito all'interno dell' SageMaker intelligenza artificiale che consente la formazione di modelli di machine learning su larga scala. Lo strumento è in grado di gestire le esigenze computazionali dei modelli di formazione in modo efficiente, utilizzando la scalabilità e l'integrazione integrate con altri. Servizi AWS SageMaker AI Training supporta anche algoritmi e contenitori personalizzati, rendendolo flessibile per un'ampia gamma di flussi di lavoro ML.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
**Altri strumenti**
+ [Docker](https://www.docker.com/) è un insieme di prodotti Platform as a Service (PaaS) che utilizzano la virtualizzazione a livello di sistema operativo per fornire software in container. È stato utilizzato secondo questo schema per garantire ambienti coerenti in varie fasi, dallo sviluppo alla distribuzione, e per impacchettare dipendenze e codice in modo affidabile. La containerizzazione di Docker ha consentito una facile scalabilità e il controllo delle versioni in tutto il flusso di lavoro.
+ [Hydra](https://hydra.cc/) è uno strumento di gestione della configurazione che offre flessibilità per la gestione di più configurazioni e la gestione dinamica delle risorse. È fondamentale per la gestione delle configurazioni degli ambienti e consente un'implementazione senza interruzioni in ambienti diversi. [Per ulteriori dettagli su Hydra, vedere Informazioni aggiuntive.](#streamline-machine-learning-workflows-by-using-amazon-sagemaker-additional)
+ [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico. Python è stato usato per scrivere il codice ML e il flusso di lavoro di distribuzione.
+ [Poetry](https://python-poetry.org/) è uno strumento per la gestione delle dipendenze e la creazione di pacchetti in Python.
**Deposito di codice**
Il codice per questo pattern è disponibile nel repository GitHub [configuring-sagemaker-training-jobs-with-hydra](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra).
## Best practice
+ Scegli un ruolo IAM per l'implementazione e l'avvio dei lavori di formazione sull' SageMaker intelligenza artificiale che segua il principio del privilegio minimo e concedi le autorizzazioni minime necessarie per eseguire un'attività. Per ulteriori informazioni, consulta le [best practice relative alla [concessione dei privilegi minimi](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#grant-least-priv) e alla sicurezza](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) nella documentazione IAM.
+ Utilizza credenziali temporanee per accedere al ruolo IAM nel terminale.
## Epiche
### Configura l'ambiente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea e attiva l'ambiente virtuale. | Per creare e attivare l'ambiente virtuale, esegui i seguenti comandi nella radice del repository:poetry install
poetry shell
| Informazioni generali su AWS |
| Implementa l'infrastruttura. | Per distribuire l'infrastruttura utilizzando CloudFormation, esegui il comando seguente:aws cloudformation deploy --template-file infra/hydra-sagemaker-setup.yaml --stack-name hydra-sagemaker-setup --capabilities CAPABILITY_NAMED_IAM
| General AWS, DevOps ingegnere |
| Scarica i dati di esempio. | Per scaricare i dati di input da [openml](https://www.openml.org/) sul computer locale, esegui il seguente comando:python scripts/download_data.py
| Informazioni generali su AWS |
| Esegui localmente per test rapidi. | Per eseguire il codice di addestramento localmente per il test, esegui il comando seguente:python mypackage/train.py data.train_data_path=data/train.csv evaluation.base_dir_path=data
I registri di tutte le esecuzioni vengono archiviati in base alla data di esecuzione in una cartella denominata. `outputs` [Per ulteriori informazioni, consulta la sezione «Output» nel GitHub repository.](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra)È inoltre possibile eseguire più corsi di formazione in parallelo, con parametri diversi, utilizzando la `--multirun` funzionalità. Per maggiori dettagli, consulta la documentazione di [Hydra](https://hydra.cc/docs/tutorials/basic/running_your_app/multi-run/). | Data Scientist |
### Esegui flussi di lavoro sull'intelligenza artificiale SageMaker
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Imposta le variabili di ambiente. | Per eseguire il tuo lavoro sull' SageMaker intelligenza artificiale, imposta le seguenti variabili di ambiente, fornendo il tuo ID Regione AWS e il tuo Account AWS ID:export ECR_REPO_NAME=hydra-sm-artifact
export image_tag=latest
export AWS_REGION="" # for instance, us-east-1
export ACCOUNT_ID=""
export BUCKET_NAME_DATA=hydra-sample-data-$ACCOUNT_ID
export BUCKET_NAME_CONFIG=hydra-sample-config-$ACCOUNT_ID
export AWS_DEFAULT_REGION=$AWS_REGION
export ROLE_ARN=arn:aws:iam::${ACCOUNT_ID}:role/hydra-sample-sagemaker
export INPUT_DATA_S3_PATH=s3://$BUCKET_NAME_DATA/hydra-on-sm/input/
export OUTPUT_DATA_S3_PATH=s3://$BUCKET_NAME_DATA/hydra-on-sm/output/
| Informazioni generali su AWS |
| Crea e invia un'immagine Docker. | Per creare l'immagine Docker e inviarla al repository Amazon ECR, esegui il seguente comando:chmod +x scripts/create_and_push_image.sh
scripts/create_and_push_image.sh $ECR_REPO_NAME $image_tag $AWS_REGION $ACCOUNT_ID
Questa attività presuppone che tu disponga di credenziali valide nel tuo ambiente. L'immagine Docker viene inviata al repository Amazon ECR specificato nella variabile di ambiente nell'attività precedente e viene utilizzata per attivare il contenitore SageMaker AI in cui verrà eseguito il processo di formazione. | Ingegnere ML, General AWS |
| Copia i dati di input su Amazon S3. | Il processo di formazione sull' SageMaker intelligenza artificiale deve raccogliere i dati di input. Per copiare i dati di input nel bucket Amazon S3 per i dati, esegui il seguente comando: aws s3 cp data/train.csv "${INPUT_DATA_S3_PATH}train.csv" | Ingegnere dei dati, General AWS |
| Invia lavori di formazione sull' SageMaker intelligenza artificiale. | Per semplificare l'esecuzione degli script, specifica i parametri di configurazione predefiniti nel `default.yaml` file. Oltre a garantire la coerenza tra le esecuzioni, questo approccio offre anche la flessibilità necessaria per sostituire facilmente le impostazioni predefinite, se necessario. Fai riferimento al file di esempio seguente:python scripts/start_sagemaker_training_job.py sagemaker.role_arn=$ROLE_ARN sagemaker.config_s3_bucket=$BUCKET_NAME_CONFIG sagemaker.input_data_s3_path=$INPUT_DATA_S3_PATH sagemaker.output_data_s3_path=$OUTPUT_DATA_S3_PATH
| General AWS, ingegnere ML, Data scientist |
| Esegui l'ottimizzazione degli iperparametri SageMaker AI. | L'esecuzione dell'ottimizzazione degli iperparametri SageMaker AI è simile all'invio di un lavoro di formazione AII. SageMaker [Tuttavia, lo script di esecuzione differisce in alcuni aspetti importanti, come si può vedere nel file start\$1sagemaker\$1hpo\$1job.py.](https://github.com/aws-samples/configuring-sagemaker-training-jobs-with-hydra/blob/main/scripts/start_sagemaker_hpo_job.py) Gli iperparametri da ottimizzare devono essere trasmessi attraverso il payload boto3, non attraverso un canale di accesso al processo di formazione.Per avviare il processo di ottimizzazione degli iperparametri (HPO), esegui i seguenti comandi:python scripts/start_sagemaker_hpo_job.py sagemaker.role_arn=$ROLE_ARN sagemaker.config_s3_bucket=$BUCKET_NAME_CONFIG sagemaker.input_data_s3_path=$INPUT_DATA_S3_PATH sagemaker.output_data_s3_path=$OUTPUT_DATA_S3_PATH
| Data Scientist |
## Risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| Token scaduto | Esporta nuove credenziali AWS . |
| Mancanza di autorizzazioni IAM | Assicurati di esportare le credenziali di un ruolo IAM che disponga di tutte le autorizzazioni IAM necessarie per implementare il CloudFormation modello e avviare i lavori di formazione sull' SageMaker IA. |
## Risorse correlate
+ [Addestra un modello con Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) (AWS documentazione)
+ [Che cos'è l'ottimizzazione degli iperparametri?](https://aws.amazon.com/what-is/hyperparameter-tuning/#:~:text=Hyperparameter%20tuning%20allows%20data%20scientists,the%20model%20as%20a%20hyperparameter.)
## Informazioni aggiuntive
Questo modello affronta le seguenti sfide:
**Coerenza dallo sviluppo locale alla distribuzione su larga scala**: con questo modello, gli sviluppatori possono utilizzare lo stesso flusso di lavoro, indipendentemente dal fatto che utilizzino script Python locali, eseguano contenitori Docker locali, conducano grandi esperimenti SageMaker sull'intelligenza artificiale o implementino in produzione sull'intelligenza artificiale. SageMaker Questa coerenza è importante per i seguenti motivi:
+ **Iterazione più** rapida: consente una rapida sperimentazione locale senza la necessità di grandi aggiustamenti durante la scalabilità.
+ **Nessun refactoring**: il passaggio a esperimenti più ampi sull' SageMaker intelligenza artificiale è semplice e non richiede alcuna revisione della configurazione esistente.
+ **Miglioramento continuo**: lo sviluppo di nuove funzionalità e il miglioramento continuo dell'algoritmo sono semplici perché il codice rimane lo stesso in tutti gli ambienti.
**Gestione della configurazione**: questo modello utilizza [Hydra](https://hydra.cc/), uno strumento di gestione della configurazione, per fornire i seguenti vantaggi:
+ I parametri sono definiti nei file di configurazione, separati dal codice.
+ Diversi set di parametri possono essere scambiati o combinati facilmente.
+ Il tracciamento degli esperimenti è semplificato perché la configurazione di ogni esecuzione viene registrata automaticamente.
+ Gli esperimenti sul cloud possono utilizzare la stessa struttura di configurazione delle esecuzioni locali, garantendo la coerenza.
Con Hydra, puoi gestire la configurazione in modo efficace, abilitando le seguenti funzionalità:
+ **Dividi le configurazioni**: suddividi le configurazioni del progetto in parti più piccole e gestibili che possono essere modificate indipendentemente. Questo approccio semplifica la gestione di progetti complessi.
+ **Modifica facilmente i valori predefiniti**: modifica rapidamente le configurazioni di base, semplificando la sperimentazione di nuove idee.
+ **Allinea gli input della CLI e i file di configurazione: combina facilmente gli input** della riga di comando con i file di configurazione. Questo approccio riduce il disordine e la confusione, rendendo il progetto più gestibile nel tempo.
# Traduci il linguaggio naturale in query DSL for OpenSearch ed Elasticsearch
*Tabby Ward, Nicholas Switzer e Breanne Warner, Amazon Web Services*
## Riepilogo
Questo modello dimostra come utilizzare modelli linguistici di grandi dimensioni (LLMs) per convertire le query in linguaggio naturale in linguaggio specifico del dominio di query (query DSL), il che semplifica l'interazione degli utenti con servizi di ricerca come Elasticsearch senza una conoscenza approfondita del linguaggio di query. OpenSearch Questa risorsa è particolarmente utile per sviluppatori e data scientist che desiderano potenziare le applicazioni basate sulla ricerca con funzionalità di interrogazione in linguaggio naturale, migliorando in ultima analisi l'esperienza utente e la funzionalità di ricerca.
Il modello illustra le tecniche per una progettazione tempestiva, il perfezionamento iterativo e l'incorporazione di conoscenze specialistiche, tutte fondamentali nella generazione di dati sintetici. Sebbene questo approccio si concentri principalmente sulla conversione delle query, dimostra implicitamente il potenziale dell'aumento dei dati e della produzione scalabile di dati sintetici. Questa base potrebbe essere estesa a attività più complete di generazione di dati sintetici, per evidenziare la potenza del collegamento tra input non strutturati LLMs in linguaggio naturale e output strutturati e specifici dell'applicazione.
Questa soluzione non prevede strumenti di migrazione o implementazione nel senso tradizionale. Si concentra invece sulla dimostrazione di un proof of concept (PoC) per convertire le query in linguaggio naturale in query DSL utilizzando. LLMs
+ Il modello utilizza un notebook Jupyter come step-by-step guida per la configurazione dell'ambiente e l'implementazione della conversione. text-to-query
+ Utilizza Amazon Bedrock per accedere LLMs, che è fondamentale per interpretare il linguaggio naturale e generare query appropriate.
+ La soluzione è progettata per funzionare con Amazon OpenSearch Service. Puoi seguire un processo simile per Elasticsearch e le query generate potrebbero essere potenzialmente adattate a motori di ricerca simili.
[Query DSL](https://opensearch.org/docs/latest/query-dsl/) è un linguaggio di ricerca flessibile basato su JSON che viene utilizzato per costruire query complesse sia in Elasticsearch che. OpenSearch Consente di specificare le query nei parametri di query delle operazioni di ricerca e supporta vari tipi di query. Una query DSL include query leaf e query composte. Le query Leaf cercano valori specifici in determinati campi e comprendono query full-text, a livello di termine, geografiche, di join, span e specializzate. Le query composte fungono da involucro per più clausole leaf o composte e combinano i risultati o ne modificano il comportamento. Query DSL supporta la creazione di ricerche sofisticate, che vanno da query semplici e corrispondenti a query complesse con più clausole che producono risultati altamente specifici. Query DSL è particolarmente utile per i progetti che richiedono funzionalità di ricerca avanzate, una costruzione flessibile delle query e strutture di query basate su JSON.
Questo modello utilizza tecniche come few-shot prompting, system prompt, output strutturato, concatenamento dei prompt, fornitura di contesto e istruzioni specifiche per le attività per la conversione DSL. text-to-query [Per le definizioni e gli esempi di queste tecniche, consultate la sezione Informazioni aggiuntive.](#translate-natural-language-query-dsl-opensearch-elasticsearch-additional)
## Prerequisiti e limitazioni
**Prerequisiti**
Per utilizzare efficacemente il notebook Jupyter per convertire le query in linguaggio naturale in query DSL, è necessario:
+ **Familiarità** con i notebook Jupyter. Conoscenze di base su come navigare ed eseguire codice in un ambiente notebook Jupyter.
+ Ambiente **Python**. Un ambiente Python funzionante, preferibilmente Python 3.x, con le librerie necessarie installate.
+ **Elasticsearch** o conoscenza. OpenSearch Conoscenza di base di Elasticsearch o OpenSearch, compresa la sua architettura e come eseguire le query.
+ **Account AWS**. Un utente attivo Account AWS per accedere ad Amazon Bedrock e ad altri servizi correlati.
+ **Librerie e dipendenze**. Installazione di librerie specifiche menzionate nel notebook, ad esempio `boto3` per AWS l'interazione, e qualsiasi altra dipendenza richiesta per l'integrazione LLM.
+ **Accesso ai modelli all'interno di Amazon Bedrock**. Questo modello utilizza tre Claude LLMs di Anthropic. Apri la [console Amazon Bedrock](https://console.aws.amazon.com/bedrock/) e scegli **Model access**. Nella schermata successiva, scegli **Abilita modelli specifici** e seleziona questi tre modelli:
+ Claude 3 Sonnet
+ Claude 3.5 Sonnet
+ Claude 3 Haiku
+ **Politiche IAM adeguate e ruolo IAM**. Per eseguire il notebook in un Account AWS ruolo AWS Identity and Access Management (IAM) è necessaria la `SagemakerFullAccess` policy e la policy fornita nella sezione [Informazioni aggiuntive](#translate-natural-language-query-dsl-opensearch-elasticsearch-additional), a cui è possibile assegnare un nome`APGtext2querydslpolicy`. Questa politica include l'abbonamento ai tre modelli Claude elencati.
La presenza di questi prerequisiti garantisce un'esperienza fluida quando si lavora con il notebook e si implementano le funzionalità. text-to-query
**Limitazioni**
+ **Verifica dello stato del concetto**. Questo progetto è inteso principalmente come proof of concept (PoC). Dimostra il potenziale di utilizzo LLMs per convertire le query in linguaggio naturale in query DSL, ma potrebbe non essere completamente ottimizzato o pronto per la produzione.
+ **Limitazioni del modello:**
**Vincoli della finestra contestuale***.* Quando utilizzi LLMs quelli disponibili su Amazon Bedrock, tieni presente le limitazioni della finestra di contesto:
Modelli Claude (a settembre 2024):
+ Claude 3 Opus: 200.000 gettoni
+ Claude 3 Sonnet: 200.000 gettoni
+ Claude 3 Haiku: 200.000 gettoni
Altri modelli su Amazon Bedrock potrebbero avere finestre contestuali di dimensioni diverse. Controlla sempre la documentazione più recente per le informazioni più recenti.
**Disponibilità del modello***.*La disponibilità di modelli specifici su Amazon Bedrock può variare. Assicurati di avere accesso ai modelli richiesti prima di implementare questa soluzione.
+ **Limitazioni aggiuntive**
+ **Complessità delle interrogazioni**. L'efficacia del linguaggio naturale per interrogare la conversione DSL può variare a seconda della complessità della query di input.
+ **Compatibilità delle versioni**. La query DSL generata potrebbe richiedere modifiche in base alla versione specifica di Elasticsearch o OpenSearch in uso.
+ **Prestazioni.** Questo modello fornisce un'implementazione PoC, quindi la velocità e la precisione di generazione delle query potrebbero non essere ottimali per l'uso in produzione su larga scala.
+ **Costo**. L'utilizzo LLMs in Amazon Bedrock comporta dei costi. Tieni presente la struttura dei prezzi per il modello che hai scelto. Per maggiori informazioni, consulta [Prezzi di Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html).
+ **Manutenzione**. Potrebbero essere necessari aggiornamenti regolari dei prompt e della selezione dei modelli per tenere il passo con i progressi della tecnologia LLM e le modifiche alla sintassi DSL delle query.
**Versioni del prodotto**
Questa soluzione è stata testata in Amazon OpenSearch Service. Se desideri utilizzare Elasticsearch, potresti dover apportare alcune modifiche per replicare l'esatta funzionalità di questo modello.
+ **OpenSearch compatibilità delle versioni.** **OpenSearch **mantiene la compatibilità con le versioni precedenti all'interno delle versioni principali. Esempio:
+ OpenSearch I client 1.x sono generalmente compatibili con i cluster OpenSearch 1.x.
+ OpenSearch I client 2.x sono generalmente compatibili con i cluster 2.x. OpenSearch
Tuttavia, quando possibile, è sempre preferibile utilizzare la stessa versione secondaria sia per il client che per il cluster.
+ **OpenSearch Compatibilità con le API**. **OpenSearch **mantiene la compatibilità delle API con Elasticsearch OSS 7.10.2 per la maggior parte delle operazioni. Tuttavia, esistono alcune differenze, specialmente nelle versioni più recenti.
+ **OpenSearch considerazioni sull'aggiornamento**:
+ I downgrade diretti non sono supportati. Se necessario, utilizzate le istantanee per il rollback.
+ Quando esegui l'aggiornamento, controlla la [matrice di compatibilità e le note di rilascio](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-operations.html) per eventuali modifiche sostanziali.
**Considerazioni su Elasticsearch**
+ **Versione Elasticsearch.** La versione principale di Elasticsearch che stai utilizzando è fondamentale, perché la sintassi e le funzionalità delle query possono cambiare tra le versioni principali. Attualmente, l'ultima versione stabile è Elasticsearch 8.x. Assicurati che le tue query siano compatibili con la tua versione specifica di Elasticsearch.
+ Versione della libreria DSL di **Elasticsearch query**. Se stai usando la libreria DSL Python di query Elasticsearch, assicurati che la sua versione corrisponda alla tua versione di Elasticsearch. Esempio:
+ Per Elasticsearch 8.x, usa una `elasticsearch-dsl` versione maggiore o uguale alla 8.0.0 ma inferiore alla 9.0.0.
+ Per Elasticsearch 7.x, usa una `elasticsearch-dsl` versione maggiore o uguale a 7.0.0 ma inferiore alla 8.0.0.
+ **Versione della libreria client.** Che tu stia utilizzando il client Elasticsearch ufficiale o un client specifico per una lingua, assicurati che sia compatibile con la tua versione di Elasticsearch.
+ **Interroga** la versione DSL. Query DSL si evolve con le versioni di Elasticsearch. Alcuni tipi o parametri di query potrebbero essere obsoleti o introdotti in versioni diverse.
+ **Versione di mappatura.** Il modo in cui si definiscono le mappature per gli indici e si passa da una versione all'altra. Controlla sempre la documentazione di mappatura per la tua versione specifica di Elasticsearch.
+ Versioni degli strumenti di **analisi**. Se utilizzi analizzatori, tokenizzatori o altri strumenti di analisi del testo, il loro comportamento o la loro disponibilità potrebbero cambiare tra le versioni.
## Architecture
**Architettura Target**
Il diagramma seguente illustra l'architettura di questo modello.
![\[Architettura per la traduzione del linguaggio naturale per interrogare DSL in Amazon Bedrock.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/75296405-2893-4328-9551-9bcc6ec7fd3e/images/ffb1b893-d23c-4e1c-b679-8063b4f85a8a.png)
dove:
1. Input dell'utente e prompt di sistema con alcuni esempi di prompt. Il processo inizia con un utente che fornisce una query in linguaggio naturale o una richiesta per la generazione di schemi.
1. Amazon Bedrock L'input viene inviato ad Amazon Bedrock, che funge da interfaccia per accedere a Claude LLM.
1. Claude 3 Sonnet LLM. Amazon Bedrock utilizza Claude 3 Sonnet della famiglia Claude 3 LLMs per elaborare l'input. Interpreta e genera l'Elasticsearch o la query DSL appropriata. OpenSearch Per le richieste di schema, genera Elasticsearch o mappature sintetiche. OpenSearch
1. Generazione di query DSL. Per le query in linguaggio naturale, l'applicazione prende l'output del LLM e lo formatta in un DSL di query Elasticsearch o Service valido. OpenSearch
1. Generazione di dati sintetici. L'applicazione utilizza anche schemi per creare Elasticsearch sintetici o OpenSearch dati da caricare in una raccolta OpenSearch Serverless per i test.
1. OpenSearch o Elasticsearch. La Query DSL generata viene interrogata su una raccolta OpenSearch Serverless su tutti gli indici. L'output JSON contiene i dati pertinenti e il numero di *hit* dei dati che risiedono nella raccolta Serverless. OpenSearch
**Automazione e scalabilità**
Il codice fornito con questo pattern è creato esclusivamente per scopi PoC. L'elenco seguente fornisce alcuni suggerimenti per automatizzare e scalare ulteriormente la soluzione e portare il codice alla produzione. Questi miglioramenti non rientrano nell'ambito di questo modello.
+ Containerizzazione:
+ Dockerizza l'applicazione per garantire la coerenza tra diversi ambienti.
+ Utilizza piattaforme di orchestrazione dei container come Amazon Elastic Container Service (Amazon ECS) o Kubernetes per distribuzioni scalabili.
+ Architettura serverless:
+ Converti le funzionalità di base in AWS Lambda funzioni.
+ Usa Amazon API Gateway per creare RESTful endpoint per l'input di query in linguaggio naturale.
+ Elaborazione asincrona:
+ Implementa Amazon Simple Queue Service (Amazon SQS) per mettere in coda le query in entrata.
+ Utilizzalo AWS Step Functions per orchestrare il flusso di lavoro di elaborazione delle query e generazione di query DSL.
+ Memorizzazione nella cache:
+ Implementa un meccanismo per memorizzare nella cache i prompt.
+ Monitoraggio e registrazione:
+ Usa Amazon CloudWatch per il monitoraggio e gli avvisi.
+ Implementa la registrazione centralizzata con Amazon CloudWatch Logs o Amazon OpenSearch Service per l'analisi dei log.
+ Miglioramenti della sicurezza:
+ Implementa i ruoli IAM per un controllo granulare degli accessi.
+ Utilizzalo Gestione dei segreti AWS per archiviare e gestire in modo sicuro chiavi e credenziali API.
+ Implementazione in più regioni:
+ Prendi in considerazione l'implementazione della soluzione su più sistemi Regioni AWS per migliorare la latenza e il disaster recovery.
+ Usa Amazon Route 53 per il routing intelligente delle richieste.
Implementando questi suggerimenti, puoi trasformare questo PoC in una soluzione robusta, scalabile e pronta per la produzione. Si consiglia di testare a fondo ogni componente e l'intero sistema prima dell'implementazione completa.
## Tools (Strumenti)
**Strumenti**
+ I notebook [Amazon SageMaker AI sono notebook](https://aws.amazon.com/sagemaker/notebooks/) Jupyter completamente gestiti per lo sviluppo dell'apprendimento automatico. Questo modello utilizza i notebook come ambiente interattivo per l'esplorazione dei dati, lo sviluppo di modelli e la sperimentazione in Amazon AI. SageMaker I notebook offrono una perfetta integrazione con altre funzionalità di intelligenza artificiale e. SageMaker Servizi AWS
+ [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico. Questo modello utilizza Python come linguaggio principale per implementare la soluzione.
+ [Amazon Bedrock](https://aws.amazon.com/bedrock/) è un servizio completamente gestito che rende disponibili per l'uso modelli di base ad alte prestazioni (FMs) delle principali startup di intelligenza artificiale e di Amazon tramite un'API unificata. Amazon Bedrock fornisce l'accesso all' LLMs elaborazione del linguaggio naturale. Questo modello utilizza modelli Anthropic Claude 3.
+ [AWS SDK per Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)è un kit di sviluppo software che ti aiuta a integrare la tua applicazione, libreria o script Python con Servizi AWS, incluso Amazon Bedrock.
+ [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html) è un servizio gestito che ti aiuta a distribuire, gestire e scalare i cluster OpenSearch di servizi nel cloud AWS. Questo modello utilizza OpenSearch Service come sistema di destinazione per la generazione di query DSL.
**Archivio di codice**
Il codice per questo pattern è disponibile nel repository GitHub [Prompt Engineering Text-to-QueryDSL Using Claude 3](https://github.com/aws-samples/text-to-queryDSL/blob/main/text2ES_prompting_guide.ipynb) Models. L'esempio utilizza un'app di social media sulla salute che crea post per utenti e profili utente associati all'applicazione sanitaria.
## Best practice
Quando utilizzi questa soluzione, considera quanto segue:
+ La necessità di AWS credenziali e autorizzazioni adeguate per accedere ad Amazon Bedrock
+ Potenziali costi associati all'utilizzo e Servizi AWS LLMs
+ L'importanza di comprendere le query DSL per convalidare e potenzialmente modificare le query generate
## Epiche
### Configura l'ambiente e prepara i dati
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura l'ambiente di sviluppo. | [Per istruzioni dettagliate e codice per questo e gli altri passaggi di questo schema, consulta la procedura dettagliata completa nel GitHub repository.](https://github.com/aws-samples/text-to-queryDSL/blob/main/text2ES_prompting_guide.ipynb)[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/translate-natural-language-query-dsl-opensearch-elasticsearch.html) | Python, pip, SDK AWS |
| Configura l'accesso. AWS | Configura il client Amazon Bedrock e la sessione SageMaker AI. Recupera l'Amazon Resource Name (ARN) per SageMaker il ruolo di esecuzione AI per utilizzarlo successivamente nella creazione OpenSearch della raccolta Serverless. | IAM, AWS CLI, Amazon Bedrock, Amazon SageMaker |
| Carica gli schemi delle app sanitarie. | Leggi e analizza gli schemi JSON per i post sanitari e i profili utente da file predefiniti. Converti gli schemi in stringhe per utilizzarli successivamente nei prompt. | DevOps ingegnere, AWS generale, Python, JSON |
### Genera dati sintetici
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un generatore di dati basato su LLM. | Implementa la funzione **generate\$1data ()** per chiamare l'API Amazon Bedrock Converse con i modelli Claude 3. Configura il modello IDs per Sonnet, Sonnet 3.5 e Haiku:model_id_sonnet3_5 = "anthropic.claude-3-5-sonnet-20240620-v1:0"
model_id_sonnet = "anthropic.claude-3-sonnet-20240229-v1:0"
model_id_haiku = "anthropic.claude-3-haiku-20240307-v1:0"
| Python, API Amazon Bedrock, prompt LLM |
| Crea post sanitari sintetici. | Utilizzate la funzione **generate\$1data ()** con un messaggio specifico per creare post sintetici sulla salute in base allo schema fornito. La chiamata alla funzione ha il seguente aspetto: health_post_data = generate_data(bedrock_rt, model_id_sonnet, system_prompt, message_healthpost, inference_config)
| Python, JSON |
| Crea profili utente sintetici. | Utilizzate la funzione **generate\$1data ()** con un messaggio specifico per creare voci sintetiche del profilo utente in base allo schema fornito. È simile alla generazione di post sanitari, ma utilizza un prompt diverso. | Python, JSON |
### Configura OpenSearch e acquisisci dati
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura una raccolta OpenSearch Serverless. | Usa Boto3 per creare una raccolta OpenSearch Serverless con politiche di crittografia, rete e accesso appropriate. La creazione della collezione ha il seguente aspetto: collection = aoss_client.create_collection(name=es_name, type='SEARCH')
Per ulteriori informazioni su OpenSearch Serverless, consulta la [AWS documentazione](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless.html). | OpenSearch Serverless, IAM |
| Definisci gli OpenSearch indici. | Crea indici per postazioni sanitarie e profili utente utilizzando il OpenSearch client, in base alle mappature dello schema predefinite. La creazione dell'indice ha il seguente aspetto:response_health = oss_client.indices.create(healthpost_index, body=healthpost_body)
| OpenSearch, JSON |
| Carica i dati in. OpenSearch | Esegui la funzione **ingest\$1data ()** per inserire in blocco i post sanitari sintetici e i profili utente nei rispettivi indici. OpenSearch La funzione utilizza l'helper bulk di: `opensearch-py`success, failed = bulk(oss_client, actions)
| Python, OpenSearch API, operazioni di dati di massa |
### Genera ed esegui interrogazioni
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Progetta alcuni esempi di prompt. | Genera query di esempio e domande corrispondenti in linguaggio naturale utilizzando i modelli Claude 3 come esempi di pochi esempi per la generazione di query. Il prompt di sistema include questi esempi:system_prompt_query_generation = [{"text": f"""You are an expert query dsl generator. ... Examples: {example_prompt} ..."""}] | Richiesta LLM, interrogazione DSL |
| Crea un convertitore DSL text-to-query. | Implementa il prompt di sistema, che include schemi, dati ed esempi sintetici, per la generazione di query. Utilizzate il prompt di sistema per convertire le query in linguaggio naturale in query DSL. La chiamata alla funzione ha il seguente aspetto:query_response = generate_data(bedrock_rt, model_id, system_prompt_query_generation, query, inference_config)
| Python, API Amazon Bedrock, prompt LLM |
| Interrogazione di prova DSL attiva. OpenSearch | Eseguite la funzione **query\$1oss ()** per eseguire la query DSL generata sulla raccolta OpenSearch Serverless e restituire i risultati. La funzione utilizza il metodo di ricerca del client OpenSearch :response = oss_client.search(index="_all", body=temp)
| Python, OpenSearch API, interrogazione DSL |
### Testa e valuta
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un set di query di test. | Usa Claude 3 per generare una serie diversificata di domande di test basate su dati e schemi sintetici:test_queries = generate_data(bedrock_rt, model_id_sonnet, query_system_prompt, query_prompt, inference_config)
| Richiesta LLM |
| Valuta l'accuratezza della conversione DSL della query. | Testa la query DSL generata eseguendo query OpenSearch e analizzando i risultati restituiti per verificarne la pertinenza e la precisione. Ciò comporta l'esecuzione della query e l'ispezione dei risultati:output = query_oss(response1) print("Response after running query against Opensearch") print(output) | Python, analisi dei dati, query DSL |
| Modelli Benchmark Claude 3. | Confronta le prestazioni di diversi modelli Claude 3 (Haiku, Sonnet, Sonnet 3.5) per la generazione di query in termini di precisione e latenza. Per confrontare, modifica il `model_id` momento in cui chiami **generate\$1data** () e misura il tempo di esecuzione. | Python, analisi comparativa delle prestazioni |
### Pulisci e documenta
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Sviluppa un processo di pulizia. | Elimina tutti gli indici dalla raccolta OpenSearch Serverless dopo l'uso. | Python, SDK AWS, API OpenSearch |
## Risorse correlate
+ [Interrogazione DSL (documentazione)](https://opensearch.org/docs/latest/query-dsl/) OpenSearch
+ [Documentazione OpenSearch del servizio Amazon](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/what-is.html)
+ [OpenSearch Raccolte serverless](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-manage.html)
+ [Documentazione Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html)
+ [Documentazione Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)
+ [AWS SDK per Python (Boto3) documentazione](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
## Informazioni aggiuntive
**Policy IAM**
Ecco la `APGtext2querydslpolicy` politica per il ruolo IAM utilizzata in questo modello:
```
{
"Version": "2012-10-17",
"Statement": [
{ "Effect": "Allow",
"Action": [
"bedrock:InvokeModel",
"bedrock:InvokeModelWithResponseStream"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::sagemaker-*",
"arn:aws:s3:::sagemaker-*/*"
]
},
{ "Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:log-group:/aws/sagemaker/*"
},
{ "Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DeleteNetworkInterface"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": [
"aoss:*"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": [
"iam:PassRole",
"sagemaker:*"
],
"Resource": [
"arn:aws:iam::*:role/*", "*"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": "sagemaker.amazonaws.com"
}
}
},
{ "Effect": "Allow",
"Action": [
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetRepository",
"codecommit:ListBranches",
"codecommit:ListRepositories"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": [
"aws-marketplace:Subscribe"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws-marketplace:ProductId": [
"prod-6dw3qvchef7zy",
"prod-m5ilt4siql27k",
"prod-ozonys2hmmpeu"
]
}
}
},
{ "Effect": "Allow",
"Action": [
"aws-marketplace:Unsubscribe",
"aws-marketplace:ViewSubscriptions"
],
"Resource": "*"
},
{ "Effect": "Allow",
"Action": "iam:*",
"Resource": "*"
}
]
}
```
**Tecniche rapide con i modelli Anthropic Claude 3**
Questo modello illustra le seguenti tecniche di richiesta per la conversione text-to-query DSL utilizzando i modelli Claude 3.
+ **Few-shot prompting:** il few-shot prompting è una tecnica potente per migliorare le prestazioni dei modelli Claude 3 su Amazon Bedrock. Questo approccio prevede di fornire al modello un numero limitato di esempi che dimostrino il input/output comportamento desiderato prima di chiedergli di eseguire un'attività simile. Quando utilizzi i modelli Claude 3 su Amazon Bedrock, i suggerimenti in pochi passaggi possono essere particolarmente efficaci per attività che richiedono una formattazione specifica, schemi di ragionamento o conoscenze del dominio. Per implementare questa tecnica, in genere si struttura il prompt con due componenti principali: la sezione di esempio e la query effettiva. La sezione di esempio contiene una o più input/output coppie che illustrano l'attività e la sezione query presenta il nuovo input per il quale si desidera una risposta. Questo metodo aiuta Claude 3 a comprendere il contesto e il formato di output previsto e spesso si traduce in una risposta più accurata e coerente.
Esempio:
```
"query": {
"bool": {
"must": [
{"match": {"post_type": "recipe"}},
{"range": {"likes_count": {"gte": 100}}},
{"exists": {"field": "media_urls"}}
]
}
}
Question: Find all recipe posts that have at least 100 likes and include media URLs.
```
+ Istruzioni di **sistema: oltre ai prompt** di pochi passaggi, i modelli Claude 3 su Amazon Bedrock supportano anche l'uso dei prompt di sistema. I prompt di sistema sono un modo per fornire contesto generale, istruzioni o linee guida al modello prima di presentarlo con input specifici dell'utente. Sono particolarmente utili per impostare il tono, definire il ruolo del modello o stabilire vincoli per l'intera conversazione. Per utilizzare un prompt di sistema con Claude 3 su Amazon Bedrock, devi includerlo nel `system` parametro della tua richiesta API. Questo è separato dai messaggi degli utenti e si applica all'intera interazione. I prompt di sistema dettagliati vengono utilizzati per impostare il contesto e fornire linee guida per il modello.
Esempio:
```
You are an expert query dsl generator. Your task is to take an input question and generate a query dsl to answer the question. Use the schemas and data below to generate the query.
Schemas: [schema details]
Data: [sample data]
Guidelines:
- Ensure the generated query adheres to DSL query syntax
- Do not create new mappings or other items that aren't included in the provided schemas.
```
+ **Output strutturato**: è possibile indicare al modello di fornire output in formati specifici, come JSON o all'interno di tag XML.
Esempio:
```
Put the query in json tags
```
+ **Concatenamento dei prompt**: il notebook utilizza l'output di una chiamata LLM come input per un'altra, ad esempio utilizza dati sintetici generati per creare domande di esempio.
+ **Fornitura del contesto**: il contesto pertinente, inclusi schemi e dati di esempio, viene fornito nelle istruzioni.
Esempio:
```
Schemas: [schema details]
Data: [sample data]
```
+ Istruzioni **specifiche per attività: vengono creati diversi prompt** per attività specifiche, come la generazione di dati sintetici, la creazione di domande di esempio e la conversione di query in linguaggio naturale in query DSL.
Esempio di generazione di domande di prova:
```
Your task is to generate 5 example questions users can ask the health app based on provided schemas and data. Only include the questions generated in the response.
```
# Usa Amazon Q Developer come assistente di programmazione per aumentare la tua produttività
*Ram Kandaswamy, Amazon Web Services*
## Riepilogo
Questo modello utilizza un tic-tac-toe gioco per dimostrare come applicare Amazon Q Developer a una serie di attività di sviluppo. Genera codice per un tic-tac-toe gioco come applicazione a pagina singola (SPA), migliora l'interfaccia utente e crea script su cui distribuire l'applicazione. AWS
Amazon Q Developer funge da assistente di codifica per accelerare i flussi di lavoro di sviluppo software e migliorare la produttività sia per gli sviluppatori che per i non sviluppatori. Indipendentemente dalla tua esperienza tecnica, ti aiuta a creare architetture e progettare soluzioni per problemi aziendali, avvia il tuo ambiente di lavoro, ti aiuta a implementare nuove funzionalità e genera casi di test per la convalida. Utilizza istruzioni in linguaggio naturale e funzionalità di intelligenza artificiale per garantire codice coerente e di alta qualità e mitigare le sfide di codifica indipendentemente dalle tue capacità di programmazione.
Il vantaggio principale di Amazon Q Developer è la sua capacità di liberarti da attività di codifica ripetitive. Quando usi l'`@workspace`annotazione, Amazon Q Developer inserisce e indicizza tutti i file di codice, le configurazioni e la struttura del progetto nel tuo ambiente di sviluppo integrato (IDE) e fornisce risposte personalizzate per aiutarti a concentrarti sulla risoluzione creativa dei problemi. Puoi dedicare più tempo alla progettazione di soluzioni innovative e al miglioramento dell'esperienza utente. Se non sei tecnico, puoi utilizzare Amazon Q Developer per semplificare i flussi di lavoro e collaborare in modo più efficace con il team di sviluppo. La funzionalità del **codice Amazon Q Developer Explain** offre istruzioni e riepiloghi dettagliati, in modo da poter navigare tra basi di codice complesse.
Inoltre, Amazon Q Developer offre un approccio indipendente dal linguaggio che aiuta gli sviluppatori di livello medio e basso ad ampliare le proprie competenze. Puoi concentrarti sui concetti fondamentali e sulla logica aziendale anziché sulla sintassi specifica del linguaggio. Ciò riduce la curva di apprendimento quando si cambia tecnologia.
## Prerequisiti e limitazioni
**Prerequisiti**
+ IDE (ad esempio, WebStorm o Visual Studio Code) con il plug-in Amazon Q Developer installato. Per istruzioni, consulta [Installazione dell'estensione o del plug-in Amazon Q Developer nel tuo IDE](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE-setup.html) nella documentazione di Amazon Q Developer.
+ Una Account AWS configurazione attiva con Amazon Q Developer. Per istruzioni, consulta la sezione [Guida introduttiva](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/getting-started-q-dev.html) nella documentazione di Amazon Q Developer.
+ **npm** installato. Per istruzioni, consulta la documentazione di [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm). Questo modello è stato testato con la versione 10.8 di npm.
+ AWS Command Line Interface (AWS CLI) installato. Per istruzioni, consultate la [AWS CLI documentazione](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Limitazioni**
+ Amazon Q Developer può eseguire solo un'attività di sviluppo alla volta.
+ Alcune Servizi AWS non sono disponibili in tutte Regioni AWS. Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
## Tools (Strumenti)
+ Questo modello richiede un IDE come Visual Studio Code o. WebStorm Per un elenco di quelli supportati IDEs, consulta la [documentazione di Amazon Q Developer](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE.html#supported-ides-features).
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che ti aiuta a interagire Servizi AWS tramite comandi nella shell della riga di comando.
## Best practice
Consulta [le migliori pratiche di codifica con Amazon Q Developer](https://docs.aws.amazon.com/prescriptive-guidance/latest/best-practices-code-generation/best-practices-coding.html) in AWS Prescriptive Guidance. Inoltre:
+ Quando fornisci istruzioni ad Amazon Q Developer, assicurati che le istruzioni siano chiare e inequivocabili. Aggiungi frammenti di codice e annotazioni, ad esempio, al prompt `@workspace` per fornire più contesto ai tuoi prompt.
+ Includi le librerie pertinenti e importale per evitare conflitti o ipotesi errate da parte del sistema.
+ Se il codice generato non è preciso o come previsto, utilizzate l'opzione **Fornisci feedback e rigenera**. Prova a suddividere le istruzioni in istruzioni più piccole.
## Epiche
### Configura l'ambiente di lavoro
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un nuovo progetto. | Per creare un nuovo progetto nel tuo ambiente di lavoro, esegui il seguente comando e accetta le impostazioni predefinite per tutte le domande:npx create-next-app@latest
| Sviluppatore di app, programmatore, sviluppatore di software |
| Prova l'applicazione di base. | Eseguite il comando seguente e confermate che l'applicazione di base venga caricata correttamente nel browser:npm run dev
| Sviluppatore di app, programmatore, sviluppatore di software |
| Pulisci il codice base. | Vai al `page.tsx` file nella `src/app` cartella ed elimina il contenuto predefinito per ottenere una pagina vuota. Dopo l'eliminazione, il file dovrebbe avere il seguente aspetto:export default function Home() {
return (
);
} | Sviluppatore di app, programmatore, sviluppatore di software |
### Usa Amazon Q Developer per progettare un progetto di tic-tac-toe gioco
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Ottieni una panoramica dei passaggi. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | Sviluppatore di app, programmatore, sviluppatore di software |
| Genera codice per tic-tac-toe. | Nel pannello di chat, avvia un'attività di sviluppo utilizzando il `/dev` comando seguito dalla descrizione dell'attività. Esempio:/dev Create a React-based single-page application written in TypeScript for a tic-tac-toe game with the following specifications:
1. Design an aesthetically pleasing interface with the game grid centered vertically and
horizontally on the page.
2. Include a heading and clear instructions on how to play the game.
3. Implement color-coding for X and O marks to distinguish them easily.
Amazon Q Developer genera codice in base alle tue istruzioni. | Sviluppatore di app, programmatore, sviluppatore di software |
| Ispeziona e accetta il codice generato. | Ispeziona visivamente il codice e scegli **Accetta codice** per sostituire automaticamente il `page.tsx` file.Se riscontri problemi, scegli **Fornisci feedback e rigenera e** descrivi il problema che hai riscontrato. | Sviluppatore di app, programmatore, sviluppatore di software |
| Correggi gli errori di lint. | Il tic-tac-toe gioco di esempio include una griglia. Il codice generato da Amazon Q Developer potrebbe utilizzare il tipo predefinito`any`. Puoi aggiungere la sicurezza dei tipi richiedendo ad Amazon Q Developer come segue:/dev Ensure proper TypeScript typing for the onSquare Click event handler
to resolve any 'any' type issues.
| Sviluppatore di app, programmatore, sviluppatore di software |
| Aggiungi fascino visivo. | È possibile suddividere il requisito originale in frammenti più piccoli. Ad esempio, puoi migliorare l'interfaccia utente del gioco con le seguenti istruzioni nelle attività di sviluppo. Questo prompt migliora gli stili CSS (Cascading Style Sheets) ed esporta l'app per la distribuzione./dev Debug and fix any CSS issues to correctly display the game grid and overall layout.
Simplify the code by removing game history functionality and related components.
Implement static file export to an 'out' directory for easy deployment. The solution
should be fully functional, visually appealing, and free of typing errors or layout issues.
| Sviluppatore di app, programmatore, sviluppatore di software |
| Prova di nuovo. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | Sviluppatore di app, programmatore, sviluppatore di software |
### Distribuisci l'applicazione su Cloud AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea cartelle e file per la distribuzione. | Nel progetto nel tuo ambiente di lavoro, crea una cartella di distribuzione e due file al suo interno: `pushtos3.sh` e`cloudformation.yml`:mkdir deployment && cd deployment
touch pushtos3.sh && chmod +x pushtos3.sh
touch cloudformation.yml
| Sviluppatore di app, programmatore, sviluppatore di software |
| Genera codice di automazione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | Amministratore AWS, AWS DevOps, sviluppatore di app |
| Genera contenuti di script. | Per creare uno script di distribuzione, utilizzate il seguente prompt:/dev Modify the pushtos3 shell script so that it can use AWS CLI commands to create a
CloudFormation stack named tictactoe-stack if it does not exist already, and use
cloudformation.yml as the source template. Wait for the stack to complete and sync the
contents from the out folder to the S3 bucket. Perform invalidation of the CloudFront
origin.
| Sviluppatore di app, programmatore, sviluppatore di software |
| Distribuisci l'applicazione su. Cloud AWS | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/use-q-developer-as-coding-assistant-to-increase-productivity.html) | Amministratore AWS, AWS DevOps, architetto del cloud, sviluppatore di app |
## risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| La build non crea un'applicazione a pagina singola né la esporta nella cartella di output. | Guarda il contenuto del `next.config.mjs` file.Se il codice ha la seguente configurazione predefinita:const nextConfig = {};modificalo come segue:const nextConfig = {
output: 'export',
distDir: 'out',
}; |
## Risorse correlate
+ [Creare un nuovo progetto React](https://react.dev/learn/start-a-new-react-project) (documentazione React)
+ [Panoramica di Amazon Q per sviluppatori](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/what-is.html) (AWS documentazione)
+ [Best practice per gli sviluppatori di Amazon Q](https://docs.aws.amazon.com/prescriptive-guidance/latest/best-practices-code-generation/introduction.html) (Guida AWS prescrittiva)
+ [Installazione, configurazione e utilizzo di Amazon Q Developer con JetBrains IDEs](https://www.youtube.com/watch?v=-iQfIhTA4J0&pp=ygUSYW1hem9uIHEgZGV2ZWxvcGVy) (YouTube video)
+ [Installazione di Amazon Q per la riga di comando](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-getting-started-installing.html) (AWS documentazione)
# Usa SageMaker Processing per l'ingegneria di funzionalità distribuite di set di dati ML su scala terabyte
*Chris Boomhower, Amazon Web Services*
## Riepilogo
Molti set di dati su scala terabyte o più grandi spesso sono costituiti da una struttura gerarchica di cartelle e i file del set di dati a volte condividono interdipendenze. Per questo motivo, gli ingegneri del machine learning (ML) e i data scientist devono prendere decisioni progettuali ponderate per preparare tali dati per l'addestramento e l'inferenza dei modelli. Questo modello dimostra come è possibile utilizzare tecniche manuali di macrosharding e microsharding in combinazione con Amazon SageMaker Processing e la parallelizzazione della CPU virtuale (vCPU) per scalare in modo efficiente i processi di progettazione delle funzionalità per complessi set di dati ML di big data.
Questo modello definisce il *macrosharding* come la suddivisione di directory di dati su più macchine per l'elaborazione e il *microsharding* come la suddivisione dei dati su ogni macchina su più thread di elaborazione. [Il modello dimostra queste tecniche utilizzando Amazon SageMaker con esempi di record di forme d'onda di serie temporali dal set di dati MIMIC-III. PhysioNet ](https://physionet.org/content/mimic3wdb/1.0/) Implementando le tecniche di questo modello, è possibile ridurre al minimo i tempi e i costi di elaborazione per la progettazione delle funzionalità, massimizzando al contempo l'utilizzo delle risorse e l'efficienza della produttività. Queste ottimizzazioni si basano sull' SageMaker elaborazione distribuita su istanze Amazon Elastic Compute Cloud EC2 (Amazon) e v CPUs per set di dati simili e di grandi dimensioni, indipendentemente dal tipo di dati.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Accedi alle istanze di SageMaker notebook o a SageMaker Studio, se desideri implementare questo modello per il tuo set di dati. Se utilizzi Amazon SageMaker per la prima volta, consulta la sezione Guida [introduttiva ad Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html) nella documentazione AWS.
+ SageMaker Studio, se desideri implementare questo modello con i dati di esempio [PhysioNet MIMIC-III](https://physionet.org/content/mimic3wdb/1.0/).
+ Il pattern utilizza SageMaker Processing, ma non richiede alcuna esperienza nell'esecuzione SageMaker dei job di Processing.
**Limitazioni**
+ Questo modello è adatto ai set di dati ML che includono file interdipendenti. Queste interdipendenze traggono il massimo vantaggio dal macrosharding manuale e dall'esecuzione in parallelo di più processi di elaborazione a istanza singola SageMaker . Per i set di dati in cui tali interdipendenze non esistono, la `ShardedByS3Key` funzionalità di SageMaker Processing potrebbe essere un'alternativa migliore al macrosharding, poiché invia dati suddivisi a più istanze gestite dallo stesso processo di elaborazione. Tuttavia, è possibile implementare la strategia di microsharding di questo pattern in entrambi gli scenari per utilizzare al meglio l'istanza v. CPUs
**Versioni del prodotto**
+ SDK Amazon SageMaker Python versione 2
## Architecture
**Stack tecnologico Target**
+ Amazon Simple Storage Service (Amazon S3)
+ Amazon SageMaker
**Architettura Target**
*Macrosharding e istanze distribuite EC2 *
I 10 processi paralleli rappresentati in questa architettura riflettono la struttura del set di dati MIMIC-III. (I processi sono rappresentati da ellissi per semplificare i diagrammi.) Un'architettura simile si applica a qualsiasi set di dati quando si utilizza il macrosharding manuale. Nel caso di MIMIC-III, è possibile utilizzare a proprio vantaggio la struttura grezza del set di dati elaborando ogni cartella del gruppo di pazienti separatamente, con il minimo sforzo. Nel diagramma seguente, il blocco dei gruppi di record appare sulla sinistra (1). Data la natura distribuita dei dati, ha senso condividerli per gruppo di pazienti.
![\[Architettura per il microsharding e le istanze distribuite EC2\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/e7a90b31-de8f-41fd-bb3f-c7c6100fc306/images/c19a8f87-ac59-458e-89cb-50be17ca4a0c.png)
Tuttavia, la suddivisione manuale per gruppo di pazienti significa che è necessario un processo di elaborazione separato per ogni cartella del gruppo di pazienti, come si può vedere nella sezione centrale del diagramma (2), anziché un singolo processo di elaborazione con più istanze. EC2 Poiché i dati di MIMIC-III includono sia file di forme d'onda binarie che file di intestazione basati su testo corrispondenti e che è richiesta la dipendenza dalla [libreria wfdb](https://wfdb.readthedocs.io/en/latest/) per l'estrazione dei dati binari, tutti i record per un paziente specifico devono essere resi disponibili sulla stessa istanza. L'unico modo per assicurarsi che sia presente anche il file di intestazione associato a ogni file di forma d'onda binaria è implementare lo sharding manuale per eseguire ogni shard all'interno del proprio processo di elaborazione e specificare `s3_data_distribution_type='FullyReplicated'` quando si definisce l'input del processo di elaborazione. In alternativa, se tutti i dati fossero disponibili in un'unica directory e non esistessero dipendenze tra i file, un'opzione più adatta potrebbe essere quella di avviare un singolo processo di Processing con più istanze specificate. EC2 `s3_data_distribution_type='ShardedByS3Key'` Specificare `ShardedByS3Key ` come indicato dal tipo di distribuzione dei dati di Amazon S3 per gestire automaticamente lo SageMaker sharding dei dati tra le istanze.
L'avvio di un processo di elaborazione per ogni cartella è un modo conveniente per preelaborare i dati, perché l'esecuzione simultanea di più istanze consente di risparmiare tempo. Per ulteriori risparmi in termini di costi e tempi, è possibile utilizzare il microsharding all'interno di ciascun processo di elaborazione.
*Microsharding e parallel v CPUs*
All'interno di ogni processo di elaborazione, i dati raggruppati vengono ulteriormente suddivisi per massimizzare l'utilizzo di tutte le v disponibili CPUs sull'istanza completamente gestita SageMaker . EC2 I blocchi nella sezione centrale del diagramma (2) illustrano ciò che accade all'interno di ciascun processo di elaborazione principale. Il contenuto delle cartelle cliniche dei pazienti viene appiattito e suddiviso equamente in base al numero di v CPUs disponibili sull'istanza. Dopo la divisione del contenuto della cartella, il set di file di dimensioni uguali viene distribuito su tutti i v CPUs per l'elaborazione. Una volta completata l'elaborazione, i risultati di ogni vCPU vengono combinati in un unico file di dati per ogni processo di elaborazione.
Nel codice allegato, questi concetti sono rappresentati nella sezione seguente del `src/feature-engineering-pass1/preprocessing.py` file.
```
def chunks(lst, n):
"""
Yield successive n-sized chunks from lst.
:param lst: list of elements to be divided
:param n: number of elements per chunk
:type lst: list
:type n: int
:return: generator comprising evenly sized chunks
:rtype: class 'generator'
"""
for i in range(0, len(lst), n):
yield lst[i:i + n]
# Generate list of data files on machine
data_dir = input_dir
d_subs = next(os.walk(os.path.join(data_dir, '.')))[1]
file_list = []
for ds in d_subs:
file_list.extend(os.listdir(os.path.join(data_dir, ds, '.')))
dat_list = [os.path.join(re.split('_|\.', f)[0].replace('n', ''), f[:-4]) for f in file_list if f[-4:] == '.dat']
# Split list of files into sub-lists
cpu_count = multiprocessing.cpu_count()
splits = int(len(dat_list) / cpu_count)
if splits == 0: splits = 1
dat_chunks = list(chunks(dat_list, splits))
# Parallelize processing of sub-lists across CPUs
ws_df_list = Parallel(n_jobs=-1, verbose=0)(delayed(run_process)(dc) for dc in dat_chunks)
# Compile and pickle patient group dataframe
ws_df_group = pd.concat(ws_df_list)
ws_df_group = ws_df_group.reset_index().rename(columns={'index': 'signal'})
ws_df_group.to_json(os.path.join(output_dir, group_data_out))
```
Una funzione,`chunks`, viene innanzitutto definita per utilizzare un determinato elenco dividendolo in blocchi di lunghezza di dimensioni uguali `n ` e restituendo questi risultati come generatore. Successivamente, i dati vengono appiattiti tra le cartelle dei pazienti compilando un elenco di tutti i file binari di forme d'onda presenti. Fatto ciò, si ottiene il numero di v CPUs disponibile sull'istanza. EC2 [L'elenco dei file binari di forme d'onda viene suddiviso equamente tra questi v CPUs chiamando`chunks`, e quindi ogni sottolista di forme d'onda viene elaborata sulla propria vCPU utilizzando la classe Parallel di joblib.](https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html) I risultati vengono automaticamente combinati in un unico elenco di dataframe dal processo di elaborazione, che SageMaker quindi li elabora ulteriormente prima di scriverli su Amazon S3 al completamento del processo. In questo esempio, ci sono 10 file scritti su Amazon S3 dai processi di elaborazione (uno per ogni processo).
Una volta completati tutti i processi di elaborazione iniziali, un processo di elaborazione secondario, mostrato nel riquadro a destra del diagramma (3), combina i file di output prodotti da ciascun processo di elaborazione principale e scrive l'output combinato su Amazon S3 (4).
## Tools (Strumenti)
**Strumenti**
+ [Python](https://www.python.org/) — Il codice di esempio usato per questo pattern è Python (versione 3).
+ [SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html): Amazon SageMaker Studio è un ambiente di sviluppo integrato (IDE) basato sul Web per l'apprendimento automatico che ti consente di creare, addestrare, eseguire il debug, distribuire e monitorare i tuoi modelli di machine learning. Puoi eseguire i processi di SageMaker elaborazione utilizzando i notebook Jupyter all'interno di Studio. SageMaker
+ [SageMaker Elaborazione](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html): Amazon SageMaker Processing offre un modo semplificato per eseguire i carichi di lavoro di elaborazione dei dati. In questo modello, il codice di progettazione delle funzionalità viene implementato su larga scala utilizzando i processi di SageMaker elaborazione.
**Codice**
Il file.zip allegato fornisce il codice completo per questo pattern. La sezione seguente descrive i passaggi per creare l'architettura per questo pattern. Ogni passaggio è illustrato da un codice di esempio contenuto nell'allegato.
## Epiche
### Configura il tuo ambiente SageMaker Studio
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Accedi ad Amazon SageMaker Studio. | Effettua l'onboarding su SageMaker Studio nel tuo account AWS seguendo le istruzioni fornite nella [ SageMaker documentazione di Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html). | Scienziato dei dati, ingegnere ML |
| Installa l'utilità wget. | Installa *wget* se hai effettuato l'onboarding con una nuova configurazione di SageMaker Studio o se non hai mai usato queste utilità in Studio prima. SageMaker Per installarlo, apri una finestra di terminale nella console di SageMaker Studio ed esegui il seguente comando:sudo yum install wget
| Scienziato dei dati, ingegnere ML |
| Scarica e decomprimi il codice di esempio. | Scarica il `attachments.zip` file nella sezione *Allegati.* In una finestra di terminale, accedi alla cartella in cui hai scaricato il file ed estraine il contenuto:unzip attachment.zip
Vai alla cartella in cui hai estratto il file.zip ed estrai il contenuto del `Scaled-Processing.zip` file.unzip Scaled-Processing.zip
| Scienziato dei dati, ingegnere ML |
| Scarica il set di dati di esempio da physionet.org e caricalo su Amazon S3. | Esegui il notebook `get_data.ipynb` Jupyter all'interno della cartella che contiene i file. `Scaled-Processing` Questo notebook scarica un set di dati MIMIC-III di esempio da [physionet.org](https://physionet.org) e lo carica nel bucket di sessione SageMaker Studio in Amazon S3. | Scienziato dei dati, ingegnere ML |
### Configura il primo script di preelaborazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Appiattisci la gerarchia dei file in tutte le sottodirectory. | In set di dati di grandi dimensioni come MIMIC-III, i file sono spesso distribuiti su più sottodirectory anche all'interno di un gruppo principale logico. Lo script deve essere configurato per appiattire tutti i file di gruppo in tutte le sottodirectory, come dimostra il codice seguente.# Generate list of .dat files on machine
data_dir = input_dir
d_subs = next(os.walk(os.path.join(data_dir, '.')))[1]
file_list = []
for ds in d_subs:
file_list.extend(os.listdir(os.path.join(data_dir, ds, '.')))
dat_list = [os.path.join(re.split('_|\.', f)[0].replace('n', ''), f[:-4]) for f in file_list if f[-4:] == '.dat']
I frammenti di codice di esempio di questa epopea provengono dal `src/feature-engineering-pass1/preprocessing.py` file fornito nell'allegato. | Scienziato dei dati, ingegnere ML |
| Dividi i file in sottogruppi in base al numero di vCPU. | I file devono essere divisi in sottogruppi o blocchi di dimensioni uguali, a seconda del numero di v CPUs presenti nell'istanza che esegue lo script. Per questo passaggio, puoi implementare un codice simile al seguente.# Split list of files into sub-lists
cpu_count = multiprocessing.cpu_count()
splits = int(len(dat_list) / cpu_count)
if splits == 0: splits = 1
dat_chunks = list(chunks(dat_list, splits))
| Scienziato dei dati, ingegnere ML |
| Parallelizza l'elaborazione dei sottogruppi su v. CPUs | La logica dello script deve essere configurata per elaborare tutti i sottogruppi in parallelo. A tale scopo, utilizzate la `Parallel ` classe e il `delayed ` metodo della libreria Joblib come segue. # Parallelize processing of sub-lists across CPUs
ws_df_list = Parallel(n_jobs=-1, verbose=0)(delayed(run_process)(dc) for dc in dat_chunks)
| Scienziato dei dati, ingegnere ML |
| Salva l'output di un singolo gruppo di file su Amazon S3. | Una volta completata l'elaborazione parallela della vCPU, i risultati di ciascuna vCPU devono essere combinati e caricati nel percorso del bucket S3 del gruppo di file. Per questo passaggio, è possibile utilizzare un codice simile al seguente.# Compile and pickle patient group dataframe
ws_df_group = pd.concat(ws_df_list)
ws_df_group = ws_df_group.reset_index().rename(columns={'index': 'signal'})
ws_df_group.to_json(os.path.join(output_dir, group_data_out))
| Scienziato dei dati, ingegnere ML |
### Configura il secondo script di preelaborazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Combina i file di dati prodotti in tutti i processi di elaborazione che hanno eseguito il primo script. | Lo script precedente genera un singolo file per ogni processo di SageMaker elaborazione che elabora un gruppo di file dal set di dati. Successivamente, è necessario combinare questi file di output in un unico oggetto e scrivere un singolo set di dati di output su Amazon S3. Ciò è dimostrato nel `src/feature-engineering-pass1p5/preprocessing.py` file, fornito nell'allegato, come segue.def write_parquet(wavs_df, path):
"""
Write waveform summary dataframe to S3 in parquet format.
:param wavs_df: waveform summary dataframe
:param path: S3 directory prefix
:type wavs_df: pandas dataframe
:type path: str
:return: None
"""
extra_args = {"ServerSideEncryption": "aws:kms"}
wr.s3.to_parquet(
df=wavs_df,
path=path,
compression='snappy',
s3_additional_kwargs=extra_args)
def combine_data():
"""
Get combined data and write to parquet.
:return: waveform summary dataframe
:rtype: pandas dataframe
"""
wavs_df = get_data()
wavs_df = normalize_signal_names(wavs_df)
write_parquet(wavs_df, "s3://{}/{}/{}".format(bucket_xform, dataset_prefix, pass1p5out_data))
return wavs_df
wavs_df = combine_data()
| Scienziato dei dati, ingegnere ML |
### Esegui processi di elaborazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esegui il primo processo di elaborazione. | Per eseguire il macrosharding, esegui un processo di elaborazione separato per ogni gruppo di file. Il microsharding viene eseguito all'interno di ogni processo di elaborazione, poiché ogni lavoro esegue il primo script. Il codice seguente mostra come avviare un processo di elaborazione per ogni directory del gruppo di file nel seguente frammento (incluso in). `notebooks/FeatExtract_Pass1.ipynb`pat_groups = list(range(30,40))
ts = str(int(time.time()))
for group in pat_groups:
sklearn_processor = SKLearnProcessor(framework_version='0.20.0',
role=role,
instance_type='ml.m5.4xlarge',
instance_count=1,
volume_size_in_gb=5)
sklearn_processor.run(
code='../src/feature-engineering-pass1/preprocessing.py',
job_name='-'.join(['scaled-processing-p1', str(group), ts]),
arguments=[
"input_path", "/opt/ml/processing/input",
"output_path", "/opt/ml/processing/output",
"group_data_out", "ws_df_group.json"
],
inputs=
[
ProcessingInput(
source=f's3://{sess.default_bucket()}/data_inputs/{group}',
destination='/opt/ml/processing/input',
s3_data_distribution_type='FullyReplicated'
)
],
outputs=
[
ProcessingOutput(
source='/opt/ml/processing/output',
destination=f's3://{sess.default_bucket()}/data_outputs/{group}'
)
],
wait=False
)
| Scienziato dei dati, ingegnere ML |
| Esegui il secondo processo di elaborazione. | Per combinare gli output generati dal primo set di processi di elaborazione ed eseguire eventuali calcoli aggiuntivi per la preelaborazione, si esegue il secondo script utilizzando un singolo SageMaker processo di elaborazione. Il codice seguente lo dimostra (incluso in). `notebooks/FeatExtract_Pass1p5.ipynb`ts = str(int(time.time()))
bucket = sess.default_bucket()
sklearn_processor = SKLearnProcessor(framework_version='0.20.0',
role=role,
instance_type='ml.t3.2xlarge',
instance_count=1,
volume_size_in_gb=5)
sklearn_processor.run(
code='../src/feature-engineering-pass1p5/preprocessing.py',
job_name='-'.join(['scaled-processing', 'p1p5', ts]),
arguments=['bucket', bucket,
'pass1out_prefix', 'data_outputs',
'pass1out_data', 'ws_df_group.json',
'pass1p5out_data', 'waveform_summary.parquet',
'statsdata_name', 'signal_stats.csv'],
wait=True
)
| Scienziato dei dati, ingegnere ML |
## Risorse correlate
+ Effettua l'[onboarding su Amazon SageMaker Studio utilizzando Quick Start](https://docs.aws.amazon.com/sagemaker/latest/dg/onboard-quick-start.html) (SageMaker documentazione)
+ [Dati di processo](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) (SageMaker documentazione)
+ [Elaborazione dei dati con scikit-learn (documentazione](https://docs.aws.amazon.com/sagemaker/latest/dg/use-scikit-learn-processing-container.html)) SageMaker
+ [Documentazione Joblib.parallel](https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html)
+ Moody, B., Moody, G., Villarroel, M., Clifford, G.D. e Silva, I. (2020). Database delle forme d'[onda MIMIC-III](https://doi.org/10.13026/c2607m) (versione 1.0). *PhysioNet*.
+ Johnson, A.E.W., Pollard, TJ, Shen, L., Lehman, L.H., Feng, M., Ghassemi, M., Moody, B., Szolovits, P., Celi, L.A. e Mark, R.G. (2016). [MIMIC-III](https://dx.doi.org/10.1038/sdata.2016.35), un database di terapia intensiva accessibile gratuitamente. Dati scientifici, 3, 160035.
+ [Licenza del database MIMIC-III Waveform](https://physionet.org/content/mimic3wdb/1.0/LICENSE.txt)
## Allegati
[Per accedere al contenuto aggiuntivo associato a questo documento, decomprimi il seguente file: attachment.zip](samples/p-attach/e7a90b31-de8f-41fd-bb3f-c7c6100fc306/attachments/attachment.zip)
# Visualizza i risultati AI/ML del modello utilizzando Flask e AWS Elastic Beanstalk
*Chris Caudill e Durga Sury, Amazon Web Services*
## Riepilogo
La visualizzazione dei risultati dei servizi di intelligenza artificiale e machine learning (AI/ML) spesso richiede chiamate API complesse che devono essere personalizzate dai tuoi sviluppatori e ingegneri. Questo può essere uno svantaggio se gli analisti vogliono esplorare rapidamente un nuovo set di dati.
È possibile migliorare l'accessibilità dei servizi e fornire una forma più interattiva di analisi dei dati utilizzando un'interfaccia utente (UI) basata sul Web che consente agli utenti di caricare i propri dati e visualizzare i risultati del modello in una dashboard.
Questo modello utilizza [Flask](https://flask.palletsprojects.com/en/2.0.x/) e [Plotly](https://plotly.com/) per integrare Amazon Comprehend con un'applicazione web personalizzata e visualizzare sentimenti ed entità a partire dai dati forniti dagli utenti. Il modello fornisce anche i passaggi per distribuire un'applicazione utilizzando AWS Elastic Beanstalk. Puoi adattare l'applicazione utilizzando i servizi di [intelligenza artificiale di Amazon Web Services (AWS)](https://aws.amazon.com/machine-learning/ai-services/) o con un modello addestrato personalizzato ospitato su un endpoint (ad esempio, un [ SageMaker endpoint Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html)).
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account AWS attivo.
+ AWS Command Line Interface (AWS CLI), installata e configurata sul computer locale. Per ulteriori informazioni su questo argomento, consulta le nozioni di [base sulla configurazione nella documentazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html) dell'interfaccia a riga di comando di AWS. Puoi anche utilizzare un ambiente di sviluppo integrato (IDE) AWS Cloud9; per ulteriori informazioni su questo argomento, consulta il [tutorial di Python per AWS Cloud9 e l'anteprima delle applicazioni in esecuzione nell'IDE AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/sample-python.html) [nella documentazione di AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/app-preview.html).
**Avviso: non è più disponibile per i nuovi clienti.** AWS Cloud9 I clienti esistenti di AWS Cloud9 possono continuare a utilizzare il servizio normalmente. [Ulteriori informazioni](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)
+ Comprensione del framework di applicazioni web di Flask. Per ulteriori informazioni su Flask, consulta il [Quickstart](https://flask.palletsprojects.com/en/1.1.x/quickstart) nella documentazione di Flask.
+ Python versione 3.6 o successiva, installato e configurato. Puoi installare Python seguendo le istruzioni contenute in [Configurazione dell'ambiente di sviluppo Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-development-environment.html) nella documentazione di AWS Elastic Beanstalk.
+ Elastic Beanstalk Command Line Interface (EB CLI), installata e configurata. Per ulteriori informazioni su questo argomento, consulta [Installare l'EB CLI e [Configurare l'EB CLI](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3-configuration.html)](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3-install.html) dalla documentazione di AWS Elastic Beanstalk.
**Limitazioni**
+ L'applicazione Flask di questo pattern è progettata per funzionare con file.csv che utilizzano una singola colonna di testo e sono limitati a 200 righe. Il codice dell'applicazione può essere adattato per gestire altri tipi di file e volumi di dati.
+ L'applicazione non considera la conservazione dei dati e continua ad aggregare i file utente caricati fino a quando non vengono eliminati manualmente. Puoi integrare l'applicazione con Amazon Simple Storage Service (Amazon S3) per lo storage persistente di oggetti o utilizzare un database come Amazon DynamoDB per lo storage di chiave-valore senza server.
+ L'applicazione prende in considerazione solo i documenti in lingua inglese. Tuttavia, puoi utilizzare Amazon Comprehend per rilevare la lingua principale di un documento. Per ulteriori informazioni sulle lingue supportate per ogni azione, consulta il [riferimento all'API](https://docs.aws.amazon.com/comprehend/latest/dg/API_Reference.html) nella documentazione di Amazon Comprehend.
+ Un elenco di risoluzione dei problemi che contiene gli errori più comuni e le relative soluzioni è disponibile nella sezione *Informazioni aggiuntive*.
## Architecture
**Architettura dell'applicazione Flask**
Flask è un framework leggero per lo sviluppo di applicazioni web in Python. È progettato per combinare la potente elaborazione dei dati di Python con una ricca interfaccia utente web. L'applicazione Flask del pattern mostra come creare un'applicazione Web che consenta agli utenti di caricare dati, inviarli ad Amazon Comprehend per l'inferenza e quindi visualizzare i risultati. L'applicazione ha la seguente struttura:
+ `static`— Contiene tutti i file statici che supportano l'interfaccia utente Web (ad esempio JavaScript, CSS e immagini)
+ `templates`— Contiene tutte le pagine HTML dell'applicazione
+ `userData`— Memorizza i dati utente caricati
+ `application.py`— Il file dell'applicazione Flask
+ `comprehend_helper.py`— Funzioni per effettuare chiamate API verso Amazon Comprehend
+ `config.py`— Il file di configurazione dell'applicazione
+ `requirements.txt`— Le dipendenze Python richieste dall'applicazione
Lo `application.py` script contiene le funzionalità principali dell'applicazione Web, che consiste in quattro percorsi Flask. Il diagramma seguente mostra questi percorsi Flask.
![\[I quattro percorsi Flask che costituiscono la funzionalità principale dell'applicazione web.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/03d80cf1-ec97-43f7-adb5-2746a9ec70e6/images/9ca6bad1-26e2-4262-98d0-d54c172336bf.png)
+ `/`è la radice dell'applicazione e indirizza gli utenti alla `upload.html` pagina (memorizzata nella `templates` directory).
+ `/saveFile`è una route che viene richiamata dopo che un utente carica un file. Questo percorso riceve una `POST` richiesta tramite un modulo HTML, che contiene il file caricato dall'utente. Il file viene salvato nella `userData` directory e il percorso reindirizza gli utenti al `/dashboard` percorso.
+ `/dashboard`invia gli utenti alla pagina. `dashboard.html` All'interno del codice HTML di questa pagina, esegue il JavaScript codice `static/js/core.js` che legge i dati dal `/data` percorso e quindi crea visualizzazioni per la pagina.
+ `/data`è un'API JSON che presenta i dati da visualizzare nella dashboard. Questo percorso legge i dati forniti dall'utente e utilizza le funzioni `comprehend_helper.py` per inviare i dati utente ad Amazon Comprehend per l'analisi del sentiment e il riconoscimento delle entità nominate (NER). La risposta di Amazon Comprehend viene formattata e restituita come oggetto JSON.
**Architettura di distribuzione**
![\[Diagramma di architettura per l'utilizzo di Flask ed Elastic Beanstalk per visualizzare i risultati del modello. AI/ML\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/03d80cf1-ec97-43f7-adb5-2746a9ec70e6/images/d691bfd2-e2ec-4830-8bff-ffa1e3a95c4a.png)
[Considerazioni di progettazione](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/concepts.concepts.design.html)
Per ulteriori informazioni sulle considerazioni di progettazione per le applicazioni distribuite utilizzando Elastic Beanstalk sul cloud AWS, consulta la documentazione di AWS Elastic Beanstalk.
**Stack tecnologico**
+ Amazon Comprehend
+ Elastic Beanstalk
+ Flask
**Automazione e scalabilità**
Le implementazioni di Elastic Beanstalk vengono configurate automaticamente con sistemi di bilanciamento del carico e gruppi di auto scaling. Per ulteriori opzioni di configurazione, consulta [Configurazione degli ambienti Elastic Beanstalk nella documentazione di AWS Elastic](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/customize-containers.html) Beanstalk.
## Tools (Strumenti)
+ [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)) è uno strumento unificato che fornisce un'interfaccia coerente per interagire con tutte le parti di AWS.
+ [Amazon Comprehend](https://docs.aws.amazon.com/comprehend/latest/dg/comprehend-general.html) utilizza l'elaborazione del linguaggio naturale (NLP) per estrarre informazioni dettagliate sul contenuto dei documenti senza richiedere una preelaborazione speciale.
+ [AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/Welcome.html) ti aiuta a distribuire e gestire rapidamente le applicazioni nel cloud AWS senza dover conoscere l'infrastruttura che esegue tali applicazioni.
+ [Elastic Beanstalk CLI (EB CLI)](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb-cli3.html) è un'interfaccia a riga di comando per AWS Elastic Beanstalk che fornisce comandi interattivi per semplificare la creazione, l'aggiornamento e il monitoraggio di ambienti da un repository locale.
+ Il framework [Flask](https://flask.palletsprojects.com/en/2.0.x/) esegue l'elaborazione dei dati e le chiamate API utilizzando Python e offre una visualizzazione web interattiva con Plotly.
**Codice**
Il codice per questo modello è disponibile nei [risultati del AI/ML modello GitHub Visualize utilizzando Flask e il repository AWS Elastic Beanstalk](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask).
## Epiche
### Configura l'applicazione Flask
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona il GitHub repository. | Estrai il codice dell'applicazione dai [risultati del AI/ML modello GitHub Visualize utilizzando Flask e il repository AWS Elastic Beanstalk eseguendo il seguente comando](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask):`git clone git@github.com:aws-samples/aws-comprehend-elasticbeanstalk-for-flask.git`Assicurati di configurare le tue chiavi SSH con. GitHub | Developer |
| Installa i moduli Python. | Dopo aver clonato il repository, viene creata una nuova `aws-comprehend-elasticbeanstalk-for-flask` directory locale. In quella directory, il `requirements.txt` file contiene i moduli e le versioni di Python che eseguono l'applicazione. Utilizzate i seguenti comandi per installare i moduli:`cd aws-comprehend-elasticbeanstalk-for-flask``pip install -r requirements.txt` | Sviluppatore Python |
| Prova l'applicazione localmente. | Avvia il server Flask eseguendo il seguente comando:`python application.py`Ciò restituisce informazioni sul server in esecuzione. Dovresti essere in grado di accedere all'applicazione aprendo un browser e visitando http://localhost:5000Se esegui l'applicazione in un IDE AWS Cloud9, devi sostituire `application.run()` il comando nel file con `application.py` la seguente riga:`application.run(host=os.getenv('IP', '0.0.0.0'),port=int(os.getenv('PORT', 8080)))`È necessario annullare questa modifica prima della distribuzione. | Sviluppatore Python |
### Distribuisci l'applicazione su Elastic Beanstalk
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Avvia l'applicazione Elastic Beanstalk. | Per avviare il progetto come applicazione Elastic Beanstalk, esegui il seguente comando dalla directory principale dell'applicazione:`eb init -p python-3.6 comprehend_flask --region us-east-1`[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html)Esegui il `eb init -i` comando per ulteriori opzioni di configurazione della distribuzione. | Architetto, sviluppatore |
| Implementa l'ambiente Elastic Beanstalk. | Esegui il comando seguente dalla directory principale dell'applicazione:`eb create comprehend-flask-env``comprehend-flask-env`è il nome dell'ambiente Elastic Beanstalk e può essere modificato in base alle proprie esigenze. Il nome può contenere solo lettere, numeri e trattini. | Architetto, sviluppatore |
| Autorizza la tua distribuzione all'uso di Amazon Comprehend. | Sebbene la tua applicazione possa essere stata distribuita correttamente, dovresti anche fornire alla distribuzione l'accesso ad Amazon Comprehend. `ComprehendFullAccess`è una policy gestita da AWS che fornisce all'applicazione distribuita le autorizzazioni per effettuare chiamate API verso Amazon Comprehend.Allega la `ComprehendFullAccess` policy a `aws-elasticbeanstalk-ec2-role` (questo ruolo viene creato automaticamente per le istanze Amazon Elastic Compute Cloud (Amazon EC2) della tua distribuzione) eseguendo il seguente comando:`aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/ComprehendFullAccess --role-name aws-elasticbeanstalk-ec2-role``aws-elasticbeanstalk-ec2-role`viene creato quando l'applicazione viene distribuita. È necessario completare il processo di distribuzione prima di poter allegare la policy di AWS Identity and Access Management (IAM). | Sviluppatore, architetto della sicurezza |
| Visita la tua applicazione distribuita. | Dopo che l'applicazione è stata distribuita correttamente, puoi visitarla eseguendo il `eb open` comando.Puoi anche eseguire il `eb status` comando per ricevere dettagli sulla distribuzione. L'URL di distribuzione è elencato sotto`CNAME`. | Architetto, sviluppatore |
### (Facoltativo) Personalizza l'applicazione in base al tuo modello ML
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Autorizza Elastic Beanstalk ad accedere al nuovo modello. | Assicurati che Elastic Beanstalk disponga delle autorizzazioni di accesso necessarie per il tuo nuovo endpoint modello. Ad esempio, se utilizzi un SageMaker endpoint Amazon, la tua distribuzione deve disporre dell'autorizzazione per richiamare l'endpoint. Per ulteriori informazioni a riguardo, [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)consulta la SageMaker documentazione di Amazon. | Sviluppatore, architetto della sicurezza |
| Invia i dati dell'utente a un nuovo modello. | Per modificare il modello ML sottostante in questa applicazione, è necessario modificare i seguenti file:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html) | Data Scientist |
| Aggiorna le visualizzazioni del pannello di controllo. | In genere, incorporare un nuovo modello ML significa che le visualizzazioni devono essere aggiornate per riflettere i nuovi risultati. Queste modifiche vengono apportate nei seguenti file:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/visualize-ai-ml-model-results-using-flask-and-aws-elastic-beanstalk.html) | Sviluppatore web |
### (Facoltativo) Distribuisci l'applicazione aggiornata
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aggiorna il file dei requisiti dell'applicazione. | Prima di inviare modifiche a Elastic Beanstalk, `requirements.txt` aggiorna il file in modo che rifletta eventuali nuovi moduli Python eseguendo il seguente comando nella directory principale dell'applicazione:`pip freeze > requirements.txt` | Sviluppatore Python |
| Ridistribuisci l'ambiente Elastic Beanstalk. | Per assicurarti che le modifiche all'applicazione si riflettano nella distribuzione di Elastic Beanstalk, vai alla directory principale dell'applicazione ed esegui il comando seguente:`eb deploy`Questo invia la versione più recente del codice dell'applicazione alla distribuzione esistente di Elastic Beanstalk. | Amministratore di sistema, Architetto |
## Risorse correlate
+ [Chiama un endpoint SageMaker modello Amazon utilizzando Amazon API Gateway e AWS Lambda](https://aws.amazon.com/blogs/machine-learning/call-an-amazon-sagemaker-model-endpoint-using-amazon-api-gateway-and-aws-lambda/)
+ [Distribuzione di un'applicazione Flask su Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create-deploy-python-flask.html)
+ [Riferimento ai comandi CLI EB](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/eb3-cmd-commands.html)
+ [Configurazione dell'ambiente di sviluppo Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-development-environment.html)
## Informazioni aggiuntive
**Elenco di risoluzione dei problemi**
Di seguito sono riportati sei errori comuni e le relative soluzioni.
***Errore 1***
```
Unable to assume role "arn:aws:iam::xxxxxxxxxx:role/aws-elasticbeanstalk-ec2-role". Verify that the role exists and is configured correctly.
```
**Soluzione**: se questo errore si verifica durante l'esecuzione`eb create`, crea un'applicazione di esempio sulla console Elastic Beanstalk per creare il profilo di istanza predefinito. Per ulteriori informazioni su questo argomento, consulta [Creazione di un ambiente Elastic Beanstalk nella documentazione di AWS Elastic](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/using-features.environments.html) Beanstalk.
***Errore 2***
```
Your WSGIPath refers to a file that does not exist.
```
**Soluzione:** questo errore si verifica nei registri di distribuzione perché Elastic Beanstalk prevede che il codice Flask venga denominato. `application.py` Se hai scelto un nome diverso, eseguilo `eb config` e modificalo WSGIPath come mostrato nel seguente esempio di codice:
```
aws:elasticbeanstalk:container:python:
NumProcesses: '1'
NumThreads: '15'
StaticFiles: /static/=static/
WSGIPath: application.py
```
Assicurati di sostituirlo `application.py` con il nome del file.
Puoi anche sfruttare Gunicorn e un Procfile. Per ulteriori informazioni su questo approccio, consulta [Configurazione del server WSGI con un Procfile](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/python-configuration-procfile.html) nella documentazione di AWS Elastic Beanstalk.
***Errore 3***
```
Target WSGI script '/opt/python/current/app/application.py' does not contain WSGI application 'application'.
```
**Soluzione:** Elastic Beanstalk si aspetta che la variabile che rappresenta l'applicazione Flask venga denominata. `application` Assicurati che il `application.py` file utilizzi `application` come nome della variabile:
```
application = Flask(__name__)
```
***Errore 4***
```
The EB CLI cannot find your SSH key file for keyname
```
**Soluzione:** utilizza l'EB CLI per specificare quale coppia di chiavi utilizzare o per creare una coppia di chiavi per le istanze EC2 della distribuzione. Per risolvere l'errore, esegui `eb init -i` e una delle opzioni chiederà:
```
Do you want to set up SSH for your instances?
```
`Y`Rispondi con per creare una coppia di chiavi o specificare una coppia di chiavi esistente.
***Errore 5***
*Ho aggiornato il codice e l'ho ridistribuito, ma la mia distribuzione non riflette le mie modifiche.*
**Soluzione**: se utilizzi un repository Git con la tua distribuzione, assicurati di aggiungere e confermare le modifiche prima di ridistribuirle.
***Errore 6***
*Stai visualizzando l'anteprima dell'applicazione Flask da un IDE AWS Cloud9 e riscontri degli errori.*
**Soluzione:** per ulteriori informazioni su questo argomento, consulta [Anteprima delle applicazioni in esecuzione nell'IDE AWS Cloud9 nella documentazione di AWS](https://docs.aws.amazon.com/cloud9/latest/user-guide/app-preview.html) Cloud9.
**Elaborazione del linguaggio naturale con Amazon Comprehend**
Scegliendo di utilizzare Amazon Comprehend, puoi rilevare entità personalizzate in singoli documenti di testo eseguendo analisi in tempo reale o processi batch asincroni. Amazon Comprehend consente inoltre di addestrare modelli personalizzati di riconoscimento delle entità e classificazione del testo che possono essere utilizzati in tempo reale creando un endpoint.
Questo modello utilizza processi batch asincroni per rilevare sentimenti ed entità da un file di input che contiene più documenti. L'applicazione di esempio fornita da questo modello è progettata per consentire agli utenti di caricare un file.csv contenente una singola colonna con un documento di testo per riga. Il `comprehend_helper.py` file nei [risultati del AI/ML modello GitHub Visualize utilizzando Flask e il repository AWS Elastic Beanstalk legge il file di input e invia l'input ad Amazon](https://github.com/aws-samples/aws-comprehend-elasticbeanstalk-for-flask) Comprehend per l'elaborazione.
*BatchDetectEntities*
Amazon Comprehend esamina il testo di un batch di documenti alla ricerca di entità denominate e restituisce l'entità, l'ubicazione, il [tipo di entità](https://docs.aws.amazon.com/comprehend/latest/dg/how-entities.html) rilevati e un punteggio che indica il livello di fiducia di Amazon Comprehend. È possibile inviare un massimo di 25 documenti in una chiamata API, con ogni documento di dimensioni inferiori a 5.000 byte. Puoi filtrare i risultati per mostrare solo determinate entità in base al caso d'uso. Ad esempio, è possibile ignorare il tipo di `‘quantity’` entità e impostare un punteggio di soglia per l'entità rilevata (ad esempio, 0,75). Ti consigliamo di esaminare i risultati per il tuo caso d'uso specifico prima di scegliere un valore di soglia. Per ulteriori informazioni su questo argomento, consulta la [BatchDetectEntities](https://docs.aws.amazon.com/comprehend/latest/dg/API_BatchDetectEntities.html)documentazione di Amazon Comprehend.
*BatchDetectSentiment*
Amazon Comprehend ispeziona un batch di documenti in entrata e restituisce il sentimento prevalente per ogni documento (,, o). `POSITIVE` `NEUTRAL` `MIXED` `NEGATIVE` È possibile inviare un massimo di 25 documenti in una chiamata API, con ogni documento di dimensioni inferiori a 5.000 byte. L'analisi del sentimento è semplice e puoi scegliere il sentimento con il punteggio più alto da visualizzare nei risultati finali. Per ulteriori informazioni su questo argomento, consulta la [BatchDetectSentiment](https://docs.aws.amazon.com/comprehend/latest/dg/API_BatchDetectSentiment.html)documentazione di Amazon Comprehend.
**Gestione della configurazione di Flask**
I server Flask utilizzano una serie di [variabili di configurazione](https://flask.palletsprojects.com/en/1.1.x/config/) per controllare il funzionamento del server. Queste variabili possono contenere output di debug, token di sessione o altre impostazioni dell'applicazione. È inoltre possibile definire variabili personalizzate a cui è possibile accedere mentre l'applicazione è in esecuzione. Esistono diversi approcci per l'impostazione delle variabili di configurazione.
In questo modello, la configurazione è definita `config.py` ed ereditata all'interno`application.py`.
+
**Nota**
`config.py`contiene le variabili di configurazione impostate all'avvio dell'applicazione. In questa applicazione, viene definita una `DEBUG` variabile per indicare all'applicazione di eseguire il server in [modalità di debug](https://flask.palletsprojects.com/en/1.1.x/config/#DEBUG). : la modalità di debug non deve essere utilizzata quando si esegue un'applicazione in un ambiente di produzione. `UPLOAD_FOLDER`è una variabile personalizzata definita per essere referenziata più avanti nell'applicazione e che indica dove devono essere archiviati i dati utente caricati.
+ `application.py`avvia l'applicazione Flask ed eredita le impostazioni di configurazione definite in. `config.py` Questa operazione viene eseguita dal seguente codice:
```
application = Flask(__name__)
application.config.from_pyfile('config.py')
```
# Altri modelli
**Topics**
+ [Accelera MLOps con Backstage e modelli Amazon SageMaker AI self-service](accelerate-mlops-with-backstage-and-sagemaker-templates.md)
+ [Automatizza le operazioni AWS dell'infrastruttura utilizzando Amazon Bedrock](automate-aws-infrastructure-operations-by-using-amazon-bedrock.md)
+ [Implementa sistemi agentici su Amazon Bedrock con il framework CrewAI utilizzando Terraform](deploy-agentic-systems-on-amazon-bedrock-with-the-crewai-framework.md)
+ [Implementa una ChatOps soluzione per gestire i risultati della scansione SAST utilizzando Amazon Q Developer nelle applicazioni di chat, azioni personalizzate e CloudFormation](deploy-chatops-solution-to-manage-sast-scan-results.md)
+ [Genera approfondimenti sui dati utilizzando Modernizzazione del mainframe AWS Amazon Q in Quick Sight](generate-data-insights-by-using-aws-mainframe-modernization-and-amazon-q-in-quicksight.md)
+ [Genera approfondimenti sui z/OS dati Db2 utilizzando Modernizzazione del mainframe AWS Amazon Q in Quick Sight](generate-db2-zos-data-insights-aws-mainframe-modernization-amazon-q-in-quicksight.md)
+ [Offri alle istanze di SageMaker notebook l'accesso temporaneo a un CodeCommit repository in un altro account AWS](give-sagemaker-notebook-instances-temporary-access-to-a-codecommit-repository-in-another-aws-account.md)
+ [Gestisci AWS Organizations le policy come codice utilizzando AWS CodePipeline Amazon Bedrock](manage-organizations-policies-as-code.md)
+ [Modernizza l'applicazione CardDemo mainframe utilizzando AWS Transform](modernize-carddemo-mainframe-app.md)
+ [Modernizza e implementa le applicazioni mainframe utilizzando e Terraform AWS Transform](modernize-mainframe-app-transform-terraform.md)
+ [Esegui analisi avanzate con Amazon Redshift ML](perform-advanced-analytics-using-amazon-redshift-ml.md)
+ [Semplifica la gestione EC2 della conformità di Amazon con agenti Amazon Bedrock e AWS Config](streamline-amazon-ec2-compliance-management-with-amazon-bedrock-agents-and-aws-config.md)
+ [Semplifica lo sviluppo e la distribuzione di bot Amazon Lex utilizzando un flusso di lavoro automatizzato](streamline-amazon-lex-bot-development-and-deployment-using-an-automated-workflow.md)
+ [Risolvi i problemi relativi agli stati AWS Step Functions utilizzando Amazon Bedrock](troubleshooting-states-in-aws-step-functions.md)