När kunderna accelererar sina migreringar till molnet och omvandlar sin verksamhet, hamnar vissa i situationer där de måste hantera IT-drift i en multimolnmiljö. Till exempel kan du ha förvärvat ett företag som redan kördes på en annan molnleverantör, eller så kan du ha en arbetsbelastning som genererar värde från unika funktioner som tillhandahålls av AWS. Ett annat exempel är oberoende mjukvaruleverantörer (ISV) som gör sina produkter och tjänster tillgängliga i olika molnplattformar för att gynna sina slutkunder. Eller en organisation kan vara verksam i en region där en primär molnleverantör inte är tillgänglig, och för att uppfylla kraven på datasuveränitet eller datauppehållstillstånd kan de använda en sekundär molnleverantör.
I dessa scenarier, när du börjar omfamna generativ AI, stora språkmodeller (LLM) och maskininlärningsteknik (ML) som en central del av din verksamhet, kanske du letar efter alternativ att dra nytta av AWS AI och ML funktioner utanför AWS i en multimolnmiljö. Till exempel kanske du vill använda dig av Amazon SageMaker att bygga och träna ML-modell, eller använda Amazon SageMaker Jumpstart för att distribuera förbyggda grundmodeller eller tredjeparts ML-modeller, som du kan distribuera med ett klick på några knappar. Eller du kanske vill dra nytta av Amazonas berggrund att bygga och skala generativa AI-applikationer, eller så kan du dra nytta av det AWS förutbildade AI-tjänster, som inte kräver att du lär dig maskininlärning. AWS ger stöd för scenarier där organisationer vill ta med sin egen modell till Amazon SageMaker or till Amazon SageMaker Canvas för förutsägelser.
I det här inlägget visar vi ett av de många alternativ som du har för att dra fördel av AWS bredaste och djupaste uppsättning AI/ML-funktioner i en multimolnmiljö. Vi visar hur du kan bygga och träna en ML-modell i AWS och distribuera modellen i en annan plattform. Vi tränar modellen med Amazon SageMaker, lagrar modellartefakterna i Amazon enkel lagringstjänst (Amazon S3), och distribuera och kör modellen i Azure. Det här tillvägagångssättet är fördelaktigt om du använder AWS-tjänster för ML för dess mest omfattande uppsättning funktioner, men ändå måste du köra din modell i en annan molnleverantör i en av de situationer som vi har diskuterat.
Nyckelbegrepp
Amazon SageMaker Studio är en webbaserad, integrerad utvecklingsmiljö (IDE) för maskininlärning. SageMaker Studio låter datavetare, ML-ingenjörer och dataingenjörer förbereda data, bygga, träna och distribuera ML-modeller på ett webbgränssnitt. Med SageMaker Studio kan du få tillgång till specialbyggda verktyg för varje steg i ML-utvecklingslivscykeln, från dataförberedelse till att bygga, träna och distribuera dina ML-modeller, vilket förbättrar datavetenskapsteamets produktivitet med upp till tio gånger. SageMaker Studio anteckningsböcker är snabbstartade, samarbetsbara anteckningsböcker som integreras med specialbyggda ML-verktyg i SageMaker och andra AWS-tjänster.
SageMaker är en omfattande ML-tjänst som gör det möjligt för affärsanalytiker, datavetare och MLOps-ingenjörer att bygga, träna och distribuera ML-modeller för alla användningsfall, oavsett ML-expertis.
AWS tillhandahåller Deep Learning Containers (DLC) för populära ML-ramverk som PyTorch, TensorFlow och Apache MXNet, som du kan använda med SageMaker för träning och slutledning. DLC:er är tillgängliga som Docker-bilder i Amazon Elastic Container Registry (Amazon ECR). Docker-avbildningarna är förinstallerade och testade med de senaste versionerna av populära ramverk för djupinlärning samt andra beroenden som behövs för utbildning och slutledning. För en komplett lista över de förbyggda Docker-bilderna som hanteras av SageMaker, se Docker-registersökvägar och exempelkod. Amazon ECR stöder säkerhetsskanning och är integrerad med Amazon inspektör sårbarhetshanteringstjänst för att möta din organisations säkerhetskrav för bildefterlevnad och för att automatisera skanning av sårbarhetsbedömningar. Organisationer kan också använda AWS Trainium och AWS slutledning för bättre pris-prestanda för att köra ML-träningsjobb eller slutledning.
Lösningsöversikt
I det här avsnittet beskriver vi hur man bygger och tränar en modell med SageMaker och distribuerar modellen till Azure Functions. Vi använder en SageMaker Studio-anteckningsbok för att bygga, träna och distribuera modellen. Vi tränar modellen i SageMaker med hjälp av en förbyggd Docker-bild för PyTorch. Även om vi distribuerar den tränade modellen till Azure i det här fallet, kan du använda samma tillvägagångssätt för att distribuera modellen på andra plattformar, till exempel i lokaler eller andra molnplattformar.
När vi skapar ett träningsjobb lanserar SageMaker ML-beräkningsinstanserna och använder vår träningskod och utbildningsdataset för att träna modellen. Den sparar de resulterande modellartefakterna och andra utdata i en S3-hink som vi anger som input till träningsjobbet. När modellutbildningen är klar använder vi Öppna Neural Network Exchange (ONNX) runtime-bibliotek för att exportera PyTorch-modellen som en ONNX-modell.
Slutligen distribuerar vi ONNX-modellen tillsammans med en anpassad slutledningskod skriven i Python till Azure Functions med hjälp av Azure CLI. ONNX stöder de flesta vanliga ML-ramverk och verktyg. En sak att notera är att det är användbart att konvertera en ML-modell till ONNX om du vill använda ett annat ramverk för måldistribution, som PyTorch till TensorFlow. Om du använder samma ramverk på både källan och målet behöver du inte konvertera modellen till ONNX-format.
Följande diagram illustrerar arkitekturen för detta tillvägagångssätt.
Vi använder en SageMaker Studio-anteckningsbok tillsammans med SageMaker Python SDK att bygga och träna vår modell. SageMaker Python SDK är ett bibliotek med öppen källkod för att träna och distribuera ML-modeller på SageMaker. För mer information, se Skapa eller öppna en Amazon SageMaker Studio Notebook.
Kodavsnitten i följande avsnitt har testats i SageMaker Studio-anteckningsbokmiljön med hjälp av Data Science 3.0-bilden och Python 3.0-kärnan.
I den här lösningen visar vi följande steg:
- Träna en PyTorch-modell.
- Exportera PyTorch-modellen som en ONNX-modell.
- Paketera modellen och slutledningskoden.
- Distribuera modellen till Azure Functions.
Förutsättningar
Du bör ha följande förutsättningar:
- Ett AWS-konto.
- En SageMaker-domän och SageMaker Studio-användare. För instruktioner för att skapa dessa, se Ombord på Amazon SageMaker Domain med snabbinställning.
- Azure CLI.
- Åtkomst till Azure och autentiseringsuppgifter för en tjänstehuvud som har behörighet att skapa och hantera Azure-funktioner.
Träna en modell med PyTorch
I det här avsnittet beskriver vi stegen för att träna en PyTorch-modell.
Installera beroenden
Installera biblioteken för att utföra de steg som krävs för modellträning och modelldistribution:
pip install torchvision onnx onnxruntime
Slutför den första installationen
Vi börjar med att importera AWS SDK för Python (Boto3) och SageMaker Python SDK. Som en del av installationen definierar vi följande:
- Ett sessionsobjekt som tillhandahåller bekvämlighetsmetoder inom ramen för SageMaker och vårt eget konto.
- En SageMaker-roll som ARN använde för att delegera behörigheter till utbildnings- och värdtjänsten. Vi behöver detta så att dessa tjänster kan komma åt S3-hinkarna där vår data och modell lagras. För instruktioner om hur du skapar en roll som uppfyller dina affärsbehov, se SageMaker roller. För det här inlägget använder vi samma exekveringsroll som vår Studio-anteckningsbok-instans. Den här rollen får vi genom att ringa
sagemaker.get_execution_role()
. - Standardregionen där vårt träningsjobb kommer att köras.
- Standardhinken och prefixet vi använder för att lagra modellutdata.
Se följande kod:
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"
Skapa träningsdatauppsättningen
Vi använder datauppsättningen som är tillgänglig i den offentliga bucket sagemaker-example-files-prod-{region}
. Datauppsättningen innehåller följande filer:
- train-images-idx3-ubyte.gz – Innehåller bilder för träningsset
- train-labels-idx1-ubyte.gz – Innehåller etiketter för träningsset
- t10k-images-idx3-ubyte.gz – Innehåller testuppsättningsbilder
- t10k-labels-idx1-ubyte.gz – Innehåller testsetetiketter
Vi användertorchvision.datasets
modul för att ladda ner data från den offentliga bucket lokalt innan du laddar upp den till vår träningsdata bucket. Vi skickar denna hinkplats som en input till SageMaker-utbildningsjobbet. Vårt träningsskript använder den här platsen för att ladda ner och förbereda träningsdata och sedan träna modellen. Se följande kod:
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,))] ),
)
Skapa träningsskriptet
Med SageMaker kan du ta med din egen modell med hjälp av skriptläge. Med skriptläge kan du använda de förbyggda SageMaker-behållarna och tillhandahålla ditt eget träningsskript, som har modelldefinitionen, tillsammans med eventuella anpassade bibliotek och beroenden. De SageMaker Python SDK passerar vårt manus som en entry_point
till containern, som laddar och kör tågfunktionen från det medföljande skriptet för att träna vår modell.
När utbildningen är klar sparar SageMaker modellutgången i S3-hinken som vi tillhandahöll som en parameter till träningsjobbet.
Vår träningskod är anpassad från följande PyTorch exempelskript. Följande utdrag ur koden visar modelldefinitionen och tågfunktionen:
# 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
Träna modellen
Nu när vi har ställt in vår miljö och skapat vår indatadatauppsättning och anpassade träningsskript, kan vi starta modellträningen med SageMaker. Vi använder PyTorch-estimatorn i SageMaker Python SDK för att starta ett träningsjobb på SageMaker. Vi skickar in de nödvändiga parametrarna till estimatorn och anropar passningsmetoden. När vi anropar fit på PyTorch estimator, startar SageMaker ett träningsjobb med vårt skript som träningskod:
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}"
})
Exportera den tränade modellen som en ONNX-modell
Efter att utbildningen är klar och vår modell har sparats på den fördefinierade platsen i Amazon S3, exporterar vi modellen till en ONNX-modell med ONNX-runtime.
Vi inkluderar koden för att exportera vår modell till ONNX i vårt träningsskript för att köras efter att utbildningen är klar.
PyTorch exporterar modellen till ONNX genom att köra modellen med vår input och registrera ett spår av operatörer som används för att beräkna utdata. Vi använder en slumpmässig inmatning av rätt typ med PyTorch torch.onnx.export
funktion för att exportera modellen till ONNX. Vi specificerar också den första dimensionen i vår input som dynamisk så att vår modell accepterar en variabel batch_size
av ingångar under slutledning.
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 är ett öppet standardformat för modeller för djupinlärning som möjliggör interoperabilitet mellan ramverk för djupinlärning som PyTorch, Microsoft Cognitive Toolkit (CNTK) med flera. Det betyder att du kan använda vilket som helst av dessa ramverk för att träna modellen och sedan exportera de förtränade modellerna i ONNX-format. Genom att exportera modellen till ONNX får du fördelen av ett bredare urval av distributionsenheter och plattformar.
Ladda ner och extrahera modellartefakterna
ONNX-modellen som vårt träningsskript har sparat har kopierats av SageMaker till Amazon S3 på den utdataplats som vi angav när vi startade träningsjobbet. Modellartefakterna lagras som en komprimerad arkivfil som kallas model.tar.gz
. Vi laddar ner den här arkivfilen till en lokal katalog i vår Studio notebook-instans och extraherar modellartefakterna, nämligen 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()
Validera ONNX-modellen
ONNX-modellen exporteras till en fil med namnet mnist-pytorch.onnx
av vårt träningsmanus. Efter att vi har laddat ner och extraherat den här filen kan vi valfritt validera ONNX-modellen med hjälp av onnx.checker
modul. De check_model
funktionen i denna modul kontrollerar en modells överensstämmelse. Ett undantag görs om testet misslyckas.
import onnx onnx_model = onnx.load("mnist-pytorch.onnx")
onnx.checker.check_model(onnx_model)
Paketera modellen och slutledningskoden
För det här inlägget använder vi .zip-distribution för Azure Functions. I den här metoden paketerar vi vår modell, tillhörande kod och inställningar för Azure Functions i en .zip-fil och publicerar den till Azure Functions. Följande kod visar katalogstrukturen för vårt distributionspaket:
mnist-onnx
├── function_app.py
├── model
│ └── mnist-pytorch.onnx
└── requirements.txt
Lista beroenden
Vi listar beroenden för vår slutledningskod i requirements.txt
fil i roten av vårt paket. Den här filen används för att bygga Azure Functions-miljön när vi publicerar paketet.
azure-functions
numpy
onnxruntime
Skriv inferenskod
Vi använder Python för att skriva följande slutledningskod och använder ONNX Runtime-biblioteket för att ladda vår modell och köra slutledning. Detta instruerar Azure Functions-appen att göra slutpunkten tillgänglig på /classify
relativ väg.
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 )
Distribuera modellen till Azure Functions
Nu när vi har paketerat koden i det nödvändiga .zip-formatet är vi redo att publicera den till Azure Functions. Vi gör det med hjälp av Azure CLI, ett kommandoradsverktyg för att skapa och hantera Azure-resurser. Installera Azure CLI med följande kod:
!pip install -q azure-cli
Gör sedan följande steg:
- Logga in på Azure:
!az login
- Ställ in parametrarna för att skapa resurs:
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}"
- Använd följande kommandon för att skapa Azure Functions-appen tillsammans med de nödvändiga resurserna:
!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}
- Ställ in Azure Functions så att när vi distribuerar Functions-paketet
requirements.txt
fil används för att bygga våra applikationsberoenden:!az functionapp config appsettings set --name {function_app} --resource-group {resource_group_name} --settings @./functionapp/settings.json
- Konfigurera Functions-appen för att köra Python v2-modellen och utför en build på koden den tar emot efter .zip-distribution:
{ "AzureWebJobsFeatureFlags": "EnableWorkerIndexing", "SCM_DO_BUILD_DURING_DEPLOYMENT": true }
- När vi har resursgruppen, lagringsbehållaren och Functions-appen med rätt konfiguration publicerar du koden till Functions-appen:
!az functionapp deployment source config-zip -g {resource_group_name} -n {function_app} --src {function_archive} --build-remote true
Testa modellen
Vi har distribuerat ML-modellen till Azure Functions som en HTTP-utlösare, vilket innebär att vi kan använda Functions-appens URL för att skicka en HTTP-förfrågan till funktionen för att anropa funktionen och köra modellen.
För att förbereda inmatningen, ladda ner testbildfilerna från SageMaker-exempelfilen och förbered en uppsättning prover till det format som krävs 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))
Använd förfrågningsbiblioteket för att skicka en postbegäran till slutpunktens slutpunkt med exempelingångarna. Slutpunktens slutpunkt har formatet som visas i följande kod:
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']
Städa upp
När du är klar med att testa modellen tar du bort resursgruppen tillsammans med de ingående resurserna, inklusive lagringsbehållaren och appen Funktioner:
!az group delete --name {resource_group_name} --yes
Dessutom rekommenderas det att stänga av lediga resurser i SageMaker Studio för att minska kostnaderna. För mer information, se Spara kostnader genom att automatiskt stänga av lediga resurser i Amazon SageMaker Studio.
Slutsats
I det här inlägget visade vi hur du kan bygga och träna en ML-modell med SageMaker och distribuera den till en annan molnleverantör. I lösningen använde vi en SageMaker Studio-anteckningsbok, men för produktionsbelastningar rekommenderade vi att använda MLOps att skapa repeterbara utbildningsarbetsflöden för att påskynda modellutveckling och implementering.
Det här inlägget visade inte alla möjliga sätt att distribuera och köra en modell i en multicloud-miljö. Till exempel kan du också paketera din modell i en containerbild tillsammans med slutledningskod och beroendebibliotek för att köra modellen som en containeriserad applikation på vilken plattform som helst. För mer information om detta tillvägagångssätt, se Distribuera containerapplikationer i en multimolnmiljö med Amazon CodeCatalyst. Syftet med inlägget är att visa hur organisationer kan använda AWS AI/ML-funktioner i en multimolnmiljö.
Om författarna
Raja Vaidyanathan är en lösningsarkitekt på AWS som stödjer globala finansiella tjänster kunder. Raja arbetar med kunder för att skapa lösningar på komplexa problem med långsiktig positiv inverkan på deras verksamhet. Han är en stark ingenjörsyrkeskunnig inom IT-strategi, företagsdatahantering och applikationsarkitektur, med särskilda intressen för analys och maskininlärning.
Amandeep Bajwa är en Senior Solutions Architect på AWS som stödjer finansiella tjänsteföretag. Han hjälper organisationer att uppnå sina affärsresultat genom att identifiera lämplig molntransformationsstrategi baserad på branschtrender och organisatoriska prioriteringar. Några av de områden Amandeep konsulterar om är molnmigrering, molnstrategi (inklusive hybrid och multicloud), digital transformation, data och analys och teknik i allmänhet.
Prema Iyer är Senior Technical Account Manager för AWS Enterprise Support. Hon arbetar med externa kunder i en mängd olika projekt och hjälper dem att förbättra värdet av sina lösningar när de använder AWS.
- SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
- PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
- PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
- Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
- PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
- Källa: https://aws.amazon.com/blogs/machine-learning/train-and-deploy-ml-models-in-a-multicloud-environment-using-amazon-sagemaker/
- : har
- :är
- :inte
- :var
- $UPP
- 1
- 10
- 100
- 13
- 25
- 28
- 32
- 7
- 9
- a
- Om oss
- accelerera
- accepterar
- tillgång
- Konto
- Uppnå
- förvärvade
- Fördel
- Efter
- AI
- AI / ML
- Alla
- tillåter
- längs
- redan
- också
- Även
- amason
- Amazon SageMaker
- Amazon SageMaker Canvas
- Amazon SageMaker Studio
- Amazon Web Services
- an
- analytiker
- analytics
- och
- Anonym
- Annan
- vilken som helst
- Apache
- app
- Ansökan
- tillämpningar
- tillvägagångssätt
- lämpligt
- arkitektur
- arkiv
- ÄR
- områden
- AS
- bedömning
- At
- automatisera
- automatiskt
- tillgänglig
- AWS
- AXLAR
- Azure
- baserat
- BE
- varit
- innan
- börja
- fördelaktigt
- fördel
- Bättre
- mellan
- båda
- föra
- bredare
- SLUTRESULTAT
- Byggnad
- företag
- men
- by
- Ring
- kallas
- anropande
- KAN
- canvas
- kapacitet
- bära
- Vid
- Kontroller
- klass
- klassificera
- klick
- cloud
- koda
- kognitiv
- samarbete
- företag
- fullborda
- komplex
- Efterlevnad
- omfattande
- Compute
- konfiguration
- innehöll
- Behållare
- Behållare
- innehåller
- sammanhang
- bekvämlighet
- konvertera
- omvandling
- Kärna
- Kostar
- kunde
- skapa
- skapas
- Skapa
- skapande
- referenser
- beställnings
- Kunder
- datum
- datahantering
- Förberedelse av data
- datavetenskap
- datauppsättningar
- djup
- djupt lärande
- djupaste
- Standard
- definiera
- definition
- demonstrera
- beroenden
- Dependency
- distribuera
- utplacerade
- utplacera
- utplacering
- beskriva
- detalj
- detaljer
- Utveckling
- anordning
- enheter
- olika
- digital
- digital Transformation
- siffror
- Dimensionera
- diskuteras
- do
- Hamnarbetare
- domän
- gjort
- inte
- ner
- ladda ner
- under
- dynamisk
- e
- annars
- omfamna
- möjliggör
- möjliggör
- änden
- Slutpunkt
- Teknik
- Ingenjörer
- Företag
- företag
- Miljö
- epok
- epoker
- Varje
- exempel
- Utom
- undantag
- utförande
- expertis
- export
- export
- extern
- extrahera
- misslyckas
- Funktioner
- få
- Fil
- Filer
- finansiella
- finansiella tjänster
- hitta
- Förnamn
- passa
- efter
- För
- format
- fundament
- Ramverk
- ramar
- från
- fungera
- funktioner
- Allmänt
- genererar
- generativ
- Generativ AI
- skaffa sig
- Välgörenhet
- globala finansiella
- Grupp
- Har
- he
- hjälpa
- hjälper
- värd
- Hur ser din drömresa ut
- How To
- html
- http
- HTTPS
- Hybrid
- ID
- identifiera
- Idle
- if
- illustrerar
- bild
- bilder
- Inverkan
- importera
- importera
- förbättra
- förbättra
- in
- innefattar
- Inklusive
- oberoende
- industrin
- informationen
- inledande
- ingång
- ingångar
- installera
- exempel
- instruktioner
- integrera
- integrerade
- uppsåt
- intressen
- Gränssnitt
- Interoperabilitet
- in
- IT
- DESS
- Jobb
- Lediga jobb
- jpg
- json
- språk
- Large
- senaste
- lanserar
- LÄRA SIG
- inlärning
- Längd
- Hävstång
- bibliotek
- Bibliotek
- livscykel
- linje
- linux
- Lista
- läsa in
- laster
- lokal
- lokalt
- läge
- skogsavverkning
- lång sikt
- du letar
- förlust
- Maskinen
- maskininlärning
- göra
- hantera
- förvaltade
- ledning
- chef
- många
- karta
- matplotlib
- Maj..
- betyder
- Möt
- möter
- metod
- metoder
- Microsoft
- kanske
- migration
- ML
- MLOps
- Mode
- modell
- modeller
- Modulerna
- mer
- mest
- namn
- Som heter
- nämligen
- Behöver
- behövs
- behov
- netto
- nät
- neurala
- neurala nätverk
- anteckningsbok
- numpy
- objektet
- of
- on
- ONE
- öppet
- öppen källkod
- drift
- Verksamhet
- operatörer
- Tillbehör
- or
- beställa
- organisation
- organisatoriska
- organisationer
- OS
- Övriga
- vår
- ut
- utfall
- produktion
- utanför
- egen
- paket
- förpackade
- parameter
- parametrar
- del
- särskilt
- parti
- passera
- passerar
- bana
- Utföra
- behörigheter
- plattform
- Plattformar
- plato
- Platon Data Intelligence
- PlatonData
- Populära
- positiv
- möjlig
- Inlägg
- Förutsägelser
- beredning
- Förbered
- förutsättningar
- primär
- Principal
- problem
- Bearbetad
- Produktion
- produktivitet
- Produkter
- professionell
- projekt
- ge
- förutsatt
- leverantör
- ger
- allmän
- publicera
- Python
- pytorch
- Snabbt
- insamlat
- slumpmässig
- redo
- erhåller
- rekommenderas
- inspelning
- minska
- hänvisa
- Oavsett
- region
- register
- relativ
- repeterbar
- begära
- förfrågningar
- kräver
- Obligatorisk
- Krav
- resurs
- Resurser
- respons
- resultera
- resulterande
- avkastning
- höger
- Roll
- rot
- Körning
- rinnande
- kör
- sagemaker
- Samma
- sparade
- Skala
- scanning
- scenarier
- Vetenskap
- vetenskapsmän
- skript
- sDK
- sekundär
- §
- sektioner
- säkerhet
- se
- Val
- SJÄLV
- sända
- senior
- service
- Tjänster
- session
- in
- inställningar
- inställning
- Forma
- hon
- skall
- show
- visade
- visas
- Visar
- stänga
- stänga
- Enkelt
- situationer
- skicklig
- färdigheter
- So
- Mjukvara
- lösning
- Lösningar
- några
- Källa
- suveränitet
- specificerade
- Etapp
- standard
- starta
- igång
- startar
- Steg
- förvaring
- lagra
- lagras
- Strategi
- Sträng
- stark
- struktur
- studio
- Senare
- Framgångsrikt
- sådana
- stödja
- Stödjande
- Stöder
- Ta
- tar
- Målet
- grupp
- Teknisk
- Tekniken
- Teknologi
- tio
- tensorflow
- testa
- testade
- Testning
- text
- den där
- Smakämnen
- källan
- deras
- Dem
- sig själva
- sedan
- Dessa
- de
- sak
- Tredje
- detta
- gånger
- till
- toolkit
- verktyg
- brännaren
- Torchvision
- Trace
- Tåg
- tränad
- Utbildning
- Förvandla
- Transformation
- Transformationsstrategi
- transformer
- Trender
- utlösa
- triggas
- sann
- prova
- Typ
- unika
- uppladdad
- uppladdning
- URL
- användning
- användningsfall
- Begagnade
- Användare
- användningar
- med hjälp av
- verktyg
- BEKRÄFTA
- värde
- variabel
- mängd
- försäljare
- versioner
- sårbarhet
- vill
- var
- sätt
- we
- webb
- webbservice
- Webb-baserad
- VÄL
- när
- som
- kommer
- med
- inom
- arbetsflöden
- fungerar
- skriva
- skriven
- X
- ännu
- Om er
- Din
- zephyrnet
- Postnummer