

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Use modelos básicos com o SageMaker Python SDK
<a name="jumpstart-foundation-models-use-python-sdk"></a>

Todos os modelos JumpStart básicos estão disponíveis para implantação programática usando o SageMaker Python SDK.

Para implantar modelos de base disponíveis ao público, você pode usar o ID do modelo. Você pode encontrar o modelo IDs para todos os modelos básicos disponíveis publicamente nos [Algoritmos integrados com tabela de modelos pré-treinada](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html). Pesquise o nome de um modelo de base na barra de **Pesquisa**. Use o menu suspenso **Mostrar entradas** ou os controles de paginação para navegar pelos modelos disponíveis.

Modelos proprietários devem ser implantados usando as informações do pacote do modelo após a assinatura do modelo em AWS Marketplace. 

Você pode encontrar a lista de modelos JumpStart disponíveis em[Modelos de base disponíveis](jumpstart-foundation-models-latest.md).

**Importante**  
Alguns modelos de base exigem aceitação explícita de um contrato de licença do usuário final (EULA). Para obter mais informações, consulte [Aceitação do EULA com o SDK SageMaker Python](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula-python-sdk).

As seções a seguir mostram como ajustar os modelos de base disponíveis ao público usando a função `JumpStartEstimator`, implantar modelos de base disponíveis ao público usando a função `JumpStartModel` e implantar modelos de base proprietários usando a função `ModelPackage`.

**Topics**
+ [Ajustar modelos de base disponíveis ao público com a função `JumpStartEstimator`](jumpstart-foundation-models-use-python-sdk-estimator-class.md)
+ [Implantar modelos de base disponíveis ao público com a função `JumpStartModel`](jumpstart-foundation-models-use-python-sdk-model-class.md)
+ [Implementar modelos de base proprietários com a função `ModelPackage`](jumpstart-foundation-models-use-python-sdk-proprietary.md)

# Ajustar modelos de base disponíveis ao público com a função `JumpStartEstimator`
<a name="jumpstart-foundation-models-use-python-sdk-estimator-class"></a>

**nota**  
Para ver instruções sobre como ajustar os modelos de base em um hub privado selecionado, consulte [Ajustar modelos de hub selecionado](jumpstart-curated-hubs-fine-tune.md).

Você pode ajustar um algoritmo integrado ou um modelo pré-treinado em apenas algumas linhas de código usando o SDK. SageMaker Python

1. Primeiro, encontre o ID do modelo de sua escolha na [tabela de algoritmos integrados com modelos pré-treinados](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html). 

1. Usando o ID do modelo, defina seu trabalho de treinamento como um JumpStart estimador.

   ```
   from sagemaker.jumpstart.estimator import JumpStartEstimator
   
   model_id = "huggingface-textgeneration1-gpt-j-6b"
   estimator = JumpStartEstimator(model_id=model_id)
   ```

1. Execute `estimator.fit()` em seu modelo, indicando os dados de treinamento a serem usados no ajuste.

   ```
   estimator.fit(
       {"train": training_dataset_s3_path, "validation": validation_dataset_s3_path}
   )
   ```

1. Em seguida, use o método `deploy` para implantar automaticamente seu modelo para inferência. Neste exemplo, usamos o modelo GPT-J 6B do Hugging Face.

   ```
   predictor = estimator.deploy()
   ```

1. Depois, você pode executar a inferência com o modelo implantado usando o método `predict`.

   ```
   question = "What is Southern California often abbreviated as?"
   response = predictor.predict(question)
   print(response)
   ```

**nota**  
Este exemplo usa o modelo de base GPT-J 6B, que é adequado para diversos casos de uso de geração de texto, incluindo respostas a perguntas, reconhecimento de entidades nomeadas, resumos e muito mais. Para obter mais informações sobre os casos de uso do modelo, consulte [Modelos de base disponíveis](jumpstart-foundation-models-latest.md).

Você também pode especificar versões do modelo ou tipos de instância ao criar seu `JumpStartEstimator`. Para obter mais informações sobre a `JumpStartEstimator ` classe e seus parâmetros, consulte [JumpStartEstimator](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.jumpstart.estimator.JumpStartEstimator).

## Verificar os tipos de instância padrão
<a name="jumpstart-foundation-models-use-python-sdk-estimator-class-instance-types"></a>

