À medida que os clientes aceleram as suas migrações para a nuvem e transformam os seus negócios, alguns encontram-se em situações em que têm de gerir operações de TI num ambiente multicloud. Por exemplo, você pode ter adquirido uma empresa que já operava em um provedor de nuvem diferente ou pode ter uma carga de trabalho que gera valor a partir de recursos exclusivos fornecidos pela AWS. Outro exemplo são os fornecedores independentes de software (ISVs) que disponibilizam seus produtos e serviços em diferentes plataformas de nuvem para beneficiar seus clientes finais. Ou uma organização pode estar operando em uma região onde um provedor de nuvem primário não está disponível e, para atender aos requisitos de soberania ou residência de dados, pode usar um provedor de nuvem secundário.
Nesses cenários, à medida que você começa a adotar a IA generativa, os grandes modelos de linguagem (LLMs) e as tecnologias de aprendizado de máquina (ML) como parte central do seu negócio, você pode estar procurando opções para aproveitar as vantagens IA e ML da AWS recursos fora da AWS em um ambiente multicloud. Por exemplo, você pode querer fazer uso de Amazon Sage Maker para construir e treinar modelo de ML ou usar Início rápido do Amazon SageMaker para implantar modelos de ML básicos pré-construídos ou de terceiros, que você pode implantar com o clique de alguns botões. Ou você pode querer aproveitar Rocha Amazônica para construir e dimensionar aplicativos generativos de IA, ou você pode aproveitar Serviços de IA pré-treinados da AWS, que não exigem que você aprenda habilidades de aprendizado de máquina. A AWS fornece suporte para cenários em que as organizações desejam trazer seu próprio modelo para o Amazon SageMaker or no Amazon SageMaker Canvas para previsões.
Nesta postagem, demonstramos uma das muitas opções que você tem para aproveitar as vantagens do conjunto mais amplo e profundo de recursos de IA/ML da AWS em um ambiente multicloud. Mostramos como você pode construir e treinar um modelo de ML na AWS e implantar o modelo em outra plataforma. Treinamos o modelo usando Amazon SageMaker, armazenamos os artefatos do modelo em Serviço de armazenamento simples da Amazon (Amazon S3) e implantar e executar o modelo no Azure. Essa abordagem é benéfica se você usa serviços AWS para ML para seu conjunto mais abrangente de recursos, mas precisa executar seu modelo em outro provedor de nuvem em uma das situações que discutimos.
Conceitos chave
Estúdio Amazon SageMaker é um ambiente de desenvolvimento integrado (IDE) baseado na web para aprendizado de máquina. O SageMaker Studio permite que cientistas de dados, engenheiros de ML e engenheiros de dados preparem dados, construam, treinem e implantem modelos de ML em uma interface web. Com o SageMaker Studio, você pode acessar ferramentas específicas para cada estágio do ciclo de vida de desenvolvimento de ML, desde a preparação de dados até a construção, treinamento e implantação de seus modelos de ML, melhorando a produtividade da equipe de ciência de dados em até dez vezes. Blocos de notas do SageMaker Studio são notebooks colaborativos de início rápido que se integram a ferramentas de ML desenvolvidas especificamente no SageMaker e em outros serviços da AWS.
SageMaker é um serviço abrangente de ML que permite que analistas de negócios, cientistas de dados e engenheiros de MLOps criem, treinem e implantem modelos de ML para qualquer caso de uso, independentemente da experiência em ML.
AWS fornece Contêineres de aprendizado profundo (DLCs) para estruturas de ML populares, como PyTorch, TensorFlow e Apache MXNet, que você pode usar com SageMaker para treinamento e inferência. DLCs estão disponíveis como imagens Docker em Registro do Amazon Elastic Container (Amazon ECR). As imagens Docker são pré-instaladas e testadas com as versões mais recentes de estruturas populares de aprendizagem profunda, bem como outras dependências necessárias para treinamento e inferência. Para obter uma lista completa das imagens Docker pré-construídas gerenciadas pelo SageMaker, consulte Caminhos de registro do Docker e código de exemplo. O Amazon ECR oferece suporte à verificação de segurança e está integrado com Inspetor da Amazônia serviço de gerenciamento de vulnerabilidades para atender aos requisitos de segurança de conformidade de imagem da sua organização e para automatizar a verificação de avaliação de vulnerabilidades. As organizações também podem usar Treinamento AWS e Inferência da AWS para melhor relação custo-benefício para execução de trabalhos de treinamento ou inferência de ML.
Visão geral da solução
Nesta seção, descrevemos como construir e treinar um modelo usando o SageMaker e implantar o modelo no Azure Functions. Usamos um notebook SageMaker Studio para construir, treinar e implantar o modelo. Treinamos o modelo no SageMaker usando uma imagem Docker pré-construída para PyTorch. Embora neste caso estejamos a implementar o modelo treinado no Azure, poderá utilizar a mesma abordagem para implementar o modelo noutras plataformas, como no local ou outras plataformas na nuvem.
Quando criamos um trabalho de treinamento, o SageMaker inicia as instâncias de computação de ML e usa nosso código de treinamento e o conjunto de dados de treinamento para treinar o modelo. Ele salva os artefatos do modelo resultantes e outras saídas em um bucket S3 que especificamos como entrada para o trabalho de treinamento. Quando o treinamento do modelo for concluído, usamos o Troca de rede neural aberta (ONNX) biblioteca de tempo de execução para exportar o modelo PyTorch como um modelo ONNX.
Por fim, implantamos o modelo ONNX juntamente com um código de inferência personalizado escrito em Python no Azure Functions usando a CLI do Azure. ONNX suporta a maioria dos estruturas e ferramentas de ML comumente usadas. Uma coisa a observar é que converter um modelo de ML em ONNX é útil se você quiser usar uma estrutura de implantação de destino diferente, como PyTorch para TensorFlow. Se estiver usando a mesma estrutura na origem e no destino, não será necessário converter o modelo para o formato ONNX.
O diagrama a seguir ilustra a arquitetura dessa abordagem.
Usamos um notebook SageMaker Studio junto com o SDK Python do SageMaker para construir e treinar nosso modelo. O SageMaker Python SDK é uma biblioteca de código aberto para treinamento e implantação de modelos de ML no SageMaker. Para mais detalhes, consulte Crie ou abra um notebook do Amazon SageMaker Studio.
Os trechos de código nas seções a seguir foram testados no ambiente de notebook SageMaker Studio usando a imagem Data Science 3.0 e o kernel Python 3.0.
Nesta solução, demonstramos as seguintes etapas:
- Treine um modelo PyTorch.
- Exporte o modelo PyTorch como um modelo ONNX.
- Empacote o modelo e o código de inferência.
- Implante o modelo no Azure Functions.
Pré-requisitos
Você deve ter os seguintes pré-requisitos:
- Uma conta AWS.
- Um domínio do SageMaker e um usuário do SageMaker Studio. Para obter instruções sobre como criá-los, consulte Integrar ao domínio do Amazon SageMaker usando a configuração rápida.
- A CLI do Azure.
- Acesso ao Azure e credenciais para uma entidade de serviço que tem permissões para criar e gerenciar Funções do Azure.
Treine um modelo com PyTorch
Nesta seção, detalhamos as etapas para treinar um modelo PyTorch.
Instalar dependências
Instale as bibliotecas para executar as etapas necessárias para o treinamento e implantação do modelo:
pip install torchvision onnx onnxruntime
Conclua a configuração inicial
Começamos importando o SDK da AWS para Python (Boto3) e os votos de SDK Python do SageMaker. Como parte da configuração, definimos o seguinte:
- Um objeto de sessão que fornece métodos de conveniência no contexto do SageMaker e de nossa própria conta.
- Um ARN de função do SageMaker usado para delegar permissões ao serviço de treinamento e hospedagem. Precisamos disso para que esses serviços possam acessar os buckets S3 onde nossos dados e modelo estão armazenados. Para obter instruções sobre como criar uma função que atenda às suas necessidades de negócios, consulte Funções do SageMaker. Para esta postagem, usamos a mesma função de execução de nossa instância de notebook Studio. Conseguimos essa função ligando para
sagemaker.get_execution_role()
. - A região padrão onde nosso trabalho de treinamento será executado.
- O bucket padrão e o prefixo que usamos para armazenar a saída do modelo.
Veja o seguinte código:
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"
Crie o conjunto de dados de treinamento
Usamos o conjunto de dados disponível no bucket público sagemaker-example-files-prod-{region}
. O conjunto de dados contém os seguintes arquivos:
- trem-imagens-idx3-ubyte.gz – Contém imagens do conjunto de treinamento
- train-labels-idx1-ubyte.gz – Contém rótulos de conjuntos de treinamento
- t10k-images-idx3-ubyte.gz – Contém imagens do conjunto de testes
- t10k-labels-idx1-ubyte.gz – Contém rótulos de conjuntos de testes
Usamos otorchvision.datasets
módulo para baixar os dados do intervalo público localmente antes de carregá-los em nosso intervalo de dados de treinamento. Passamos esse local de bucket como uma entrada para o trabalho de treinamento do SageMaker. Nosso script de treinamento usa esse local para baixar e preparar os dados de treinamento e, em seguida, treinar o modelo. Veja o seguinte código:
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,))] ),
)
Crie o roteiro de treinamento
Com o SageMaker, você pode criar seu próprio modelo usando modo de script. Com o modo de script, você pode usar os contêineres pré-construídos do SageMaker e fornecer seu próprio script de treinamento, que contém a definição do modelo, juntamente com quaisquer bibliotecas e dependências personalizadas. O SDK Python do SageMaker passa nosso script como um entry_point
ao contêiner, que carrega e executa a função train do script fornecido para treinar nosso modelo.
Quando o treinamento for concluído, o SageMaker salva a saída do modelo no bucket S3 que fornecemos como parâmetro para o trabalho de treinamento.
Nosso código de treinamento é adaptado do seguinte Script de exemplo PyTorch. O seguinte trecho do código mostra a definição do modelo e a função de trem:
# 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
Treine o modelo
Agora que configuramos nosso ambiente e criamos nosso conjunto de dados de entrada e script de treinamento personalizado, podemos iniciar o treinamento do modelo usando o SageMaker. Usamos o estimador PyTorch no SageMaker Python SDK para iniciar um trabalho de treinamento no SageMaker. Passamos os parâmetros necessários para o estimador e chamamos o método fit. Quando chamamos fit no estimador PyTorch, o SageMaker inicia um trabalho de treinamento usando nosso script como código de treinamento:
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}"
})
Exporte o modelo treinado como um modelo ONNX
Depois que o treinamento for concluído e nosso modelo for salvo no local predefinido no Amazon S3, exportamos o modelo para um modelo ONNX usando o tempo de execução ONNX.
Incluímos o código para exportar nosso modelo para ONNX em nosso script de treinamento para ser executado após a conclusão do treinamento.
PyTorch exporta o modelo para ONNX executando o modelo usando nossa entrada e gravando um rastreamento de operadores usados para calcular a saída. Usamos uma entrada aleatória do tipo certo com o PyTorch torch.onnx.export
função para exportar o modelo para ONNX. Também especificamos a primeira dimensão em nossa entrada como dinâmica para que nosso modelo aceite uma variável batch_size
de entradas durante a inferência.
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 é um formato padrão aberto para modelos de aprendizagem profunda que permite a interoperabilidade entre estruturas de aprendizagem profunda, como PyTorch, Microsoft Cognitive Toolkit (CNTK) e muito mais. Isso significa que você pode usar qualquer uma dessas estruturas para treinar o modelo e posteriormente exportar os modelos pré-treinados no formato ONNX. Ao exportar o modelo para ONNX, você obtém o benefício de uma seleção mais ampla de dispositivos e plataformas de implantação.
Baixe e extraia os artefatos do modelo
O modelo ONNX que nosso script de treinamento salvou foi copiado pelo SageMaker para o Amazon S3 no local de saída que especificamos quando iniciamos o trabalho de treinamento. Os artefatos do modelo são armazenados como um arquivo compactado chamado model.tar.gz
. Baixamos esse arquivo para um diretório local em nossa instância de notebook Studio e extraímos os artefatos do modelo, ou seja, o modelo 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()
Valide o modelo ONNX
O modelo ONNX é exportado para um arquivo chamado mnist-pytorch.onnx
pelo nosso roteiro de treinamento. Depois de baixar e extrair este arquivo, podemos opcionalmente validar o modelo ONNX usando o onnx.checker
módulo. o check_model
A função neste módulo verifica a consistência de um modelo. Uma exceção é gerada se o teste falhar.
import onnx onnx_model = onnx.load("mnist-pytorch.onnx")
onnx.checker.check_model(onnx_model)
Empacote o modelo e o código de inferência
Para esta postagem, usamos a implantação .zip para Azure Functions. Neste método, empacotamos nosso modelo, o código que o acompanha e as configurações do Azure Functions em um arquivo .zip e o publicamos no Azure Functions. O código a seguir mostra a estrutura de diretórios do nosso pacote de implantação:
mnist-onnx
├── function_app.py
├── model
│ └── mnist-pytorch.onnx
└── requirements.txt
Listar dependências
Listamos as dependências do nosso código de inferência no requirements.txt
arquivo na raiz do nosso pacote. Este arquivo é usado para construir o ambiente do Azure Functions quando publicamos o pacote.
azure-functions
numpy
onnxruntime
Escreva o código de inferência
Usamos Python para escrever o seguinte código de inferência, usando a biblioteca ONNX Runtime para carregar nosso modelo e executar a inferência. Isso instrui o aplicativo Azure Functions a disponibilizar o ponto de extremidade no /classify
caminho 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 )
Implantar o modelo no Azure Functions
Agora que temos o código empacotado no formato .zip necessário, estamos prontos para publicá-lo no Azure Functions. Fazemos isso utilizando o Azure CLI, um utilitário de linha de comando para criar e gerir recursos do Azure. Instale a CLI do Azure com o seguinte código:
!pip install -q azure-cli
Em seguida, conclua as seguintes etapas:
- Faça login no Azure:
!az login
- Configure os parâmetros de criação de recursos:
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}"
- Utilize os seguintes comandos para criar a aplicação Azure Functions juntamente com os recursos pré-requisitos:
!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}
- Configure o Azure Functions para que, quando implantarmos o pacote Functions, o
requirements.txt
arquivo é usado para construir nossas dependências de aplicativo:!az functionapp config appsettings set --name {function_app} --resource-group {resource_group_name} --settings @./functionapp/settings.json
- Configure o aplicativo Functions para executar o modelo Python v2 e execute um build no código que ele recebe após a implantação do .zip:
{ "AzureWebJobsFeatureFlags": "EnableWorkerIndexing", "SCM_DO_BUILD_DURING_DEPLOYMENT": true }
- Depois de termos o grupo de recursos, o contêiner de armazenamento e o aplicativo Functions com a configuração correta, publique o código no aplicativo Functions:
!az functionapp deployment source config-zip -g {resource_group_name} -n {function_app} --src {function_archive} --build-remote true
Teste o modelo
Implantamos o modelo ML no Azure Functions como um gatilho HTTP, o que significa que podemos usar a URL do aplicativo Functions para enviar uma solicitação HTTP à função para invocar a função e executar o modelo.
Para preparar a entrada, baixe os arquivos de imagens de teste do bucket de arquivos de exemplo do SageMaker e prepare um conjunto de amostras no formato exigido pelo modelo:
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))
Use a biblioteca de solicitações para enviar uma solicitação posterior ao endpoint de inferência com as entradas de amostra. O endpoint de inferência assume o formato mostrado no código a seguir:
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']
limpar
Quando terminar de testar o modelo, exclua o grupo de recursos junto com os recursos contidos, incluindo o contêiner de armazenamento e o aplicativo Functions:
!az group delete --name {resource_group_name} --yes
Além disso, é recomendado encerrar recursos ociosos no SageMaker Studio para reduzir custos. Para obter mais informações, consulte Economize custos desligando automaticamente recursos ociosos no Amazon SageMaker Studio.
Conclusão
Nesta postagem, mostramos como você pode construir e treinar um modelo de ML com SageMaker e implantá-lo em outro provedor de nuvem. Na solução, usamos um notebook SageMaker Studio, mas para cargas de trabalho de produção, recomendamos usar MLOps para criar fluxos de trabalho de treinamento repetíveis para acelerar o desenvolvimento e a implantação de modelos.
Esta postagem não mostrou todas as maneiras possíveis de implantar e executar um modelo em um ambiente multicloud. Por exemplo, você também pode empacotar seu modelo em uma imagem de contêiner junto com código de inferência e bibliotecas de dependência para executar o modelo como um aplicativo em contêiner em qualquer plataforma. Para obter mais informações sobre essa abordagem, consulte Implante aplicações de contêiner em um ambiente multicloud usando o Amazon CodeCatalyst. A intenção da postagem é mostrar como as organizações podem usar os recursos de IA/ML da AWS em um ambiente multicloud.
Sobre os autores
Raja Vaidyanathan é arquiteto de soluções na AWS, oferecendo suporte a clientes globais de serviços financeiros. Raja trabalha com clientes para arquitetar soluções para problemas complexos com impacto positivo de longo prazo em seus negócios. Ele é um forte profissional de engenharia especializado em estratégia de TI, gerenciamento de dados corporativos e arquitetura de aplicativos, com interesses específicos em análise e aprendizado de máquina.
Amandeep Bajwa é arquiteto de soluções sênior na AWS, apoiando empresas de serviços financeiros. Ele ajuda as organizações a alcançarem seus resultados de negócios, identificando a estratégia apropriada de transformação em nuvem com base nas tendências do setor e nas prioridades organizacionais. Algumas das áreas em que Amandeep presta consultoria são migração para nuvem, estratégia de nuvem (incluindo híbrida e multicloud), transformação digital, dados e análises e tecnologia em geral.
Prema Iyer é gerente técnico sênior de contas do AWS Enterprise Support. Ela trabalha com clientes externos em diversos projetos, ajudando-os a melhorar o valor de suas soluções ao usar a AWS.
- Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
- PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
- PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
- PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
- PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
- Fonte: https://aws.amazon.com/blogs/machine-learning/train-and-deploy-ml-models-in-a-multicloud-environment-using-amazon-sagemaker/
- :tem
- :é
- :não
- :onde
- $UP
- 1
- 10
- 100
- 13
- 25
- 28
- 32
- 7
- 9
- a
- Sobre
- acelerar
- Aceita
- Acesso
- Conta
- Alcançar
- adquirido
- Vantagem
- Depois de
- AI
- AI / ML
- Todos os Produtos
- permite
- juntamente
- já
- tb
- Apesar
- Amazon
- Amazon Sage Maker
- Tela do Amazon SageMaker
- Estúdio Amazon SageMaker
- Amazon Web Services
- an
- Analistas
- analítica
- e
- Anônimo
- Outro
- qualquer
- apache
- app
- Aplicação
- aplicações
- abordagem
- apropriado
- arquitetura
- arquivo
- SOMOS
- áreas
- AS
- avaliação
- At
- automatizar
- automaticamente
- disponível
- AWS
- MACHADOS
- Azul
- baseado
- BE
- sido
- antes
- começar
- benéfico
- beneficiar
- Melhor
- entre
- ambos
- trazer
- mais amplo
- construir
- Prédio
- negócio
- mas a
- by
- chamada
- chamado
- chamada
- CAN
- lona
- capacidades
- transportar
- casas
- Cheques
- classe
- classificar
- clique
- Na nuvem
- código
- cognitivo
- colaborativo
- Empresa
- completar
- integrações
- compliance
- compreensivo
- Computar
- Configuração
- contida
- Recipiente
- Containers
- contém
- contexto
- facilidade
- converter
- conversão
- núcleo
- custos
- poderia
- crio
- criado
- Criar
- criação
- Credenciais
- personalizadas
- Clientes
- dados,
- gestão de dados
- Preparação de dados
- ciência de dados
- conjuntos de dados
- profundo
- deep learning
- mais profundo
- Padrão
- definir
- definição
- demonstrar
- dependências
- Dependência
- implantar
- implantado
- Implantação
- desenvolvimento
- descreve
- detalhe
- detalhes
- Desenvolvimento
- dispositivo
- Dispositivos/Instrumentos
- diferente
- digital
- Transformação Digital
- dígitos
- Dimensão
- discutido
- do
- Estivador
- domínio
- feito
- não
- down
- download
- durante
- dinâmico
- e
- outro
- abraços
- permite
- permitindo
- final
- Ponto final
- Engenharia
- Engenheiros
- Empreendimento
- empresas
- Meio Ambiente
- época
- épocas
- Cada
- exemplo
- Exceto
- exceção
- execução
- experiência
- exportar
- exportações
- externo
- extrato
- falha
- Funcionalidades
- poucos
- Envie o
- Arquivos
- financeiro
- serviços financeiros
- Encontre
- Primeiro nome
- caber
- seguinte
- Escolha
- formato
- Foundation
- Quadro
- enquadramentos
- da
- função
- funções
- Geral
- gera
- generativo
- IA generativa
- ter
- Global
- financeiro global
- Grupo
- Ter
- he
- ajuda
- ajuda
- hospedagem
- Como funciona o dobrador de carta de canal
- Como Negociar
- HTML
- http
- HTTPS
- HÍBRIDO
- ID
- identificar
- inativo
- if
- ilustra
- imagem
- imagens
- Impacto
- importar
- importador
- melhorar
- melhorar
- in
- incluir
- Incluindo
- de treinadores em Entrevista Motivacional
- indústria
- INFORMAÇÕES
- do estado inicial,
- entrada
- inputs
- instalar
- instância
- instruções
- integrar
- integrado
- intenção
- interesses
- Interface
- Interoperabilidade
- para dentro
- IT
- ESTÁ
- Trabalho
- Empregos
- jpg
- json
- língua
- grande
- mais recente
- lança
- APRENDER
- aprendizagem
- Comprimento
- Alavancagem
- bibliotecas
- Biblioteca
- wifecycwe
- Line
- linux
- Lista
- carregar
- cargas
- local
- localmente
- localização
- logging
- longo prazo
- procurando
- fora
- máquina
- aprendizado de máquina
- fazer
- gerencia
- gerenciados
- de grupos
- Gerente
- muitos
- mapa,
- matplotlib
- Posso..
- significa
- Conheça
- atende
- método
- métodos
- Microsoft
- poder
- migração
- ML
- MLOps
- Moda
- modelo
- modelos
- Módulo
- mais
- a maioria
- nome
- Nomeado
- nomeadamente
- você merece...
- necessário
- Cria
- líquido
- rede
- neural
- rede neural
- caderno
- numpy
- objeto
- of
- on
- ONE
- aberto
- open source
- operando
- Operações
- operadores
- Opções
- or
- ordem
- organização
- organizacional
- organizações
- OS
- Outros
- A Nossa
- Fora
- resultados
- saída
- lado de fora
- próprio
- pacote
- empacotado
- parâmetro
- parâmetros
- parte
- particular
- festa
- passar
- passes
- caminho
- Realizar
- permissões
- plataforma
- Plataformas
- platão
- Inteligência de Dados Platão
- PlatãoData
- Popular
- positivo
- possível
- Publique
- Previsões
- preparação
- Preparar
- pré-requisitos
- primário
- Diretor
- problemas
- Processado
- Produção
- produtividade
- Produtos
- profissional
- projetos
- fornecer
- fornecido
- provedor
- fornece
- público
- publicar
- Python
- pytorch
- Links
- angariado
- acaso
- pronto
- recebe
- Recomenda
- gravação
- reduzir
- referir
- Independentemente
- região
- registro
- relativo
- Repetivel
- solicitar
- pedidos
- requerer
- requeridos
- Requisitos
- recurso
- Recursos
- resposta
- resultar
- resultando
- retorno
- certo
- Tipo
- raiz
- Execute
- corrida
- é executado
- sábio
- mesmo
- salvo
- Escala
- exploração
- cenários
- Ciência
- cientistas
- escrita
- Sdk
- secundário
- Seção
- seções
- segurança
- Vejo
- doadores,
- AUTO
- enviar
- senior
- serviço
- Serviços
- Sessão
- conjunto
- Configurações
- instalação
- Shape
- ela
- rede de apoio social
- mostrar
- mostrou
- mostrando
- Shows
- Encerre
- desligando
- simples
- situações
- hábil
- Habilidades
- So
- Software
- solução
- Soluções
- alguns
- fonte
- soberania
- especificada
- Etapa
- padrão
- começo
- começado
- começa
- Passos
- armazenamento
- loja
- armazenadas
- Estratégia
- Tanga
- mais forte,
- estrutura
- estudo
- Subseqüentemente
- entraram com sucesso
- tal
- ajuda
- Apoiar
- suportes
- Tire
- toma
- Target
- Profissionais
- Dados Técnicos:
- Tecnologias
- Tecnologia
- dez
- fluxo tensor
- teste
- testado
- ensaio
- texto
- que
- A
- A fonte
- deles
- Eles
- si mesmos
- então
- Este
- deles
- coisa
- Terceiro
- isto
- vezes
- para
- kit de ferramentas
- ferramentas
- tocha
- Visão da tocha
- Traçar
- Trem
- treinado
- Training
- Transformar
- Transformação
- Estratégia de Transformação
- transformações
- Tendências
- desencadear
- desencadeado
- verdadeiro
- tentar
- tipo
- único
- carregado
- Upload
- URL
- usar
- caso de uso
- usava
- Utilizador
- usos
- utilização
- utilidade
- VALIDAR
- valor
- variável
- variedade
- fornecedores
- versões
- vulnerabilidade
- queremos
- foi
- maneiras
- we
- web
- serviços web
- Web-Based
- BEM
- quando
- qual
- precisarão
- de
- dentro
- fluxos de trabalho
- trabalho
- escrever
- escrito
- X
- ainda
- Vocês
- investimentos
- zefirnet
- Zip