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á.
# Executar trabalhos de treinamento em um cluster heterogêneo
Usando o recurso de cluster heterogêneo do SageMaker Training, você pode executar um trabalho de treinamento com vários tipos de instâncias de ML para uma melhor escalabilidade e utilização de recursos para diferentes tarefas e propósitos de treinamento de ML. Por exemplo, se o seu trabalho de treinamento em um cluster com instâncias de GPU apresentar problemas de baixa utilização da GPU e de gargalo de CPU devido a tarefas intensivas de CPU, o uso de um cluster heterogêneo pode ajudar a aliviar tarefas intensivas de CPU adicionando grupos de instâncias de CPU mais econômicos, resolvendo esses problemas de gargalo e alcançando uma melhor utilização da GPU.
**nota**
Esse recurso está disponível no SageMaker Python SDK v2.98.0 e versões posteriores.
**nota**
Esse recurso está disponível por meio das classes de estimadores de [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)estrutura [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)e SageMaker IA. As estruturas suportadas são PyTorch v1.10 ou posterior e TensorFlow v2.6 ou posterior.
Veja também o blog [Melhore a relação preço/desempenho de seu treinamento de modelos usando clusters heterogêneos de SageMaker IA da Amazon](https://aws.amazon.com/blogs/machine-learning/improve-price-performance-of-your-model-training-using-amazon-sagemaker-heterogeneous-clusters/).
**Topics**
+ [Configure um trabalho de treinamento com um cluster heterogêneo na Amazon AI SageMaker](train-heterogeneous-cluster-configure.md)
+ [Execute treinamento distribuído em um cluster heterogêneo na Amazon AI SageMaker](train-heterogeneous-cluster-configure-distributed.md)
+ [Modifique seu script de treinamento para atribuir grupos de instâncias](train-heterogeneous-cluster-modify-training-script.md)
# Configure um trabalho de treinamento com um cluster heterogêneo na Amazon AI SageMaker
Esta seção fornece instruções sobre como executar um trabalho de treinamento usando um cluster heterogêneo que consiste em vários tipos de instância.
Verifique o seguinte antes de começar:
+ Todos os grupos de instâncias compartilham a mesma imagem do Docker e o mesmo script de treinamento. Portanto, seu script de treinamento deve ser modificado para detectar a qual grupo de instâncias ele pertence e bifurcar a execução adequadamente.
+ O recurso de cluster heterogêneo não é compatível com o modo local de SageMaker IA.
+ Os fluxos de CloudWatch log da Amazon de um trabalho de treinamento de cluster heterogêneo não são agrupados por grupos de instâncias. Você precisa descobrir nos logs quais são os nós que estão em qual grupo.
**Topics**
+ [Opção 1: usar o SDK do SageMaker Python](#train-heterogeneous-cluster-configure-pysdk)
+ [Opção 2: Usando o nível baixo SageMaker APIs](#train-heterogeneous-cluster-configure-api)
## Opção 1: usar o SDK do SageMaker Python
Siga as instruções sobre como configurar grupos de instâncias para um cluster heterogêneo usando o SDK do Python SageMaker .
1. Para configurar grupos de instâncias de um cluster heterogêneo para um trabalho de treinamento, use a classe `sagemaker.instance_group.InstanceGroup`. Você pode especificar um nome personalizado para cada grupo de instâncias, o tipo de instância e o número de instâncias para cada grupo de instâncias. Para obter mais informações, consulte [sagemaker.instance\$1group. InstanceGroup](https://sagemaker.readthedocs.io/en/stable/api/utility/instance_group.html)na documentação do *SageMaker AI Python SDK*.
**nota**
Para obter mais informações sobre os tipos de instância disponíveis e o número máximo de grupos de instâncias que você pode configurar em um cluster heterogêneo, consulte a referência da [ InstanceGroup](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InstanceGroup.html)API.
O exemplo de código a seguir mostra como configurar dois grupos de instâncias que consistem em duas instâncias `ml.c5.18xlarge` somente de CPU nomeadas `instance_group_1` e uma instância de GPU `ml.p3dn.24xlarge` chamada `instance_group_2`, conforme mostrado no diagrama a seguir.
![\[Um exemplo conceitual de como os dados podem ser atribuídos no SageMaker Training Job.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/HCTraining.png)
O diagrama anterior mostra um exemplo conceitual de como os processos de pré-treinamento, como o pré-processamento de dados, podem ser atribuídos ao grupo de instâncias da CPU e transmitir os dados pré-processados para o grupo de instâncias da GPU.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup(
"instance_group_1", "ml.c5.18xlarge", 2
)
instance_group_2 = InstanceGroup(
"instance_group_2", "ml.p3dn.24xlarge", 1
)
```
1. Usando os objetos do grupo de instâncias, configure canais de entrada de treinamento e atribua grupos de instâncias aos canais por meio do `instance_group_names` argumento do [sagemaker.inputs. TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)classe. O argumento `instance_group_names` aceita uma lista de strings de nomes de grupos de instâncias.
O exemplo a seguir mostra como definir dois canais de entrada de treinamento e atribuir os grupos de instâncias criados no exemplo da etapa anterior. Você também pode especificar caminhos de bucket do Amazon S3 para o argumento `s3_data` para que os grupos de instâncias processem dados para suas finalidades de uso.
```
from sagemaker.inputs import TrainingInput
training_input_channel_1 = TrainingInput(
s3_data_type='S3Prefix', # Available Options: S3Prefix | ManifestFile | AugmentedManifestFile
s3_data='s3://your-training-data-storage/folder1',
distribution='FullyReplicated', # Available Options: FullyReplicated | ShardedByS3Key
input_mode='File', # Available Options: File | Pipe | FastFile
instance_groups=["instance_group_1"]
)
training_input_channel_2 = TrainingInput(
s3_data_type='S3Prefix',
s3_data='s3://your-training-data-storage/folder2',
distribution='FullyReplicated',
input_mode='File',
instance_groups=["instance_group_2"]
)
```
Para obter mais informações sobre os argumentos de `TrainingInput`, consulte os seguintes links:
+ O [sagemaker.inputs. TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)classe na documentação do *SageMaker Python SDK*
+ A DataSource API [S3](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html) na referência da *API SageMaker AI*
1. Configure um estimador de SageMaker IA com o `instance_groups` argumento, conforme mostrado no exemplo de código a seguir. O argumento `instance_groups` aceita uma lista de objetos `InstanceGroup`.
**nota**
O recurso de cluster heterogêneo está disponível por meio das classes de estimadores de [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)estrutura [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)e SageMaker IA. As estruturas suportadas são PyTorch v1.10 ou posterior e TensorFlow v2.6 ou posterior. Para encontrar uma lista completa dos contêineres, versões do framework e versões do Python disponíveis, consulte [Contêineres do SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) no repositório do AWS Deep Learning Container GitHub .
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
entry_point='my-training-script.py',
framework_version='x.y.z', # 1.10.0 or later
py_version='pyxy',
job_name='my-training-job-with-heterogeneous-cluster',
instance_groups=[instance_group_1, instance_group_2]
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
entry_point='my-training-script.py',
framework_version='x.y.z', # 2.6.0 or later
py_version='pyxy',
job_name='my-training-job-with-heterogeneous-cluster',
instance_groups=[instance_group_1, instance_group_2]
)
```
------
**nota**
O `instance_type` par de `instance_count` argumentos e e o `instance_groups` argumento da classe de SageMaker estimadores de IA são mutuamente exclusivos. Para um treinamento de cluster homogêneo, use o par de argumentos `instance_type` e `instance_count`. Para treinamento de clusters heterogêneos, use `instance_groups`.
**nota**
Para encontrar uma lista completa dos contêineres, versões do framework e versões do Python disponíveis, consulte [Contêineres do SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) no repositório do AWS Deep Learning Container GitHub .
1. Configure o `estimator.fit` método com os canais de entrada de treinamento configurados com os grupos de instâncias e inicie o trabalho de treinamento.
```
estimator.fit(
inputs={
'training': training_input_channel_1,
'dummy-input-channel': training_input_channel_2
}
)
```
## Opção 2: Usando o nível baixo SageMaker APIs
Se você usa o AWS Command Line Interface ou AWS SDK para Python (Boto3) e deseja usar o nível baixo SageMaker APIs para enviar uma solicitação de trabalho de treinamento com um cluster heterogêneo, consulte as referências de API a seguir.
+ [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)
+ [ResourceConfig ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ResourceConfig.html)
+ [InstanceGroup](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InstanceGroup.html)
+ [S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html)
# Execute treinamento distribuído em um cluster heterogêneo na Amazon AI SageMaker
Por meio do `distribution` argumento da classe de estimador de SageMaker IA, você pode atribuir um grupo de instâncias específico para executar o treinamento distribuído. Por exemplo, suponha que você tenha os dois grupos de instâncias a seguir e queira executar um treinamento com várias GPUs em um deles.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup("instance_group_1", "ml.c5.18xlarge", 1)
instance_group_2 = InstanceGroup("instance_group_2", "ml.p3dn.24xlarge", 2)
```
Você pode definir a configuração de treinamento distribuído para um dos grupos de instâncias. Por exemplo, os exemplos de código a seguir mostram como atribuir `training_group_2` com duas instâncias `ml.p3dn.24xlarge` à configuração de treinamento distribuído.
**nota**
Atualmente, somente um grupo de instâncias de um cluster heterogêneo pode ser especificado para a configuração de distribuição.
**Com MPI**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"mpi": {
"enabled": True, "processes_per_host": 8
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"mpi": {
"enabled": True, "processes_per_host": 8
},
"instance_groups": [instance_group_2]
}
)
```
------
**Com a biblioteca paralela de dados de SageMaker IA**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"dataparallel": {
"enabled": True
}
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"dataparallel": {
"enabled": True
}
},
"instance_groups": [instance_group_2]
}
)
```
------
**nota**
Ao usar a biblioteca paralela de dados de SageMaker IA, verifique se o grupo de instâncias consiste nos [tipos de instância compatíveis com a biblioteca](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-data-parallel-support.html#distributed-data-parallel-supported-instance-types).
Para obter mais informações sobre a SageMaker biblioteca paralela de dados de [SageMaker IA, consulte Treinamento paralelo de dados](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel.html) de IA.
**Com a biblioteca paralela de modelos de SageMaker IA**
------
#### [ PyTorch ]
```
from sagemaker.pytorch import PyTorch
estimator = PyTorch(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"modelparallel": {
"enabled":True,
"parameters": {
... # SageMaker AI model parallel parameters
}
}
},
"instance_groups": [instance_group_2]
}
)
```
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
...
instance_groups=[instance_group_1, instance_group_2],
distribution={
"smdistributed": {
"modelparallel": {
"enabled":True,
"parameters": {
... # SageMaker AI model parallel parameters
}
}
},
"instance_groups": [instance_group_2]
}
)
```
------
Para obter mais informações sobre a SageMaker biblioteca paralela de modelos de [SageMaker IA, consulte Treinamento paralelo de modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel.html) de IA.
# Modifique seu script de treinamento para atribuir grupos de instâncias
Com a configuração de cluster heterogênea nas seções anteriores, você preparou o ambiente de SageMaker treinamento e as instâncias para seu trabalho de treinamento. Para atribuir ainda mais os grupos de instâncias a determinadas tarefas de treinamento e processamento de dados, a próxima etapa é modificar seu script de treinamento. Por padrão, o trabalho de treinamento simplesmente cria réplicas de scripts de treinamento para todos os nós, independentemente do tamanho da instância, e isso pode levar a perda de desempenho.
Por exemplo, se você misturar instâncias de CPU e instâncias de GPU em um cluster heterogêneo enquanto passa um script de treinamento de rede neural profunda para o `entry_point` argumento do estimador de SageMaker IA, o `entry_point` script é replicado para cada instância. Isso significa que, sem a atribuição adequada de tarefas, as instâncias de CPU também executam o script inteiro e iniciam o trabalho de treinamento projetado para treinamento distribuído em instâncias de GPU. Portanto, você deve fazer alterações nas funções de processamento específicas que deseja descarregar e executar nas instâncias da CPU. Você pode usar as variáveis de ambiente de SageMaker IA para recuperar as informações do cluster heterogêneo e permitir que processos específicos sejam executados adequadamente.
Quando seu trabalho de treinamento é iniciado, seu script de treinamento lê as informações do ambiente de SageMaker treinamento que incluem a configuração heterogênea do cluster. A configuração contém informações como os grupos de instâncias atuais, os hosts atuais em cada grupo e em qual grupo o host atual reside.
Você pode consultar as informações do grupo de instâncias durante a fase de inicialização de um trabalho de treinamento de SageMaker IA das seguintes maneiras.
**(Recomendado) Ler as informações do grupo de instâncias com o kit SageMaker de ferramentas de treinamento**
Use o módulo de ambiente Python fornecido pela biblioteca do [kit de ferramentas de SageMaker treinamento](https://github.com/aws/sagemaker-training-toolkit). A biblioteca do kit de ferramentas é pré-instalada nos [contêineres da SageMaker estrutura](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) para TensorFlow e PyTorch, portanto, você não precisa de uma etapa adicional de instalação ao usar os contêineres pré-criados. Essa é a forma recomendada de recuperar as variáveis de ambiente de SageMaker IA com menos alterações de código em seu script de treinamento.
```
from sagemaker_training import environment
env = environment.Environment()
```
Variáveis de ambiente relacionadas ao SageMaker treinamento geral e clusters heterogêneos:
+ `env.is_hetero` - Retorna um resultado booleano, independentemente de um cluster heterogêneo estar configurado ou não.
+ `env.current_host` - Retorna o host atual.
+ `env.current_instance_type` - Retorna o tipo de instância do host atual.
+ `env.current_instance_group` - Retorna o nome do grupo de instâncias atual.
+ `env.current_instance_group_hosts` - Retorna uma lista de hosts no grupo de instâncias atual.
+ `env.instance_groups` - Retorna uma lista de nomes de grupos de instâncias usados para treinamento.
+ `env.instance_groups_dict` - Retorna toda a configuração heterogênea do cluster do trabalho de treinamento.
+ `env.distribution_instance_groups`— Retorna uma lista de grupos de instâncias atribuídos ao `distribution` parâmetro da classe do estimador de SageMaker IA.
+ `env.distribution_hosts`— Retorna uma lista de hosts pertencentes aos grupos de instâncias atribuídos ao `distribution` parâmetro da classe do estimador de SageMaker IA.
Por exemplo, considere o exemplo a seguir de um cluster heterogêneo que consiste em dois grupos de instâncias.
```
from sagemaker.instance_group import InstanceGroup
instance_group_1 = InstanceGroup(
"instance_group_1", "ml.c5.18xlarge", 1)
instance_group_2 = InstanceGroup(
"instance_group_2", "ml.p3dn.24xlarge", 2)
```
A saída do exemplo `env.instance_groups_dict` de cluster heterogêneo deve ser semelhante à seguinte:
```
{
"instance_group_1": {
"hosts": [
"algo-2"
],
"instance_group_name": "instance_group_1",
"instance_type": "ml.c5.18xlarge"
},
"instance_group_2": {
"hosts": [
"algo-3",
"algo-1"
],
"instance_group_name": "instance_group_2",
"instance_type": "ml.p3dn.24xlarge"
}
}
```
**(Opcional) Lendo as informações do grupo de instâncias do arquivo JSON de configuração do recurso**
Se preferir recuperar as variáveis de ambiente no formato JSON, você poderá usar diretamente o arquivo JSON de configuração do recurso. Por padrão, o arquivo JSON em uma instância de SageMaker treinamento está localizado `/opt/ml/input/config/resourceconfig.json` em.
```
file_path = '/opt/ml/input/config/resourceconfig.json'
config = read_file_as_json(file_path)
print(json.dumps(config, indent=4, sort_keys=True))
```