Você pode incluir versões específicas do modelo ou tipos de instância ao ajustar um modelo pré-treinado usando a função `JumpStartEstimator`. Todos os JumpStart modelos têm um tipo de instância padrão. Recupere o tipo de instância de treinamento padrão usando o seguinte código:

```
from sagemaker import instance_types

instance_type = instance_types.retrieve_default(
    model_id=model_id,
    model_version=model_version,
    scope="training")
print(instance_type)
```

Você pode ver todos os tipos de instância compatíveis com um determinado JumpStart modelo com o `instance_types.retrieve()` método.

## Verificar hiperparâmetros padrão
<a name="jumpstart-foundation-models-use-python-sdk-estimator-class-hyperparameters"></a>

Para verificar os hiperparâmetros padrão usados para treinamento, você pode usar o método `retrieve_default()` da função `hyperparameters`.

```
from sagemaker import hyperparameters

my_hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)
print(my_hyperparameters)

# Optionally override default hyperparameters for fine-tuning
my_hyperparameters["epoch"] = "3"
my_hyperparameters["per_device_train_batch_size"] = "4"

# Optionally validate hyperparameters for the model
hyperparameters.validate(model_id=model_id, model_version=model_version, hyperparameters=my_hyperparameters)
```

Para obter mais informações sobre hiperparâmetros disponíveis, consulte [Hiperparâmetros de ajuste normalmente aceitos](jumpstart-foundation-models-fine-tuning.md#jumpstart-foundation-models-fine-tuning-hyperparameters).

## Verificar as definições de métricas padrão
<a name="jumpstart-foundation-models-use-python-sdk-estimator-class-metric-definitions"></a>

Você também pode verificar as definições de métricas padrão:

```
print(metric_definitions.retrieve_default(model_id=model_id, model_version=model_version))
```

# Implantar modelos de base disponíveis ao público com a função `JumpStartModel`
<a name="jumpstart-foundation-models-use-python-sdk-model-class"></a>

Você pode implantar um algoritmo integrado ou um modelo pré-treinado em um endpoint de SageMaker IA em apenas algumas linhas de código usando o SageMaker Python SDK.

1. Primeiro, encontre o ID do modelo de sua escolha na [tabela de algoritmos integrados com modelos pré-treinados](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html).

1. Usando o ID do modelo, defina seu modelo como um JumpStart modelo.

   ```
   from sagemaker.jumpstart.model import JumpStartModel
   
   model_id = "huggingface-text2text-flan-t5-xl"
   my_model = JumpStartModel(model_id=model_id)
   ```

1. Use o método `deploy` para implantar automaticamente seu modelo para inferência. Neste exemplo, usamos o modelo FLAN-T5 XL do Hugging Face.

   ```
   predictor = my_model.deploy()
   ```

1. Depois, você pode executar a inferência com o modelo implantado usando o método `predict`.

   ```
   question = "What is Southern California often abbreviated as?"
   response = predictor.predict(question)
   print(response)
   ```

**nota**  
Este exemplo usa o modelo de base FLAN-T5 XL, que é adequado para diversos casos de uso de geração de texto, incluindo respostas a perguntas, resumos, criação de chatbots e muito mais. Para obter mais informações sobre os casos de uso do modelo, consulte [Modelos de base disponíveis](jumpstart-foundation-models-latest.md).

Para obter mais informações sobre a `JumpStartModel ` classe e seus parâmetros, consulte [JumpStartModel](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.jumpstart.model.JumpStartModel).

## Verificar os tipos de instância padrão
<a name="jumpstart-foundation-models-use-python-sdk-model-class-instance-types"></a>

Você também pode incluir versões específicas do modelo ou tipos de instância ao implantar um modelo pré-treinado usando a função `JumpStartModel`. Todos os JumpStart modelos têm um tipo de instância padrão. Recupere o tipo de instância de implantação padrão usando o seguinte código:

```
from sagemaker import instance_types

instance_type = instance_types.retrieve_default(
    model_id=model_id,
    model_version=model_version,
    scope="inference")
print(instance_type)
```

Veja todos os tipos de instância compatíveis com um determinado JumpStart modelo com o `instance_types.retrieve()` método.

## Usar componentes de inferência para implantar vários modelos em um endpoint compartilhado
<a name="jumpstart-foundation-models-use-python-sdk-model-class-endpoint-types"></a>

Um componente de inferência é um objeto de hospedagem de SageMaker IA que você pode usar para implantar um ou mais modelos em um endpoint para aumentar a flexibilidade e a escalabilidade. Você deve alterar o `endpoint_type` para que seu JumpStart modelo seja, inference-component-based em vez do endpoint padrão baseado em modelo. 

```
predictor = my_model.deploy(
    endpoint_name = 'jumpstart-model-id-123456789012', 
    endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED
)
```

Para obter mais informações sobre a criação de endpoints com componentes de inferência e a implantação de modelos de SageMaker IA, consulte. [Utilização compartilhada de recursos com vários modelos](realtime-endpoints-deploy-models.md#deployed-shared-utilization)

## Verificar os formatos válidos de inferência de entrada e saída
<a name="jumpstart-foundation-models-use-python-sdk-model-class-input-output"></a>

Para verificar os formatos válidos de entrada e saída de dados para inferência, você pode usar o método `retrieve_options()` das funções `Serializers` e `Deserializers`.

```
print(sagemaker.serializers.retrieve_options(model_id=model_id, model_version=model_version))
print(sagemaker.deserializers.retrieve_options(model_id=model_id, model_version=model_version))
```

## Verificar os cabeçalhos Accept e Content-Type compatíveis
<a name="jumpstart-foundation-models-use-python-sdk-model-class-content-types"></a>

Além disso, você pode usar o método `retrieve_options()` para verificar os cabeçalhos Accept e Content-Type compatíveis para um modelo.

```
print(sagemaker.content_types.retrieve_options(model_id=model_id, model_version=model_version))
print(sagemaker.accept_types.retrieve_options(model_id=model_id, model_version=model_version))
```

Para obter mais informações sobre utilitários, consulte [Utilitário APIs](https://sagemaker.readthedocs.io/en/stable/api/utility/index.html).

# Implementar modelos de base proprietários com a função `ModelPackage`
<a name="jumpstart-foundation-models-use-python-sdk-proprietary"></a>

Modelos proprietários devem ser implantados usando as informações do pacote do modelo após a assinatura do modelo em AWS Marketplace. Para obter mais informações sobre SageMaker IA e AWS Marketplace, consulte [Comprar e vender algoritmos e modelos de SageMaker IA da Amazon em AWS Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-marketplace.html). Para encontrar AWS Marketplace links para os modelos proprietários mais recentes, consulte [Introdução à Amazon SageMaker JumpStart](https://aws.amazon.com/sagemaker/jumpstart/getting-started/?sagemaker-jumpstart-cards.sort-by=item.additionalFields.priority&sagemaker-jumpstart-cards.sort-order=asc&awsf.sagemaker-jumpstart-filter-product-type=product-type%23foundation-model&awsf.sagemaker-jumpstart-filter-text=*all&awsf.sagemaker-jumpstart-filter-vision=*all&awsf.sagemaker-jumpstart-filter-tabular=*all&awsf.sagemaker-jumpstart-filter-audio-tasks=*all&awsf.sagemaker-jumpstart-filter-multimodal=*all&awsf.sagemaker-jumpstart-filter-RL=*all&sagemaker-jumpstart-cards.q=proprietary&sagemaker-jumpstart-cards.q_operator=AND).

Depois de assinar o modelo de sua escolha AWS Marketplace, você pode implantar o modelo básico usando o SageMaker Python SDK e o SDK associado ao provedor do modelo. Por exemplo, AI21 Labs, Cohere e LightOn use os `lightonsage` pacotes `"ai21[SM]"``cohere-sagemaker`, e, respectivamente.

Por exemplo, para definir um JumpStart modelo usando o Jurassic-2 Jumbo Instruct do AI21 Labs, use o seguinte código: 

```
import sagemaker
import ai21

role = get_execution_role()
sagemaker_session = sagemaker.Session()
model_package_arn = "arn:aws:sagemaker:us-east-1:865070037744:model-package/j2-jumbo-instruct-v1-1-43-4e47c49e61743066b9d95efed6882f35"

my_model = ModelPackage(
    role=role, model_package_arn=model_package_arn, sagemaker_session=sagemaker_session
)
```

Por step-by-step exemplo, encontre e execute o notebook associado ao modelo básico proprietário de sua escolha no SageMaker Studio Classic. Consulte [Use modelos básicos no Amazon SageMaker Studio Classic](jumpstart-foundation-models-use-studio.md) para obter mais informações. Para obter mais informações sobre o SageMaker Python SDK, consulte [https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.model.ModelPackage](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.model.ModelPackage).