Etter hvert som kunder akselererer migreringene til skyen og transformerer virksomheten sin, befinner noen seg i situasjoner der de må administrere IT-drift i et multiskymiljø. For eksempel kan du ha kjøpt et selskap som allerede kjørte på en annen skyleverandør, eller du kan ha en arbeidsbelastning som genererer verdi fra unike funksjoner levert av AWS. Et annet eksempel er uavhengige programvareleverandører (ISV-er) som gjør produktene og tjenestene sine tilgjengelige i forskjellige skyplattformer til fordel for sluttkundene. Eller en organisasjon kan operere i en region der en primær skyleverandør ikke er tilgjengelig, og for å oppfylle kravene til datasuverenitet eller dataopphold, kan de bruke en sekundær skyleverandør.
I disse scenariene, når du begynner å omfavne generativ AI, store språkmodeller (LLM) og maskinlæringsteknologier (ML) som en kjernedel av virksomheten din, kan det hende du ser etter alternativer for å dra nytte av AWS AI og ML funksjoner utenfor AWS i et multicloud-miljø. For eksempel kan det være lurt å benytte seg av Amazon SageMaker å bygge og trene ML-modell, eller bruke Amazon SageMaker Jumpstart å distribuere forhåndsbygde foundation- eller tredjeparts ML-modeller, som du kan distribuere ved å klikke på noen få knapper. Eller du vil kanskje dra nytte av Amazonas grunnfjell å bygge og skalere generative AI-applikasjoner, eller du kan utnytte AWS sine ferdigtrente AI-tjenester, som ikke krever at du lærer maskinlæringsferdigheter. AWS gir støtte for scenarier der organisasjoner ønsker det ta med sin egen modell til Amazon SageMaker or inn i Amazon SageMaker Canvas for spådommer.
I dette innlegget viser vi et av de mange alternativene du har for å dra nytte av AWSs bredeste og dypeste sett med AI/ML-funksjoner i et multiskymiljø. Vi viser hvordan du kan bygge og trene en ML-modell i AWS og distribuere modellen i en annen plattform. Vi trener modellen ved å bruke Amazon SageMaker, lagrer modellartefaktene i Amazon enkel lagringstjeneste (Amazon S3), og distribuer og kjør modellen i Azure. Denne tilnærmingen er fordelaktig hvis du bruker AWS-tjenester for ML for det mest omfattende settet med funksjoner, men du må kjøre modellen din i en annen skyleverandør i en av situasjonene vi har diskutert.
Nøkkelkonsepter
Amazon SageMaker Studio er et nettbasert, integrert utviklingsmiljø (IDE) for maskinlæring. SageMaker Studio lar dataforskere, ML-ingeniører og dataingeniører forberede data, bygge, trene og distribuere ML-modeller på ett nettgrensesnitt. Med SageMaker Studio kan du få tilgang til spesialbygde verktøy for alle stadier av ML-utviklingslivssyklusen, fra dataforberedelse til bygging, opplæring og distribusjon av ML-modellene dine, noe som forbedrer datavitenskapsteamets produktivitet med opptil ti ganger. SageMaker Studio notatbøker er hurtigstartende, samarbeidende notatbøker som integreres med spesialbygde ML-verktøy i SageMaker og andre AWS-tjenester.
SageMaker er en omfattende ML-tjeneste som gjør det mulig for forretningsanalytikere, dataforskere og MLOps-ingeniører å bygge, trene og distribuere ML-modeller for enhver brukssituasjon, uavhengig av ML-ekspertise.
AWS gir Deep Learning Containers (DLC-er) for populære ML-rammeverk som PyTorch, TensorFlow og Apache MXNet, som du kan bruke med SageMaker for trening og slutninger. DLC-er er tilgjengelige som Docker-bilder i Amazon Elastic Container Registry (Amazon ECR). Docker-bildene er forhåndsinstallert og testet med de nyeste versjonene av populære dyplæringsrammeverk samt andre avhengigheter som trengs for opplæring og slutninger. For en fullstendig liste over de forhåndsbygde Docker-bildene administrert av SageMaker, se Docker-registerbaner og eksempelkode. Amazon ECR støtter sikkerhetsskanning, og er integrert med Amazon-inspektør sårbarhetsadministrasjonstjeneste for å møte organisasjonens sikkerhetskrav for bildeoverholdelse, og for å automatisere skanning av sårbarhetsvurderinger. Organisasjoner kan også bruke AWS Trainium og AWS slutning for bedre pris-ytelse for å kjøre ML-treningsjobber eller slutninger.
Løsningsoversikt
I denne delen beskriver vi hvordan du bygger og trener en modell ved hjelp av SageMaker og distribuerer modellen til Azure Functions. Vi bruker en SageMaker Studio-notisbok for å bygge, trene og distribuere modellen. Vi trener modellen i SageMaker ved å bruke et forhåndsbygd Docker-bilde for PyTorch. Selv om vi distribuerer den opplærte modellen til Azure i dette tilfellet, kan du bruke den samme tilnærmingen til å distribuere modellen på andre plattformer, for eksempel i lokaler eller andre skyplattformer.
Når vi oppretter en treningsjobb, lanserer SageMaker ML-beregningsforekomstene og bruker opplæringskoden vår og opplæringsdatasettet for å trene modellen. Den lagrer de resulterende modellartefakter og andre utdata i en S3-bøtte som vi spesifiserer som input til treningsjobben. Når modellopplæringen er fullført, bruker vi Åpne Neural Network Exchange (ONNX) kjøretidsbibliotek for å eksportere PyTorch-modellen som en ONNX-modell.
Til slutt distribuerer vi ONNX-modellen sammen med en tilpasset slutningskode skrevet i Python til Azure-funksjoner ved å bruke Azure CLI. ONNX støtter det meste ofte brukte ML-rammeverk og verktøy. En ting å merke seg er at å konvertere en ML-modell til ONNX er nyttig hvis du vil bruke et annet rammeverk for måldistribusjon, for eksempel PyTorch til TensorFlow. Hvis du bruker samme rammeverk på både kilden og målet, trenger du ikke konvertere modellen til ONNX-format.
Følgende diagram illustrerer arkitekturen for denne tilnærmingen.
Vi bruker en SageMaker Studio notatbok sammen med SageMaker Python SDK å bygge og trene modellen vår. SageMaker Python SDK er et åpen kildekode-bibliotek for opplæring og distribusjon av ML-modeller på SageMaker. For flere detaljer, se Opprett eller åpne en Amazon SageMaker Studio Notebook.
Kodebitene i de følgende delene er testet i SageMaker Studio-notebookmiljøet ved å bruke Data Science 3.0-bildet og Python 3.0-kjernen.
I denne løsningen demonstrerer vi følgende trinn:
- Tren en PyTorch-modell.
- Eksporter PyTorch-modellen som en ONNX-modell.
- Pakk modellen og slutningskoden.
- Distribuer modellen til Azure Functions.
Forutsetninger
Du bør ha følgende forutsetninger:
- En AWS-konto.
- Et SageMaker-domene og SageMaker Studio-bruker. For instruksjoner for å lage disse, se Ombord på Amazon SageMaker-domene ved hjelp av hurtigoppsett.
- Azure CLI.
- Tilgang til Azure og legitimasjon for en tjenesteprinsipal som har tillatelser til å opprette og administrere Azure-funksjoner.
Tren en modell med PyTorch
I denne delen beskriver vi trinnene for å trene en PyTorch-modell.
Installer avhengigheter
Installer bibliotekene for å utføre trinnene som kreves for modellopplæring og modellimplementering:
pip install torchvision onnx onnxruntime
Fullfør innledende oppsett
Vi begynner med å importere AWS SDK for Python (Boto3) og SageMaker Python SDK. Som en del av oppsettet definerer vi følgende:
- Et øktobjekt som gir praktiske metoder innenfor konteksten av SageMaker og vår egen konto.
- En SageMaker-rolle som ARN brukte for å delegere tillatelser til opplærings- og vertstjenesten. Vi trenger dette slik at disse tjenestene kan få tilgang til S3-bøttene der dataene og modellen vår er lagret. For instruksjoner om hvordan du oppretter en rolle som dekker forretningsbehovene dine, se SageMaker-roller. For dette innlegget bruker vi den samme utførelsesrollen som Studio-notebook-forekomsten vår. Denne rollen får vi ved å ringe
sagemaker.get_execution_role()
. - Standardregionen hvor treningsjobben vår skal utføres.
- Standard bøtte og prefikset vi bruker til å lagre modellutdata.
Se følgende kode:
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"
Lag opplæringsdatasettet
Vi bruker datasettet som er tilgjengelig i den offentlige bøtten sagemaker-example-files-prod-{region}
. Datasettet inneholder følgende filer:
- train-images-idx3-ubyte.gz – Inneholder bilder av treningssett
- tog-etiketter-idx1-ubyte.gz – Inneholder etiketter på treningssett
- t10k-images-idx3-ubyte.gz – Inneholder testsettbilder
- t10k-labels-idx1-ubyte.gz – Inneholder testsettetiketter
Vi brukertorchvision.datasets
modul for å laste ned dataene fra den offentlige bøtten lokalt før du laster den opp til vår treningsdatabøtte. Vi passerer denne bøtteplasseringen som et innspill til SageMaker-treningsjobben. Vårt opplæringsskript bruker denne plasseringen til å laste ned og forberede treningsdataene, og deretter trene modellen. Se følgende kode:
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,))] ),
)
Lag treningsskriptet
Med SageMaker kan du ta med din egen modell vha skriptmodus. Med skriptmodus kan du bruke de forhåndsbygde SageMaker-beholderne og gi ditt eget treningsskript, som har modelldefinisjonen, sammen med eventuelle tilpassede biblioteker og avhengigheter. De SageMaker Python SDK passerer manuset vårt som en entry_point
til containeren, som laster og kjører togfunksjonen fra det medfølgende skriptet for å trene modellen vår.
Når opplæringen er fullført, lagrer SageMaker modellutgangen i S3-bøtta som vi ga som parameter til treningsjobben.
Vår treningskode er tilpasset fra følgende PyTorch eksempelskript. Følgende utdrag fra koden viser modelldefinisjonen og togfunksjonen:
# 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
Tren modellen
Nå som vi har satt opp miljøet vårt og laget vårt input-datasett og tilpassede opplæringsskript, kan vi starte modellopplæringen ved å bruke SageMaker. Vi bruker PyTorch-estimatoren i SageMaker Python SDK for å starte en treningsjobb på SageMaker. Vi sender inn de nødvendige parameterne til estimatoren og kaller tilpasningsmetoden. Når vi kaller fit på PyTorch-estimatoren, starter SageMaker en treningsjobb ved å bruke skriptet vårt som treningskode:
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}"
})
Eksporter den trente modellen som en ONNX-modell
Etter at opplæringen er fullført og vår modell er lagret til det forhåndsdefinerte stedet i Amazon S3, eksporterer vi modellen til en ONNX-modell ved å bruke ONNX-runtime.
Vi inkluderer koden for å eksportere modellen vår til ONNX i treningsskriptet vårt for å kjøre etter at opplæringen er fullført.
PyTorch eksporterer modellen til ONNX ved å kjøre modellen ved å bruke vår input og registrere et spor av operatører som brukes til å beregne utdata. Vi bruker en tilfeldig inngang av riktig type med PyTorch torch.onnx.export
funksjon for å eksportere modellen til ONNX. Vi spesifiserer også den første dimensjonen i inputen vår som dynamisk slik at modellen vår aksepterer en variabel batch_size
av innganger under inferens.
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 er et åpent standardformat for dyplæringsmodeller som muliggjør interoperabilitet mellom dyplæringsrammeverk som PyTorch, Microsoft Cognitive Toolkit (CNTK) og mer. Dette betyr at du kan bruke hvilket som helst av disse rammeverkene til å trene modellen og deretter eksportere de forhåndstrente modellene i ONNX-format. Ved å eksportere modellen til ONNX får du fordelen av et bredere utvalg av distribusjonsenheter og plattformer.
Last ned og trekk ut modellartefakter
ONNX-modellen som treningsskriptet vårt har lagret har blitt kopiert av SageMaker til Amazon S3 på utdatastedet som vi spesifiserte da vi startet opplæringsjobben. Modellartefaktene lagres som en komprimert arkivfil kalt model.tar.gz
. Vi laster ned denne arkivfilen til en lokal katalog i vår Studio notebook-forekomst og trekker ut modellartefakter, nemlig ONNX-modellen.
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()
Valider ONNX-modellen
ONNX-modellen eksporteres til en fil med navn mnist-pytorch.onnx
etter treningsskriptet vårt. Etter at vi har lastet ned og pakket ut denne filen, kan vi valgfritt validere ONNX-modellen ved å bruke onnx.checker
modul. De check_model
funksjonen i denne modulen sjekker konsistensen til en modell. Et unntak gjøres hvis testen mislykkes.
import onnx onnx_model = onnx.load("mnist-pytorch.onnx")
onnx.checker.check_model(onnx_model)
Pakk modellen og slutningskoden
For dette innlegget bruker vi .zip-distribusjon for Azure Functions. I denne metoden pakker vi modellen vår, tilhørende kode og Azure Functions-innstillinger i en .zip-fil og publiserer den til Azure Functions. Følgende kode viser katalogstrukturen til distribusjonspakken vår:
mnist-onnx
├── function_app.py
├── model
│ └── mnist-pytorch.onnx
└── requirements.txt
Liste avhengigheter
Vi viser avhengighetene for slutningskoden vår i requirements.txt
fil i roten av pakken vår. Denne filen brukes til å bygge Azure Functions-miljøet når vi publiserer pakken.
azure-functions
numpy
onnxruntime
Skriv slutningskode
Vi bruker Python til å skrive følgende inferenskode, ved å bruke ONNX Runtime-biblioteket for å laste modellen vår og kjøre inferens. Dette instruerer Azure Functions-appen om å gjøre endepunktet tilgjengelig på /classify
relativ vei.
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 )
Distribuer modellen til Azure Functions
Nå som vi har pakket inn koden i det nødvendige .zip-formatet, er vi klare til å publisere den til Azure Functions. Vi gjør det ved å bruke Azure CLI, et kommandolinjeverktøy for å opprette og administrere Azure-ressurser. Installer Azure CLI med følgende kode:
!pip install -q azure-cli
Fullfør deretter følgende trinn:
- Logg på Azure:
!az login
- Sett opp ressursopprettingsparametrene:
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}"
- Bruk følgende kommandoer for å opprette Azure Functions-appen sammen med de nødvendige ressursene:
!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}
- Konfigurer Azure Functions slik at når vi distribuerer Functions-pakken,
requirements.txt
filen brukes til å bygge våre applikasjonsavhengigheter:!az functionapp config appsettings set --name {function_app} --resource-group {resource_group_name} --settings @./functionapp/settings.json
- Konfigurer Functions-appen til å kjøre Python v2-modellen og utfør en build på koden den mottar etter .zip-distribusjon:
{ "AzureWebJobsFeatureFlags": "EnableWorkerIndexing", "SCM_DO_BUILD_DURING_DEPLOYMENT": true }
- Etter at vi har ressursgruppen, lagringsbeholderen og Functions-appen med riktig konfigurasjon, publiserer du koden til Functions-appen:
!az functionapp deployment source config-zip -g {resource_group_name} -n {function_app} --src {function_archive} --build-remote true
Test modellen
Vi har distribuert ML-modellen til Azure Functions som en HTTP-utløser, noe som betyr at vi kan bruke URL-adressen til funksjoner-appen til å sende en HTTP-forespørsel til funksjonen for å starte funksjonen og kjøre modellen.
For å forberede inndataene, last ned testbildefilene fra SageMaker-eksempelfilene og klargjør et sett med prøver til formatet som kreves av modellen:
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))
Bruk forespørselsbiblioteket til å sende en postforespørsel til slutningsendepunktet med eksempelinngangene. Slutningsendepunktet har formatet som vist i følgende kode:
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']
Rydd opp
Når du er ferdig med å teste modellen, sletter du ressursgruppen sammen med de inneholdte ressursene, inkludert lagringsbeholderen og funksjoner-appen:
!az group delete --name {resource_group_name} --yes
I tillegg anbefales det å stenge ledige ressurser i SageMaker Studio for å redusere kostnadene. For mer informasjon, se Spar kostnader ved automatisk å slå av ledige ressurser i Amazon SageMaker Studio.
konklusjonen
I dette innlegget viste vi hvordan du kan bygge og trene en ML-modell med SageMaker og distribuere den til en annen skyleverandør. I løsningen brukte vi en SageMaker Studio-notisbok, men for produksjonsbelastninger anbefalte vi å bruke MLOps å lage repeterbare treningsarbeidsflyter for å akselerere modellutvikling og distribusjon.
Dette innlegget viste ikke alle mulige måter å distribuere og kjøre en modell i et multicloud-miljø. Du kan for eksempel også pakke modellen inn i et beholderbilde sammen med slutningskode og avhengighetsbiblioteker for å kjøre modellen som en beholderapplikasjon på en hvilken som helst plattform. For mer informasjon om denne tilnærmingen, se Distribuer containerapplikasjoner i et multicloud-miljø ved hjelp av Amazon CodeCatalyst. Hensikten med innlegget er å vise hvordan organisasjoner kan bruke AWS AI/ML-funksjoner i et multicloud-miljø.
Om forfatterne
Raja Vaidyanathan er en løsningsarkitekt hos AWS som støtter globale finansielle tjenester-kunder. Raja jobber med kunder for å bygge løsninger på komplekse problemer med langsiktig positiv innvirkning på virksomheten deres. Han er en sterk ingeniørfaglig dyktig innen IT-strategi, bedriftsdataadministrasjon og applikasjonsarkitektur, med spesielle interesser i analyse og maskinlæring.
Amandeep Bajwa er en senior løsningsarkitekt hos AWS som støtter finansielle tjenester. Han hjelper organisasjoner med å oppnå sine forretningsresultater ved å identifisere passende skytransformasjonsstrategi basert på bransjetrender og organisatoriske prioriteringer. Noen av områdene Amandeep rådfører seg med er skymigrering, skystrategi (inkludert hybrid og multicloud), digital transformasjon, data og analyser og teknologi generelt.
Prema Iyer er Senior Technical Account Manager for AWS Enterprise Support. Hun jobber med eksterne kunder på en rekke prosjekter, og hjelper dem med å forbedre verdien av løsningene deres når de bruker AWS.
- SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
- PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
- PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
- PlatoESG. Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
- PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
- kilde: https://aws.amazon.com/blogs/machine-learning/train-and-deploy-ml-models-in-a-multicloud-environment-using-amazon-sagemaker/
- : har
- :er
- :ikke
- :hvor
- $OPP
- 1
- 10
- 100
- 13
- 25
- 28
- 32
- 7
- 9
- a
- Om oss
- akselerere
- godtar
- adgang
- Logg inn
- Oppnå
- ervervet
- Fordel
- Etter
- AI
- AI / ML
- Alle
- tillater
- langs
- allerede
- også
- Selv
- Amazon
- Amazon SageMaker
- Amazon SageMaker Canvas
- Amazon SageMaker Studio
- Amazon Web Services
- an
- analytikere
- analytics
- og
- Anonym
- En annen
- noen
- Apache
- app
- Søknad
- søknader
- tilnærming
- hensiktsmessig
- arkitektur
- Arkiv
- ER
- områder
- AS
- evaluering
- At
- automatisere
- automatisk
- tilgjengelig
- AWS
- AKSER
- Azure
- basert
- BE
- vært
- før du
- begynne
- gunstig
- nytte
- Bedre
- mellom
- både
- bringe
- bredere
- bygge
- Bygning
- virksomhet
- men
- by
- ring
- som heter
- ringer
- CAN
- lerret
- evner
- bære
- saken
- Sjekker
- klasse
- Klassifisere
- klikk
- Cloud
- kode
- kognitiv
- samarbeids
- Selskapet
- fullføre
- komplekse
- samsvar
- omfattende
- Beregn
- Konfigurasjon
- inneholdt
- Container
- Containere
- inneholder
- kontekst
- bekvemmelighet
- konvertere
- konvertering
- Kjerne
- Kostnader
- kunne
- skape
- opprettet
- Opprette
- skaperverket
- Credentials
- skikk
- Kunder
- dato
- Dataledelse
- Dataklargjøring
- datavitenskap
- datasett
- dyp
- dyp læring
- dypeste
- Misligholde
- definere
- definisjon
- demonstrere
- avhengig
- Avhengighet
- utplassere
- utplassert
- utplasserings
- distribusjon
- beskrive
- detalj
- detaljer
- Utvikling
- enhet
- Enheter
- forskjellig
- digitalt
- Digital Transformation
- sifre
- Dimensjon
- diskutert
- do
- Docker
- domene
- gjort
- ikke
- ned
- nedlasting
- under
- dynamisk
- e
- ellers
- omfavne
- muliggjør
- muliggjør
- slutt
- Endpoint
- Ingeniørarbeid
- Ingeniører
- Enterprise
- bedrifter
- Miljø
- epoke
- epoker
- Hver
- eksempel
- Unntatt
- unntak
- gjennomføring
- ekspertise
- eksportere
- eksporten
- utvendig
- trekke ut
- mislykkes
- Egenskaper
- Noen få
- filet
- Filer
- finansiell
- finansielle tjenester
- Finn
- Først
- passer
- etter
- Til
- format
- Fundament
- Rammeverk
- rammer
- fra
- funksjon
- funksjoner
- general
- genererer
- generative
- Generativ AI
- få
- Global
- global finansiell
- Gruppe
- Ha
- he
- hjelpe
- hjelper
- Hosting
- Hvordan
- Hvordan
- HTML
- http
- HTTPS
- Hybrid
- ID
- identifisering
- Idle
- if
- illustrerer
- bilde
- bilder
- Påvirkning
- importere
- importere
- forbedre
- bedre
- in
- inkludere
- Inkludert
- uavhengig
- industri
- informasjon
- innledende
- inngang
- innganger
- installere
- f.eks
- instruksjoner
- integrere
- integrert
- hensikt
- interesser
- Interface
- Interoperabilitet
- inn
- IT
- DET ER
- Jobb
- Jobb
- jpg
- JSON
- Språk
- stor
- siste
- lanseringer
- LÆRE
- læring
- Lengde
- Leverage
- bibliotekene
- Bibliotek
- Livssyklus
- linje
- linux
- Liste
- laste
- laster
- lokal
- lokalt
- plassering
- logging
- langsiktig
- ser
- tap
- maskin
- maskinlæring
- gjøre
- administrer
- fikk til
- ledelse
- leder
- mange
- kart
- matplotlib
- Kan..
- midler
- Møt
- møter
- metode
- metoder
- Microsoft
- kunne
- migrasjon
- ML
- MLOps
- Mote
- modell
- modeller
- Moduler
- mer
- mest
- navn
- oppkalt
- nemlig
- Trenger
- nødvendig
- behov
- nett
- nettverk
- nevrale
- nevrale nettverket
- bærbare
- følelsesløs
- objekt
- of
- on
- ONE
- åpen
- åpen kildekode
- drift
- Drift
- operatører
- alternativer
- or
- rekkefølge
- organisasjon
- organisasjons
- organisasjoner
- OS
- Annen
- vår
- ut
- utfall
- produksjon
- utenfor
- egen
- pakke
- pakket
- parameter
- parametere
- del
- Spesielt
- parti
- passere
- passerer
- banen
- Utfør
- tillatelser
- plattform
- Plattformer
- plato
- Platon Data Intelligence
- PlatonData
- Populær
- positiv
- mulig
- Post
- Spådommer
- forberedelse
- Forbered
- forutsetninger
- primære
- Principal
- problemer
- Bearbeidet
- Produksjon
- produktivitet
- Produkter
- profesjonell
- prosjekter
- gi
- forutsatt
- leverandør
- gir
- offentlig
- publisere
- Python
- pytorch
- Rask
- hevet
- tilfeldig
- klar
- mottar
- anbefales
- innspilling
- redusere
- referere
- Uansett
- region
- registret
- slektning
- repeterbar
- anmode
- forespørsler
- krever
- påkrevd
- Krav
- ressurs
- Ressurser
- svar
- resultere
- resulterende
- retur
- ikke sant
- Rolle
- root
- Kjør
- rennende
- går
- sagemaker
- samme
- lagret
- Skala
- skanning
- scenarier
- Vitenskap
- forskere
- script
- SDK
- sekundær
- Seksjon
- seksjoner
- sikkerhet
- se
- utvalg
- SELV
- send
- senior
- tjeneste
- Tjenester
- Session
- sett
- innstillinger
- oppsett
- Form
- hun
- bør
- Vis
- viste
- vist
- Viser
- Slå
- nedleggelse
- Enkelt
- situasjoner
- dyktig
- ferdigheter
- So
- Software
- løsning
- Solutions
- noen
- kilde
- suverenitet
- spesifisert
- Scene
- Standard
- Begynn
- startet
- starter
- Steps
- lagring
- oppbevare
- lagret
- Strategi
- String
- sterk
- struktur
- studio
- I ettertid
- vellykket
- slik
- støtte
- Støtte
- Støtter
- Ta
- tar
- Target
- lag
- Teknisk
- Technologies
- Teknologi
- ti
- tensorflow
- test
- testet
- Testing
- tekst
- Det
- De
- Kilden
- deres
- Dem
- seg
- deretter
- Disse
- de
- ting
- Tredje
- denne
- ganger
- til
- verktøykasse
- verktøy
- lommelykt
- Torchvision
- Trace
- Tog
- trent
- Kurs
- Transform
- Transformation
- Transformasjonsstrategi
- transforme
- Trender
- utløse
- utløst
- sant
- prøve
- typen
- unik
- lastet opp
- Opplasting
- URL
- bruke
- bruk sak
- brukt
- Bruker
- bruker
- ved hjelp av
- verktøyet
- VALIDERE
- verdi
- variabel
- variasjon
- leverandører
- versjoner
- sårbarhet
- ønsker
- var
- måter
- we
- web
- webtjenester
- Web-basert
- VI VIL
- når
- hvilken
- vil
- med
- innenfor
- arbeidsflyt
- virker
- skrive
- skrevet
- X
- ennå
- Du
- Din
- zephyrnet
- Zip