Mentre i clienti accelerano la migrazione al cloud e trasformano il proprio business, alcuni si ritrovano in situazioni in cui devono gestire le operazioni IT in un ambiente multicloud. Ad esempio, potresti aver acquisito un'azienda che già utilizzava un altro provider cloud oppure potresti avere un carico di lavoro che genera valore dalle funzionalità uniche fornite da AWS. Un altro esempio sono i fornitori di software indipendenti (ISV) che rendono disponibili i propri prodotti e servizi su diverse piattaforme cloud a vantaggio dei propri clienti finali. Oppure un'organizzazione potrebbe operare in una regione in cui un fornitore cloud primario non è disponibile e, per soddisfare i requisiti di sovranità o residenza dei dati, può utilizzare un fornitore cloud secondario.
In questi scenari, quando inizi ad abbracciare l’intelligenza artificiale generativa, i modelli linguistici di grandi dimensioni (LLM) e le tecnologie di machine learning (ML) come parte fondamentale della tua attività, potresti cercare opzioni da cui trarre vantaggio IA e machine learning di AWS funzionalità al di fuori di AWS in un ambiente multicloud. Ad esempio, potresti voler utilizzare Amazon Sage Maker per creare e addestrare il modello ML o utilizzarlo Avviamento di Amazon SageMaker per distribuire modelli di base predefiniti o ML di terze parti, che puoi distribuire con un clic di pochi pulsanti. Oppure potresti volerne approfittare Roccia Amazzonica per creare e scalare applicazioni di intelligenza artificiale generativa oppure puoi sfruttarle Servizi IA preaddestrati di AWS, che non richiedono l'apprendimento di competenze di machine learning. AWS fornisce supporto per gli scenari in cui le organizzazioni lo desiderano portare il proprio modello su Amazon SageMaker or in Amazon SageMaker Canvas per le previsioni.
In questo post, mostriamo una delle tante opzioni a tua disposizione per sfruttare il set più ampio e approfondito di funzionalità AI/ML di AWS in un ambiente multicloud. Mostriamo come creare e addestrare un modello ML in AWS e distribuire il modello su un'altra piattaforma. Addestriamo il modello utilizzando Amazon SageMaker, archiviamo gli artefatti del modello Servizio di archiviazione semplice Amazon (Amazon S3) e distribuire ed eseguire il modello in Azure. Questo approccio è vantaggioso se utilizzi i servizi AWS per ML per il suo set di funzionalità più completo, ma devi eseguire il tuo modello in un altro provider cloud in una delle situazioni di cui abbiamo discusso.
Concetti chiave
Amazon Sage Maker Studio è un ambiente di sviluppo integrato (IDE) basato sul web per l'apprendimento automatico. SageMaker Studio consente a data scientist, ingegneri ML e data engineer di preparare dati, creare, addestrare e distribuire modelli ML su un'unica interfaccia web. Con SageMaker Studio puoi accedere a strumenti specifici per ogni fase del ciclo di vita dello sviluppo ML, dalla preparazione dei dati alla creazione, formazione e distribuzione dei modelli ML, migliorando la produttività del team di data science fino a dieci volte. Quaderni SageMaker Studio sono notebook collaborativi e di avvio rapido che si integrano con strumenti ML appositamente creati in SageMaker e altri servizi AWS.
SageMaker è un servizio ML completo che consente ad analisti aziendali, data scientist e ingegneri MLOps di creare, addestrare e distribuire modelli ML per qualsiasi caso d'uso, indipendentemente dalle competenze ML.
AWS fornisce Contenitori di apprendimento profondo (DLC) per framework ML diffusi come PyTorch, TensorFlow e Apache MXNet, che puoi utilizzare con SageMaker per l'addestramento e l'inferenza. I DLC sono disponibili come immagini Docker in Registro dei contenitori Amazon Elastic (Amazon ECR). Le immagini Docker sono preinstallate e testate con le versioni più recenti dei più diffusi framework di deep learning e con altre dipendenze necessarie per l'addestramento e l'inferenza. Per un elenco completo delle immagini Docker predefinite gestite da SageMaker, vedere Percorsi del registro Docker e codice di esempio. Amazon ECR supporta la scansione di sicurezza ed è integrato con Ispettore Amazon servizio di gestione delle vulnerabilità per soddisfare i requisiti di sicurezza della conformità delle immagini dell'organizzazione e per automatizzare la scansione della valutazione delle vulnerabilità. Anche le organizzazioni possono utilizzare AWSTrainium ed AWS Inferenza per un migliore rapporto qualità-prezzo per l'esecuzione di lavori di formazione o inferenza ML.
Panoramica della soluzione
In questa sezione viene descritto come creare e addestrare un modello utilizzando SageMaker e distribuire il modello in Funzioni di Azure. Utilizziamo un notebook SageMaker Studio per creare, addestrare e distribuire il modello. Addestriamo il modello in SageMaker utilizzando un'immagine Docker precostruita per PyTorch. Anche se in questo caso stiamo distribuendo il modello addestrato in Azure, puoi usare lo stesso approccio per distribuire il modello su altre piattaforme, ad esempio in locale o su altre piattaforme cloud.
Quando creiamo un processo di training, SageMaker avvia le istanze di calcolo ML e utilizza il nostro codice di training e il set di dati di training per addestrare il modello. Salva gli artefatti del modello risultanti e altri output in un bucket S3 che specifichiamo come input per il processo di training. Una volta completato l'addestramento del modello, utilizziamo il file Apri scambio di reti neurali (ONNX) libreria runtime per esportare il modello PyTorch come modello ONNX.
Infine, distribuiamo il modello ONNX insieme a un codice di inferenza personalizzato scritto in Python in Funzioni di Azure usando l'interfaccia della riga di comando di Azure. ONNX supporta la maggior parte dei framework e strumenti ML comunemente utilizzati. Una cosa da notare è che la conversione di un modello ML in ONNX è utile se si desidera utilizzare un framework di distribuzione di destinazione diverso, ad esempio PyTorch in TensorFlow. Se utilizzi lo stesso framework sia sull'origine che sulla destinazione, non è necessario convertire il modello nel formato ONNX.
Il diagramma seguente illustra l'architettura di questo approccio.
Utilizziamo un notebook SageMaker Studio insieme al SDK Python di SageMaker per costruire e addestrare il nostro modello. SageMaker Python SDK è una libreria open source per il training e la distribuzione di modelli ML su SageMaker. Per ulteriori dettagli, fare riferimento a Crea o apri un notebook Amazon SageMaker Studio.
I frammenti di codice nelle sezioni seguenti sono stati testati nell'ambiente notebook SageMaker Studio utilizzando l'immagine Data Science 3.0 e il kernel Python 3.0.
In questa soluzione, mostriamo i seguenti passaggi:
- Addestra un modello PyTorch.
- Esporta il modello PyTorch come modello ONNX.
- Creare un pacchetto del modello e del codice di inferenza.
- Distribuire il modello in Funzioni di Azure.
Prerequisiti
Dovresti avere i seguenti prerequisiti:
- Un account AWS.
- Un dominio SageMaker e un utente SageMaker Studio. Per istruzioni su come crearli, fare riferimento a Integrazione nel dominio Amazon SageMaker utilizzando la configurazione rapida.
- L'interfaccia della riga di comando di Azure.
- Accesso ad Azure e credenziali per un'entità servizio che dispone delle autorizzazioni per creare e gestire Funzioni di Azure.
Addestra un modello con PyTorch
In questa sezione vengono descritti in dettaglio i passaggi per addestrare un modello PyTorch.
Installa le dipendenze
Installa le librerie per eseguire i passaggi necessari per l'addestramento e la distribuzione del modello:
pip install torchvision onnx onnxruntime
Completa la configurazione iniziale
Iniziamo importando il file SDK AWS per Python (Boto3) e la SDK Python di SageMaker. Come parte della configurazione, definiamo quanto segue:
- Un oggetto di sessione che fornisce metodi pratici nel contesto di SageMaker e del nostro account.
- Un ARN del ruolo SageMaker utilizzato per delegare le autorizzazioni al servizio di formazione e hosting. Ne abbiamo bisogno affinché questi servizi possano accedere ai bucket S3 in cui sono archiviati i nostri dati e il nostro modello. Per istruzioni sulla creazione di un ruolo che soddisfi le esigenze aziendali, fare riferimento a Ruoli di SageMaker. Per questo post utilizziamo lo stesso ruolo di esecuzione della nostra istanza notebook di Studio. Otteniamo questo ruolo chiamando
sagemaker.get_execution_role()
. - La regione predefinita in cui verrà eseguito il nostro processo di formazione.
- Il bucket predefinito e il prefisso che utilizziamo per archiviare l'output del modello.
Vedi il seguente codice:
import sagemaker
import boto3
import os execution_role = sagemaker.get_execution_role()
region = boto3.Session().region_name
session = sagemaker.Session()
bucket = session.default_bucket()
prefix = "sagemaker/mnist-pytorch"
Creare il set di dati di addestramento
Utilizziamo il set di dati disponibile nel bucket pubblico sagemaker-example-files-prod-{region}
. Il set di dati contiene i seguenti file:
- train-images-idx3-ubite.gz – Contiene immagini del set di formazione
- train-labels-idx1-ubite.gz – Contiene le etichette del set di training
- t10k-images-idx3-ubite.gz – Contiene immagini del set di test
- t10k-labels-idx1-ubite.gz – Contiene le etichette del set di test
Usiamo iltorchvision.datasets
modulo per scaricare i dati dal bucket pubblico localmente prima di caricarli nel nostro bucket di dati di addestramento. Passiamo questa posizione del bucket come input per il processo di formazione di SageMaker. Il nostro script di training utilizza questa posizione per scaricare e preparare i dati di training, quindi addestrare il modello. Vedere il seguente codice:
MNIST.mirrors = [ f"https://sagemaker-example-files-prod-{region}.s3.amazonaws.com/datasets/image/MNIST/"
] MNIST( "data", download=True, transform=transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))] ),
)
Creare lo script di formazione
Con SageMaker, puoi portare il tuo modello utilizzando modalità script. Con la modalità script, puoi utilizzare i contenitori SageMaker predefiniti e fornire il tuo script di formazione, che contiene la definizione del modello, insieme a eventuali librerie e dipendenze personalizzate. IL SDK Python di SageMaker passa il nostro script come un file entry_point
al contenitore, che carica ed esegue la funzione train dallo script fornito per addestrare il nostro modello.
Una volta completata la formazione, SageMaker salva l'output del modello nel bucket S3 che abbiamo fornito come parametro per il processo di formazione.
Il nostro codice di formazione è adattato da quanto segue Script di esempio PyTorch. Il seguente estratto dal codice mostra la definizione del modello e la funzione train:
# define network class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(1, 32, 3, 1) self.conv2 = nn.Conv2d(32, 64, 3, 1) self.dropout1 = nn.Dropout(0.25) self.dropout2 = nn.Dropout(0.5) self.fc1 = nn.Linear(9216, 128) self.fc2 = nn.Linear(128, 10) def forward(self, x): x = self.conv1(x) x = F.relu(x) x = self.conv2(x) x = F.relu(x) x = F.max_pool2d(x, 2) x = self.dropout1(x) x = torch.flatten(x, 1) x = self.fc1(x) x = F.relu(x) x = self.dropout2(x) x = self.fc2(x) output = F.log_softmax(x, dim=1) return output
# train def train(args, model, device, train_loader, optimizer, epoch): model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = F.nll_loss(output, target) loss.backward() optimizer.step() if batch_idx % args.log_interval == 0: print('Train Epoch: {} [{}/{} ({:.0f}%)]tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item())) if args.dry_run: break
Allena il modello
Ora che abbiamo configurato il nostro ambiente e creato il set di dati di input e lo script di training personalizzato, possiamo avviare il training del modello utilizzando SageMaker. Utilizziamo lo stimatore PyTorch nell'SDK Python di SageMaker per avviare un processo di formazione su SageMaker. Passiamo i parametri richiesti allo stimatore e chiamiamo il metodo fit. Quando chiamiamo fit sullo stimatore PyTorch, SageMaker avvia un processo di training utilizzando il nostro script come codice di training:
from sagemaker.pytorch import PyTorch output_location = f"s3://{bucket}/{prefix}/output"
print(f"training artifacts will be uploaded to: {output_location}") hyperparameters={ "batch-size": 100, "epochs": 1, "lr": 0.1, "gamma": 0.9, "log-interval": 100
} instance_type = "ml.c4.xlarge"
estimator = PyTorch( entry_point="train.py", source_dir="code", # directory of your training script role=execution_role, framework_version="1.13", py_version="py39", instance_type=instance_type, instance_count=1, volume_size=250, output_path=output_location, hyperparameters=hyperparameters
) estimator.fit(inputs = { 'training': f"{inputs}", 'testing': f"{inputs}"
})
Esporta il modello addestrato come modello ONNX
Una volta completata la formazione e salvato il nostro modello nella posizione predefinita in Amazon S3, esportiamo il modello in un modello ONNX utilizzando il runtime ONNX.
Includiamo il codice per esportare il nostro modello in ONNX nel nostro script di formazione da eseguire al termine della formazione.
PyTorch esporta il modello in ONNX eseguendo il modello utilizzando il nostro input e registrando una traccia degli operatori utilizzati per calcolare l'output. Usiamo un input casuale del tipo giusto con PyTorch torch.onnx.export
funzione per esportare il modello su ONNX. Specifichiamo anche la prima dimensione nel nostro input come dinamica in modo che il nostro modello accetti una variabile batch_size
degli input durante l’inferenza.
def export_to_onnx(model, model_dir, device): logger.info("Exporting the model to onnx.") dummy_input = torch.randn(1, 1, 28, 28).to(device) input_names = [ "input_0" ] output_names = [ "output_0" ] path = os.path.join(model_dir, 'mnist-pytorch.onnx') torch.onnx.export(model, dummy_input, path, verbose=True, input_names=input_names, output_names=output_names, dynamic_axes={'input_0' : {0 : 'batch_size'}, # variable length axes 'output_0' : {0 : 'batch_size'}})
ONNX è un formato standard aperto per modelli di deep learning che consente l'interoperabilità tra framework di deep learning come PyTorch, Microsoft Cognitive Toolkit (CNTK) e altri. Ciò significa che puoi utilizzare uno qualsiasi di questi framework per addestrare il modello e successivamente esportare i modelli preaddestrati in formato ONNX. Esportando il modello in ONNX, ottieni il vantaggio di una selezione più ampia di dispositivi e piattaforme di distribuzione.
Scaricare ed estrarre gli artefatti del modello
Il modello ONNX salvato dal nostro script di formazione è stato copiato da SageMaker su Amazon S3 nella posizione di output che abbiamo specificato quando abbiamo avviato il processo di formazione. Gli artefatti del modello vengono archiviati come file di archivio compresso chiamato model.tar.gz
. Scarichiamo questo file di archivio in una directory locale nella nostra istanza notebook di Studio ed estraiamo gli artefatti del modello, ovvero il modello ONNX.
import tarfile local_model_file = 'model.tar.gz'
model_bucket,model_key = estimator.model_data.split('/',2)[-1].split('/',1)
s3 = boto3.client("s3")
s3.download_file(model_bucket,model_key,local_model_file) model_tar = tarfile.open(local_model_file)
model_file_name = model_tar.next().name
model_tar.extractall('.')
model_tar.close()
Convalidare il modello ONNX
Il modello ONNX viene esportato in un file denominato mnist-pytorch.onnx
dal nostro script di formazione. Dopo aver scaricato ed estratto questo file, possiamo facoltativamente convalidare il modello ONNX utilizzando il file onnx.checker
modulo. Il check_model
La funzione in questo modulo controlla la coerenza di un modello. Viene sollevata un'eccezione se il test fallisce.
import onnx onnx_model = onnx.load("mnist-pytorch.onnx")
onnx.checker.check_model(onnx_model)
Creare un pacchetto del modello e del codice di inferenza
Per questo post usiamo la distribuzione .zip per Funzioni di Azure. Con questo metodo, confezioniamo il modello, il codice associato e le impostazioni di Funzioni di Azure in un file con estensione zip e lo pubblichiamo in Funzioni di Azure. Il codice seguente mostra la struttura delle directory del nostro pacchetto di distribuzione:
mnist-onnx
├── function_app.py
├── model
│ └── mnist-pytorch.onnx
└── requirements.txt
Elenca le dipendenze
Elenchiamo le dipendenze per il nostro codice di inferenza nel file requirements.txt
file nella radice del nostro pacchetto. Questo file viene usato per creare l'ambiente Funzioni di Azure quando pubblichiamo il pacchetto.
azure-functions
numpy
onnxruntime
Scrivi il codice di inferenza
Usiamo Python per scrivere il seguente codice di inferenza, utilizzando la libreria ONNX Runtime per caricare il nostro modello ed eseguire l'inferenza. Ciò indica all'app Funzioni di Azure di rendere l'endpoint disponibile nel file /classify
percorso relativo.
import logging
import azure.functions as func
import numpy as np
import os
import onnxruntime as ort
import json app = func.FunctionApp() def preprocess(input_data_json): # convert the JSON data into the tensor input return np.array(input_data_json['data']).astype('float32') def run_model(model_path, req_body): session = ort.InferenceSession(model_path) input_data = preprocess(req_body) logging.info(f"Input Data shape is {input_data.shape}.") input_name = session.get_inputs()[0].name # get the id of the first input of the model try: result = session.run([], {input_name: input_data}) except (RuntimeError) as e: print("Shape={0} and error={1}".format(input_data.shape, e)) return result[0] def get_model_path(): d=os.path.dirname(os.path.abspath(__file__)) return os.path.join(d , './model/mnist-pytorch.onnx') @app.function_name(name="mnist_classify")
@app.route(route="classify", auth_level=func.AuthLevel.ANONYMOUS)
def main(req: func.HttpRequest) -> func.HttpResponse: logging.info('Python HTTP trigger function processed a request.') # Get the img value from the post. try: req_body = req.get_json() except ValueError: pass if req_body: # run model result = run_model(get_model_path(), req_body) # map output to integer and return result string. digits = np.argmax(result, axis=1) logging.info(type(digits)) return func.HttpResponse(json.dumps({"digits": np.array(digits).tolist()})) else: return func.HttpResponse( "This HTTP triggered function successfully.", status_code=200 )
Distribuire il modello in Funzioni di Azure
Ora che abbiamo il codice compresso nel formato .zip richiesto, siamo pronti per pubblicarlo in Funzioni di Azure. A tale scopo, utilizziamo l'interfaccia della riga di comando di Azure, un'utilità della riga di comando per creare e gestire le risorse di Azure. Installa l'interfaccia della riga di comando di Azure con il codice seguente:
!pip install -q azure-cli
Quindi completare i seguenti passaggi:
- Accedi ad Azure:
!az login
- Imposta i parametri di creazione delle risorse:
import random random_suffix = str(random.randint(10000,99999)) resource_group_name = f"multicloud-{random_suffix}-rg" storage_account_name = f"multicloud{random_suffix}" location = "ukwest" sku_storage = "Standard_LRS" functions_version = "4" python_version = "3.9" function_app = f"multicloud-mnist-{random_suffix}"
- Usare i comandi seguenti per creare l'app Funzioni di Azure insieme alle risorse prerequisite:
!az group create --name {resource_group_name} --location {location} !az storage account create --name {storage_account_name} --resource-group {resource_group_name} --location {location} --sku {sku_storage} !az functionapp create --name {function_app} --resource-group {resource_group_name} --storage-account {storage_account_name} --consumption-plan-location "{location}" --os-type Linux --runtime python --runtime-version {python_version} --functions-version {functions_version}
- Configura le Funzioni di Azure in modo che quando distribuiamo il pacchetto Funzioni, il
requirements.txt
il file viene utilizzato per creare le dipendenze delle nostre applicazioni:!az functionapp config appsettings set --name {function_app} --resource-group {resource_group_name} --settings @./functionapp/settings.json
- Configura l'app Funzioni per eseguire il modello Python v2 ed eseguire una compilazione sul codice ricevuto dopo la distribuzione di .zip:
{ "AzureWebJobsFeatureFlags": "EnableWorkerIndexing", "SCM_DO_BUILD_DURING_DEPLOYMENT": true }
- Dopo aver ottenuto il gruppo di risorse, il contenitore di archiviazione e l'app Funzioni con la configurazione corretta, pubblica il codice nell'app Funzioni:
!az functionapp deployment source config-zip -g {resource_group_name} -n {function_app} --src {function_archive} --build-remote true
Prova il modello
Abbiamo distribuito il modello ML in Funzioni di Azure come trigger HTTP, il che significa che possiamo usare l'URL dell'app Funzioni per inviare una richiesta HTTP alla funzione per richiamare la funzione ed eseguire il modello.
Per preparare l'input, scarica i file delle immagini di test dal bucket dei file di esempio di SageMaker e prepara una serie di campioni nel formato richiesto dal modello:
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt transform=transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))]
) test_dataset = datasets.MNIST(root='../data', download=True, train=False, transform=transform)
test_loader = DataLoader(test_dataset, batch_size=16, shuffle=True) test_features, test_labels = next(iter(test_loader))
Utilizza la libreria delle richieste per inviare una richiesta post all'endpoint di inferenza con gli input di esempio. L'endpoint di inferenza assume il formato mostrato nel codice seguente:
import requests, json def to_numpy(tensor): return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy() url = f"https://{function_app}.azurewebsites.net/api/classify"
response = requests.post(url, json.dumps({"data":to_numpy(test_features).tolist()}) )
predictions = json.loads(response.text)['digits']
ripulire
Una volta terminato il test del modello, elimina il gruppo di risorse insieme alle risorse contenute, inclusi il contenitore di archiviazione e l'app Funzioni:
!az group delete --name {resource_group_name} --yes
Inoltre, si consiglia di disattivare le risorse inattive all'interno di SageMaker Studio per ridurre i costi. Per ulteriori informazioni, fare riferimento a Risparmia sui costi disattivando automaticamente le risorse inattive in Amazon SageMaker Studio.
Conclusione
In questo post abbiamo mostrato come creare e addestrare un modello ML con SageMaker e distribuirlo a un altro provider cloud. Nella soluzione abbiamo utilizzato un notebook SageMaker Studio, ma per i carichi di lavoro di produzione ne consigliamo l'utilizzo MLOp per creare flussi di lavoro di formazione ripetibili per accelerare lo sviluppo e l'implementazione del modello.
Questo post non ha mostrato tutti i modi possibili per distribuire ed eseguire un modello in un ambiente multicloud. Ad esempio, puoi anche inserire il modello in un'immagine contenitore insieme al codice di inferenza e alle librerie di dipendenze per eseguire il modello come applicazione containerizzata in qualsiasi piattaforma. Per ulteriori informazioni su questo approccio, fare riferimento a Distribuisci applicazioni container in un ambiente multicloud utilizzando Amazon CodeCatalyst. L'intento del post è mostrare come le organizzazioni possono utilizzare le funzionalità AI/ML di AWS in un ambiente multicloud.
Circa gli autori
Raja Vaidyanathan è un Solutions Architect presso AWS che supporta i clienti di servizi finanziari globali. Raja lavora con i clienti per progettare soluzioni a problemi complessi con un impatto positivo a lungo termine sulla loro attività. È un forte professionista di ingegneria esperto in strategia IT, gestione dei dati aziendali e architettura delle applicazioni, con particolare interesse per l'analisi e l'apprendimento automatico.
Amandeep Bajwa è un Senior Solutions Architect presso AWS a supporto delle imprese di servizi finanziari. Aiuta le organizzazioni a raggiungere i propri risultati aziendali identificando la strategia di trasformazione cloud appropriata in base alle tendenze del settore e alle priorità organizzative. Alcune delle aree su cui Amandeep fornisce consulenza sono la migrazione al cloud, la strategia cloud (inclusi ibridi e multicloud), la trasformazione digitale, i dati e l'analisi e la tecnologia in generale.
Prema Iyer è Senior Technical Account Manager per AWS Enterprise Support. Lavora con clienti esterni su una varietà di progetti, aiutandoli a migliorare il valore delle loro soluzioni quando utilizzano AWS.
- Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
- PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
- PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
- PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
- Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
- Fonte: https://aws.amazon.com/blogs/machine-learning/train-and-deploy-ml-models-in-a-multicloud-environment-using-amazon-sagemaker/
- :ha
- :È
- :non
- :Dove
- $ SU
- 1
- 10
- 100
- 13
- 25
- 28
- 32
- 7
- 9
- a
- WRI
- accelerare
- accetta
- accesso
- Il mio account
- Raggiungere
- acquisito
- Vantaggio
- Dopo shavasana, sedersi in silenzio; saluti;
- AI
- AI / ML
- Tutti
- consente
- lungo
- già
- anche
- Sebbene il
- Amazon
- Amazon Sage Maker
- Tela di Amazon SageMaker
- Amazon Sage Maker Studio
- Amazon Web Services
- an
- Gli analisti
- analitica
- ed
- Anonimo
- Un altro
- in qualsiasi
- Apache
- App
- Applicazioni
- applicazioni
- approccio
- opportuno
- architettura
- Archivio
- SONO
- aree
- AS
- valutazione
- At
- automatizzare
- automaticamente
- disponibile
- AWS
- ASSI
- azzurro
- basato
- BE
- stato
- prima
- iniziare
- benefico
- beneficio
- Meglio
- fra
- entrambi
- portare
- più ampia
- costruire
- Costruzione
- affari
- ma
- by
- chiamata
- detto
- chiamata
- Materiale
- tela
- funzionalità
- trasportare
- Custodie
- Controlli
- classe
- classificare
- clicca
- Cloud
- codice
- conoscitivo
- collaborativo
- azienda
- completamento di una
- complesso
- conformità
- globale
- Calcolare
- Configurazione
- contenute
- Contenitore
- Tecnologie Container
- contiene
- contesto
- comodità
- convertire
- conversione
- Nucleo
- Costi
- potuto
- creare
- creato
- Creazione
- creazione
- Credenziali
- costume
- Clienti
- dati
- gestione dei dati
- Preparazione dei dati
- scienza dei dati
- dataset
- deep
- apprendimento profondo
- più profondo
- Predefinito
- definire
- definizione
- dimostrare
- dipendenze
- Dipendenza
- schierare
- schierato
- distribuzione
- deployment
- descrivere
- dettaglio
- dettagli
- Mercato
- dispositivo
- dispositivi
- diverso
- digitale
- DIGITAL TRANSFORMATION
- cifre
- Dimensioni
- discusso
- do
- docker
- dominio
- fatto
- Dont
- giù
- scaricare
- durante
- dinamico
- e
- altro
- abbraccio
- Abilita
- consentendo
- fine
- endpoint
- Ingegneria
- Ingegneri
- Impresa
- aziende
- Ambiente
- epoca
- epoche
- Ogni
- esempio
- Tranne
- eccezione
- esecuzione
- competenza
- export
- le esportazioni
- esterno
- estratto
- fallisce
- Caratteristiche
- pochi
- Compila il
- File
- finanziario
- servizi finanziari
- Trovate
- Nome
- in forma
- i seguenti
- Nel
- formato
- Fondazione
- Contesto
- quadri
- da
- function
- funzioni
- Generale
- genera
- generativo
- AI generativa
- ottenere
- globali
- finanziaria globale
- Gruppo
- Avere
- he
- aiutare
- aiuta
- di hosting
- Come
- Tutorial
- HTML
- http
- HTTPS
- IBRIDO
- ID
- identificazione
- Idle
- if
- illustra
- Immagine
- immagini
- Impact
- importare
- importazione
- competenze
- miglioramento
- in
- includere
- Compreso
- studente indipendente
- industria
- informazioni
- inizialmente
- ingresso
- Ingressi
- install
- esempio
- istruzioni
- integrare
- integrato
- intento
- interessi
- Interfaccia
- Interoperabilità
- ai miglioramenti
- IT
- SUO
- Lavoro
- Offerte di lavoro
- jpg
- json
- Lingua
- grandi
- con i più recenti
- lancia
- IMPARARE
- apprendimento
- Lunghezza
- Leva
- biblioteche
- Biblioteca
- ciclo di vita
- linea
- linux
- Lista
- caricare
- carichi
- locale
- a livello locale
- località
- registrazione
- a lungo termine
- cerca
- spento
- macchina
- machine learning
- make
- gestire
- gestito
- gestione
- direttore
- molti
- carta geografica
- matplotlib
- Maggio..
- si intende
- Soddisfare
- Soddisfa
- metodo
- metodi
- Microsoft
- forza
- migrazione
- ML
- MLOp
- Moda
- modello
- modelli
- Moduli
- Scopri di più
- maggior parte
- Nome
- Detto
- cioè
- Bisogno
- di applicazione
- esigenze
- rete
- Rete
- neurale
- rete neurale
- taccuino
- numpy
- oggetto
- of
- on
- ONE
- aprire
- open source
- operativo
- Operazioni
- Operatori
- Opzioni
- or
- minimo
- organizzazione
- organizzativa
- organizzazioni
- OS
- Altro
- nostro
- su
- risultati
- produzione
- al di fuori
- proprio
- pacchetto
- confezionati
- parametro
- parametri
- parte
- particolare
- partito
- passare
- Passi
- sentiero
- Eseguire
- permessi
- piattaforma
- Piattaforme
- Platone
- Platone Data Intelligence
- PlatoneDati
- Popolare
- positivo
- possibile
- Post
- Previsioni
- preparazione
- Preparare
- prerequisiti
- primario
- Direttore
- problemi
- Elaborato
- Produzione
- della produttività
- Prodotti
- professionale
- progetti
- fornire
- purché
- fornitore
- fornisce
- la percezione
- pubblicare
- Python
- pytorch
- Presto
- sollevato
- casuale
- pronto
- riceve
- raccomandato
- registrazione
- ridurre
- riferimento
- Indipendentemente
- regione
- registro
- parente
- ripetibile
- richiesta
- richieste
- richiedere
- necessario
- Requisiti
- risorsa
- Risorse
- risposta
- colpevole
- risultante
- ritorno
- destra
- Ruolo
- radice
- Correre
- running
- corre
- sagemaker
- stesso
- salvato
- Scala
- scansione
- Scenari
- Scienze
- scienziati
- copione
- sdk
- secondario
- Sezione
- sezioni
- problemi di
- vedere
- prodotti
- AUTO
- inviare
- anziano
- servizio
- Servizi
- Sessione
- set
- impostazioni
- flessibile.
- Forma
- lei
- dovrebbero
- mostrare attraverso le sue creazioni
- ha mostrato
- mostrato
- Spettacoli
- fermare
- chiudendo
- Un'espansione
- situazioni
- qualificato
- abilità
- So
- Software
- soluzione
- Soluzioni
- alcuni
- Fonte
- sovranità
- specificato
- Stage
- Standard
- inizia a
- iniziato
- inizio
- Passi
- conservazione
- Tornare al suo account
- memorizzati
- Strategia
- Corda
- forte
- La struttura
- studio
- Successivamente
- Con successo
- tale
- supporto
- Supporto
- supporti
- Fai
- prende
- Target
- team
- Consulenza
- Tecnologie
- Tecnologia
- carnagione
- tensorflow
- test
- testato
- Testing
- testo
- che
- Il
- L’ORIGINE
- loro
- Li
- si
- poi
- Strumenti Bowman per analizzare le seguenti finiture:
- di
- cosa
- Terza
- questo
- volte
- a
- toolkit
- strumenti
- torcia
- Torciavisione
- Traccia
- Treni
- allenato
- Training
- Trasformare
- Trasformazione
- Strategia di trasformazione
- trasforma
- tendenze
- innescare
- innescato
- vero
- prova
- Digitare
- unico
- caricato
- Caricamento
- URL
- uso
- caso d'uso
- utilizzato
- Utente
- usa
- utilizzando
- utilità
- CONVALIDARE
- APPREZZIAMO
- variabile
- varietà
- fornitori
- versioni
- vulnerabilità
- volere
- Prima
- modi
- we
- sito web
- servizi web
- Web-basata
- WELL
- quando
- quale
- volere
- con
- entro
- flussi di lavoro
- lavori
- scrivere
- scritto
- X
- ancora
- Tu
- Trasferimento da aeroporto a Sharm
- zefiro
- Codice postale