Alors que les clients accélèrent leurs migrations vers le cloud et transforment leur activité, certains se retrouvent dans des situations où ils doivent gérer leurs opérations informatiques dans un environnement multicloud. Par exemple, vous avez peut-être acquis une entreprise qui fonctionnait déjà sur un autre fournisseur de cloud, ou vous pouvez avoir une charge de travail qui génère de la valeur à partir des capacités uniques fournies par AWS. Un autre exemple est celui des éditeurs de logiciels indépendants (ISV) qui proposent leurs produits et services sur différentes plates-formes cloud au profit de leurs clients finaux. Une organisation peut également opérer dans une région où un fournisseur de cloud principal n'est pas disponible et, afin de répondre aux exigences de souveraineté ou de résidence des données, elle peut utiliser un fournisseur de cloud secondaire.
Dans ces scénarios, alors que vous commencez à adopter l'IA générative, les grands modèles de langage (LLM) et les technologies d'apprentissage automatique (ML) comme éléments essentiels de votre entreprise, vous recherchez peut-être des options pour tirer parti de AWS IA et ML capacités en dehors d'AWS dans un environnement multicloud. Par exemple, vous souhaiterez peut-être utiliser Amazon Sage Maker pour créer et entraîner un modèle ML, ou utiliser Démarrage d'Amazon SageMaker pour déployer des modèles de base prédéfinis ou de ML tiers, que vous pouvez déployer en un seul clic. Ou vous voudrez peut-être profiter de Socle amazonien pour créer et faire évoluer des applications d'IA générative, ou vous pouvez tirer parti Services d'IA pré-entraînés d'AWS, qui ne nécessitent pas que vous acquériez des compétences en apprentissage automatique. AWS prend en charge les scénarios dans lesquels les organisations souhaitent apporter leur propre modèle à Amazon SageMaker or dans Amazon SageMaker Canvas pour les prédictions.
Dans cet article, nous démontrons l'une des nombreuses options dont vous disposez pour profiter de l'ensemble le plus large et le plus approfondi de fonctionnalités IA/ML d'AWS dans un environnement multicloud. Nous montrons comment vous pouvez créer et former un modèle ML dans AWS et déployer le modèle sur une autre plateforme. Nous formons le modèle à l'aide d'Amazon SageMaker, stockons les artefacts du modèle dans Service de stockage simple Amazon (Amazon S3), puis déployez et exécutez le modèle dans Azure. Cette approche est avantageuse si vous utilisez les services AWS pour ML pour leur ensemble de fonctionnalités le plus complet, mais que vous devez exécuter votre modèle chez un autre fournisseur de cloud dans l'une des situations dont nous avons discuté.
Concepts clés
Amazon SageMakerStudio est un environnement de développement intégré (IDE) basé sur le Web pour l'apprentissage automatique. SageMaker Studio permet aux data scientists, aux ingénieurs ML et aux ingénieurs de données de préparer des données, de créer, de former et de déployer des modèles ML sur une seule interface Web. Avec SageMaker Studio, vous pouvez accéder à des outils spécialement conçus pour chaque étape du cycle de vie du développement ML, de la préparation des données à la création, la formation et le déploiement de vos modèles ML, améliorant ainsi jusqu'à dix fois la productivité de l'équipe de science des données. Blocs-notes SageMaker Studio sont des blocs-notes collaboratifs à démarrage rapide qui s'intègrent aux outils de ML spécialement conçus dans SageMaker et d'autres services AWS.
SageMaker est un service ML complet permettant aux analystes commerciaux, aux data scientists et aux ingénieurs MLOps de créer, former et déployer des modèles ML pour n'importe quel cas d'utilisation, quelle que soit l'expertise ML.
AWS fournit Conteneurs d'apprentissage en profondeur (DLC) pour les frameworks ML populaires tels que PyTorch, TensorFlow et Apache MXNet, que vous pouvez utiliser avec SageMaker pour la formation et l'inférence. Les DLC sont disponibles sous forme d'images Docker dans Registre des conteneurs élastiques Amazon (AmazonECR). Les images Docker sont préinstallées et testées avec les dernières versions des frameworks d'apprentissage en profondeur populaires ainsi qu'avec d'autres dépendances nécessaires à la formation et à l'inférence. Pour une liste complète des images Docker prédéfinies gérées par SageMaker, voir Chemins de registre Docker et exemple de code. Amazon ECR prend en charge l'analyse de sécurité et est intégré à Inspecteur Amazon service de gestion des vulnérabilités pour répondre aux exigences de sécurité de conformité des images de votre organisation et pour automatiser l'analyse d'évaluation des vulnérabilités. Les organisations peuvent également utiliser Formation AWS ainsi que le Inférence AWS pour un meilleur rapport qualité-prix pour l'exécution de tâches de formation ou d'inférence ML.
Vue d'ensemble de la solution
Dans cette section, nous décrivons comment créer et former un modèle à l'aide de SageMaker et déployer le modèle sur Azure Functions. Nous utilisons un notebook SageMaker Studio pour créer, entraîner et déployer le modèle. Nous entraînons le modèle dans SageMaker à l'aide d'une image Docker prédéfinie pour PyTorch. Bien que nous déployions le modèle formé sur Azure dans ce cas, vous pouvez utiliser la même approche pour déployer le modèle sur d'autres plateformes, telles que sur site ou d'autres plateformes cloud.
Lorsque nous créons une tâche de formation, SageMaker lance les instances de calcul ML et utilise notre code de formation et l'ensemble de données de formation pour former le modèle. Il enregistre les artefacts de modèle résultants et autres sorties dans un compartiment S3 que nous spécifions comme entrée de la tâche de formation. Une fois la formation du modèle terminée, nous utilisons le Échange de réseau neuronal ouvert (ONNX) bibliothèque d'exécution pour exporter le modèle PyTorch en tant que modèle ONNX.
Enfin, nous déployons le modèle ONNX avec un code d'inférence personnalisé écrit en Python sur Azure Functions à l'aide d'Azure CLI. ONNX prend en charge la plupart des Cadres et outils de ML couramment utilisés. Une chose à noter est que la conversion d'un modèle ML en ONNX est utile si vous souhaitez utiliser un framework de déploiement cible différent, tel que PyTorch vers TensorFlow. Si vous utilisez le même framework sur la source et la cible, vous n'avez pas besoin de convertir le modèle au format ONNX.
Le diagramme suivant illustre l’architecture de cette approche.
Nous utilisons un bloc-notes SageMaker Studio avec le Kit de développement logiciel (SDK) SageMaker Python pour construire et entraîner notre modèle. Le SDK SageMaker Python est une bibliothèque open source pour la formation et le déploiement de modèles ML sur SageMaker. Pour plus de détails, reportez-vous à Créer ou ouvrir un bloc-notes Amazon SageMaker Studio.
Les extraits de code des sections suivantes ont été testés dans l'environnement de bloc-notes SageMaker Studio à l'aide de l'image Data Science 3.0 et du noyau Python 3.0.
Dans cette solution, nous démontrons les étapes suivantes :
- Entraînez un modèle PyTorch.
- Exportez le modèle PyTorch en tant que modèle ONNX.
- Packagez le modèle et le code d’inférence.
- Déployez le modèle sur Azure Functions.
Pré-requis
Vous devez avoir les prérequis suivants :
- Un compte AWS.
- Un domaine SageMaker et un utilisateur de SageMaker Studio. Pour obtenir des instructions pour les créer, reportez-vous à Intégration au domaine Amazon SageMaker à l'aide de la configuration rapide.
- L'Azure CLI.
- Accès à Azure et informations d’identification pour un principal de service disposant des autorisations nécessaires pour créer et gérer Azure Functions.
Entraîner un modèle avec PyTorch
Dans cette section, nous détaillons les étapes pour entraîner un modèle PyTorch.
Installer les dépendances
Installez les bibliothèques pour effectuer les étapes requises pour la formation du modèle et le déploiement du modèle :
pip install torchvision onnx onnxruntime
Terminer la configuration initiale
Nous commençons par importer le AWS SDK pour Python (Boto3) et par Kit de développement logiciel (SDK) SageMaker Python. Dans le cadre de la configuration, nous définissons les éléments suivants :
- Un objet de session qui fournit des méthodes pratiques dans le contexte de SageMaker et de notre propre compte.
- Un ARN de rôle SageMaker utilisé pour déléguer des autorisations au service de formation et d'hébergement. Nous en avons besoin pour que ces services puissent accéder aux compartiments S3 où sont stockés nos données et notre modèle. Pour obtenir des instructions sur la création d'un rôle qui répond aux besoins de votre entreprise, reportez-vous à Rôles SageMaker. Pour cet article, nous utilisons le même rôle d'exécution que notre instance de notebook Studio. Nous obtenons ce rôle en appelant
sagemaker.get_execution_role()
. - La région par défaut dans laquelle notre tâche de formation sera exécutée.
- Le compartiment par défaut et le préfixe que nous utilisons pour stocker la sortie du modèle.
Voir le code suivant:
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"
Créer l'ensemble de données d'entraînement
Nous utilisons l'ensemble de données disponible dans le bucket public sagemaker-example-files-prod-{region}
. L'ensemble de données contient les fichiers suivants :
- train-images-idx3-ubyte.gz – Contient des images d’ensemble de formation
- train-labels-idx1-ubyte.gz – Contient des étiquettes d’ensemble de formation
- t10k-images-idx3-ubyte.gz – Contient des images d’ensemble de test
- t10k-labels-idx1-ubyte.gz – Contient les étiquettes des ensembles de tests
Nous utilisons lestorchvision.datasets
module pour télécharger localement les données du bucket public avant de les télécharger dans notre bucket de données de formation. Nous transmettons cet emplacement de compartiment comme entrée à la tâche de formation SageMaker. Notre script de formation utilise cet emplacement pour télécharger et préparer les données de formation, puis entraîner le modèle. Voir le code suivant :
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,))] ),
)
Créer le script de formation
Avec SageMaker, vous pouvez apporter votre propre modèle en utilisant mode script. Avec le mode script, vous pouvez utiliser les conteneurs SageMaker prédéfinis et fournir votre propre script de formation, qui contient la définition du modèle, ainsi que toutes les bibliothèques et dépendances personnalisées. Le Kit de développement logiciel (SDK) SageMaker Python passe notre script comme un entry_point
au conteneur, qui charge et exécute la fonction d'entraînement à partir du script fourni pour entraîner notre modèle.
Une fois la formation terminée, SageMaker enregistre la sortie du modèle dans le compartiment S3 que nous avons fourni en tant que paramètre pour la tâche de formation.
Notre code de formation est adapté de ce qui suit Exemple de script PyTorch. L'extrait suivant du code montre la définition du modèle et la fonction de 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
Former le modèle
Maintenant que nous avons configuré notre environnement et créé notre ensemble de données d'entrée et notre script de formation personnalisé, nous pouvons démarrer la formation du modèle à l'aide de SageMaker. Nous utilisons l'estimateur PyTorch dans le SDK SageMaker Python pour démarrer une tâche de formation sur SageMaker. Nous transmettons les paramètres requis à l'estimateur et appelons la méthode d'ajustement. Lorsque nous appelons fit sur l'estimateur PyTorch, SageMaker démarre une tâche de formation en utilisant notre script comme code de formation :
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}"
})
Exporter le modèle entraîné en tant que modèle ONNX
Une fois la formation terminée et notre modèle enregistré à l'emplacement prédéfini dans Amazon S3, nous exportons le modèle vers un modèle ONNX à l'aide du runtime ONNX.
Nous incluons le code pour exporter notre modèle vers ONNX dans notre script de formation à exécuter une fois la formation terminée.
PyTorch exporte le modèle vers ONNX en exécutant le modèle en utilisant notre entrée et en enregistrant une trace des opérateurs utilisés pour calculer la sortie. On utilise une entrée aléatoire du bon type avec le PyTorch torch.onnx.export
fonction pour exporter le modèle vers ONNX. Nous spécifions également la première dimension de notre entrée comme dynamique afin que notre modèle accepte une variable batch_size
des entrées pendant l’inférence.
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 est un format standard ouvert pour les modèles d'apprentissage profond qui permet l'interopérabilité entre les frameworks d'apprentissage profond tels que PyTorch, Microsoft Cognitive Toolkit (CNTK), etc. Cela signifie que vous pouvez utiliser n'importe lequel de ces frameworks pour entraîner le modèle et ensuite exporter les modèles pré-entraînés au format ONNX. En exportant le modèle vers ONNX, vous bénéficiez d'une sélection plus large de dispositifs et de plates-formes de déploiement.
Téléchargez et extrayez les artefacts du modèle
Le modèle ONNX que notre script de formation a enregistré a été copié par SageMaker sur Amazon S3 dans l'emplacement de sortie que nous avons spécifié lorsque nous avons démarré la tâche de formation. Les artefacts du modèle sont stockés sous forme de fichier d'archive compressé appelé model.tar.gz
. Nous téléchargeons ce fichier d'archive dans un répertoire local de notre instance de notebook Studio et extrayons les artefacts du modèle, à savoir le modèle 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()
Valider le modèle ONNX
Le modèle ONNX est exporté vers un fichier nommé mnist-pytorch.onnx
par notre script de formation. Après avoir téléchargé et extrait ce fichier, nous pouvons éventuellement valider le modèle ONNX à l'aide du onnx.checker
module. la check_model
La fonction de ce module vérifie la cohérence d'un modèle. Une exception est levée si le test échoue.
import onnx onnx_model = onnx.load("mnist-pytorch.onnx")
onnx.checker.check_model(onnx_model)
Packager le modèle et le code d'inférence
Pour cet article, nous utilisons le déploiement .zip pour Azure Functions. Dans cette méthode, nous regroupons notre modèle, le code qui l’accompagne et les paramètres Azure Functions dans un fichier .zip et le publions sur Azure Functions. Le code suivant montre la structure des répertoires de notre package de déploiement :
mnist-onnx
├── function_app.py
├── model
│ └── mnist-pytorch.onnx
└── requirements.txt
Liste des dépendances
Nous répertorions les dépendances de notre code d'inférence dans le requirements.txt
fichier à la racine de notre package. Ce fichier est utilisé pour créer l'environnement Azure Functions lorsque nous publions le package.
azure-functions
numpy
onnxruntime
Écrire le code d'inférence
Nous utilisons Python pour écrire le code d'inférence suivant, en utilisant la bibliothèque ONNX Runtime pour charger notre modèle et exécuter l'inférence. Cela demande à l'application Azure Functions de rendre le point de terminaison disponible au niveau /classify
chemin relatif.
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 )
Déployer le modèle sur Azure Functions
Maintenant que le code est conditionné au format .zip requis, nous sommes prêts à le publier sur Azure Functions. Nous faisons cela à l’aide d’Azure CLI, un utilitaire de ligne de commande permettant de créer et de gérer des ressources Azure. Installez Azure CLI avec le code suivant :
!pip install -q azure-cli
Suivez ensuite les étapes suivantes:
- Connectez-vous à Azure :
!az login
- Configurez les paramètres de création de ressources :
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}"
- Utilisez les commandes suivantes pour créer l’application Azure Functions avec les ressources prérequises :
!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}
- Configurez Azure Functions de sorte que lorsque nous déployons le package Functions, le
requirements.txt
Le fichier est utilisé pour construire nos dépendances d'application :!az functionapp config appsettings set --name {function_app} --resource-group {resource_group_name} --settings @./functionapp/settings.json
- Configurez l'application Functions pour exécuter le modèle Python v2 et effectuez une génération sur le code qu'elle reçoit après le déploiement .zip :
{ "AzureWebJobsFeatureFlags": "EnableWorkerIndexing", "SCM_DO_BUILD_DURING_DEPLOYMENT": true }
- Une fois que nous avons le groupe de ressources, le conteneur de stockage et l'application Functions avec la bonne configuration, publiez le code dans l'application Functions :
!az functionapp deployment source config-zip -g {resource_group_name} -n {function_app} --src {function_archive} --build-remote true
Tester le modèle
Nous avons déployé le modèle ML sur Azure Functions en tant que déclencheur HTTP, ce qui signifie que nous pouvons utiliser l'URL de l'application Functions pour envoyer une requête HTTP à la fonction afin d'appeler la fonction et d'exécuter le modèle.
Pour préparer l'entrée, téléchargez les fichiers d'images de test à partir du compartiment de fichiers d'exemple SageMaker et préparez un ensemble d'échantillons au format requis par le modèle :
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))
Utilisez la bibliothèque de requêtes pour envoyer une requête de publication au point de terminaison d'inférence avec les exemples d'entrées. Le point de terminaison d'inférence prend le format indiqué dans le code suivant :
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']
Nettoyer
Lorsque vous avez terminé de tester le modèle, supprimez le groupe de ressources ainsi que les ressources contenues, y compris le conteneur de stockage et l'application Fonctions :
!az group delete --name {resource_group_name} --yes
De plus, il est recommandé de fermer les ressources inutilisées dans SageMaker Studio pour réduire les coûts. Pour plus d'informations, reportez-vous à Économisez des coûts en fermant automatiquement les ressources inactives dans Amazon SageMaker Studio.
Conclusion
Dans cet article, nous avons montré comment créer et former un modèle ML avec SageMaker et le déployer sur un autre fournisseur de cloud. Dans la solution, nous avons utilisé un notebook SageMaker Studio, mais pour les charges de travail de production, nous avons recommandé d'utiliser MLOps pour créer des flux de travail de formation reproductibles afin d'accélérer le développement et le déploiement de modèles.
Cet article n'a pas montré toutes les manières possibles de déployer et d'exécuter un modèle dans un environnement multicloud. Par exemple, vous pouvez également empaqueter votre modèle dans une image de conteneur avec du code d'inférence et des bibliothèques de dépendances pour exécuter le modèle en tant qu'application conteneurisée sur n'importe quelle plateforme. Pour plus d'informations sur cette approche, reportez-vous à Déployez des applications de conteneur dans un environnement multicloud à l'aide d'Amazon CodeCatalyst. L'objectif de cet article est de montrer comment les organisations peuvent utiliser les fonctionnalités AWS AI/ML dans un environnement multicloud.
À propos des auteurs
Raja Vaidyanathan est un architecte de solutions chez AWS qui soutient les clients mondiaux de services financiers. Raja travaille avec ses clients pour concevoir des solutions à des problèmes complexes ayant un impact positif à long terme sur leur entreprise. Il s'agit d'un solide professionnel de l'ingénierie, compétent en stratégie informatique, en gestion de données d'entreprise et en architecture d'applications, avec un intérêt particulier pour l'analyse et l'apprentissage automatique.
Amandeep Bajwa est un architecte de solutions senior chez AWS qui soutient les entreprises de services financiers. Il aide les organisations à atteindre leurs résultats commerciaux en identifiant la stratégie de transformation cloud appropriée en fonction des tendances du secteur et des priorités organisationnelles. Certains des domaines sur lesquels Amandeep consulte sont la migration vers le cloud, la stratégie cloud (y compris hybride et multicloud), la transformation numérique, les données et analyses, et la technologie en général.
Prema Iyer est responsable de compte technique principal pour AWS Enterprise Support. Elle travaille avec des clients externes sur une variété de projets, les aidant à améliorer la valeur de leurs solutions lors de l'utilisation d'AWS.
- Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
- PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
- PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
- PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
- PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
- La source: https://aws.amazon.com/blogs/machine-learning/train-and-deploy-ml-models-in-a-multicloud-environment-using-amazon-sagemaker/
- :possède
- :est
- :ne pas
- :où
- $UP
- 1
- 10
- 100
- 13
- 25
- 28
- 32
- 7
- 9
- a
- A Propos
- accélérer
- Accepte
- accès
- Compte
- atteindre
- a acquise
- Avantage
- Après
- AI
- AI / ML
- Tous
- permet
- le long de
- déjà
- aussi
- Bien que
- Amazon
- Amazon Sage Maker
- Toile Amazon SageMaker
- Amazon SageMakerStudio
- Amazon Web Services
- an
- Analystes
- analytique
- ainsi que le
- Témoignages
- Une autre
- tous
- Apache
- appli
- Application
- applications
- une approche
- approprié
- architecture
- Archive
- SONT
- domaines
- AS
- Évaluation de risque climatique
- At
- automatiser
- automatiquement
- disponibles
- AWS
- HACHES
- Azure
- basé
- BE
- était
- before
- commencer
- avantageux
- profiter
- Améliorée
- jusqu'à XNUMX fois
- tous les deux
- apporter
- plus large
- construire
- Développement
- la performance des entreprises
- mais
- by
- Appelez-nous
- appelé
- appel
- CAN
- la toile
- capacités
- porter
- maisons
- Contrôles
- classe
- Classer
- cliquez
- le cloud
- code
- cognitif
- collaborative
- Société
- complet
- complexe
- conformité
- complet
- calcul
- configuration
- contenu
- Contenant
- Conteneurs
- contient
- contexte
- commodité
- convertir
- conversion
- Core
- Costs
- pourriez
- engendrent
- créée
- La création
- création
- Lettres de créance
- Customiser
- Clients
- données
- gestion des données
- Préparation des données
- science des données
- ensembles de données
- profond
- l'apprentissage en profondeur
- le plus profond
- Réglage par défaut
- Vous permet de définir
- définition
- démontrer
- dépendances
- Dépendance
- déployer
- déployé
- déployer
- déploiement
- décrire
- détail
- détails
- Développement
- dispositif
- Compatibles
- différent
- numérique
- Transformation numérique
- chiffres
- Dimension
- discuté
- do
- Docker
- domaine
- fait
- Ne pas
- down
- download
- pendant
- Dynamic
- e
- d'autre
- embrasser
- permet
- permettant
- fin
- Endpoint
- ENGINEERING
- Les ingénieurs
- Entreprise
- entreprises
- Environment
- époque
- époques
- Chaque
- exemple
- Sauf
- exception
- exécution
- nous a permis de concevoir
- Exporter
- exportations
- externe
- extrait
- échoue
- Fonctionnalités:
- few
- Déposez votre dernière attestation
- Fichiers
- la traduction de documents financiers
- services financiers
- Trouvez
- Prénom
- s'adapter
- Abonnement
- Pour
- le format
- Fondation
- Framework
- cadres
- De
- fonction
- fonctions
- Général
- génère
- génératif
- IA générative
- obtenez
- Global
- financière mondiale
- Réservation de groupe
- Vous avez
- he
- aider
- aide
- hébergement
- Comment
- How To
- HTML
- http
- HTTPS
- Hybride
- ID
- identifier
- Idle
- if
- illustre
- image
- satellite
- Impact
- importer
- l'importation
- améliorer
- l'amélioration de
- in
- comprendre
- Y compris
- indépendant
- industrie
- d'information
- initiale
- contribution
- entrées
- installer
- instance
- Des instructions
- intégrer
- des services
- intention
- intérêts
- Interfaces
- Interopérabilité
- développement
- IT
- SES
- Emploi
- Emplois
- jpg
- json
- langue
- gros
- Nouveautés
- lance
- APPRENTISSAGE
- apprentissage
- Longueur
- Levier
- bibliothèques
- Bibliothèque
- vos produits
- Gamme
- linux
- Liste
- charge
- charges
- locales
- localement
- emplacement
- enregistrement
- long-term
- recherchez-
- perte
- click
- machine learning
- a prendre une
- gérer
- gérés
- gestion
- manager
- de nombreuses
- Localisation
- matplotlib
- Mai..
- veux dire
- Découvrez
- Se rencontre
- méthode
- méthodes
- Microsoft
- pourrait
- migration
- ML
- MLOps
- Mode
- modèle
- numériques jumeaux (digital twin models)
- Module
- PLUS
- (en fait, presque toutes)
- prénom
- Nommé
- à savoir
- Besoin
- nécessaire
- Besoins
- net
- réseau et
- neural
- Réseau neuronal
- cahier
- numpy
- objet
- of
- on
- ONE
- ouvert
- open source
- d'exploitation
- Opérations
- opérateurs
- Options
- or
- de commander
- organisation
- organisationnel
- organisations
- OS
- Autre
- nos
- ande
- les résultats
- sortie
- au contrôle
- propre
- paquet
- emballé
- paramètre
- paramètres
- partie
- particulier
- fête
- pass
- passes
- chemin
- Effectuer
- autorisations
- plateforme
- Plateformes
- Platon
- Intelligence des données Platon
- PlatonDonnées
- Populaire
- positif
- possible
- Post
- Prédictions
- préparation
- Préparer
- conditions préalables
- primaire
- Directeur
- d'ouvrabilité
- Traité
- Vidéo
- productivité
- Produits
- professionels
- projets
- fournir
- à condition de
- de voiture.
- fournit
- public
- publier
- Python
- pytorch
- Rapide
- collectés
- aléatoire
- solutions
- reçoit
- recommandé
- l'enregistrement
- réduire
- reportez-vous
- Indépendamment
- région
- enregistrement
- relatif
- répétable
- nécessaire
- demandes
- exigent
- conditions
- Exigences
- ressource
- Resources
- réponse
- résultat
- résultant
- retourner
- bon
- Rôle
- racine
- Courir
- pour le running
- fonctionne
- sagemaker
- même
- sauvé
- Escaliers intérieurs
- balayage
- scénarios
- Sciences
- scientifiques
- scénario
- Sdk
- secondaire
- Section
- les sections
- sécurité
- sur le lien
- sélection
- AUTO
- envoyer
- supérieur
- service
- Services
- Session
- set
- Paramétres
- installation
- Forme
- elle
- devrait
- montrer
- montré
- montré
- Spectacles
- arrêter
- arrêter
- étapes
- situations
- qualifié
- compétences
- So
- Logiciels
- sur mesure
- Solutions
- quelques
- Identifier
- souveraineté
- spécifié
- Étape
- Standard
- Commencer
- j'ai commencé
- départs
- Étapes
- storage
- Boutique
- stockée
- de Marketing
- Chaîne
- STRONG
- structure
- studio
- Par la suite
- Avec succès
- tel
- Support
- Appuyer
- Les soutiens
- Prenez
- prend
- Target
- équipe
- Technique
- Les technologies
- Technologie
- Dix
- tensorflow
- tester
- examiné
- Essais
- texte
- qui
- La
- La Source
- leur
- Les
- se
- puis
- Ces
- l'ont
- chose
- Troisièmement
- this
- fois
- à
- Boîte à outils
- les outils
- torche
- Vision de la torche
- Tracer
- Train
- qualifié
- Formation
- Transformer
- De La Carrosserie
- Stratégie de transformation
- se transforme
- Trends
- déclencher
- déclenché
- oui
- Essai
- type
- expérience unique et authentique
- téléchargé
- Téléchargement
- URL
- utilisé
- cas d'utilisation
- d'utiliser
- Utilisateur
- Usages
- en utilisant
- utilitaire
- VALIDER
- Plus-value
- variable
- variété
- fournisseurs
- versions
- vulnérabilité
- souhaitez
- était
- façons
- we
- web
- services Web
- Basé sur le Web
- WELL
- quand
- qui
- sera
- comprenant
- dans les
- workflows
- vos contrats
- écrire
- code écrit
- X
- encore
- Vous n'avez
- Votre
- zéphyrnet
- Zip