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á.
# Algoritmo de Aprendizagem linear
*Modelos lineares* são algoritmos de aprendizagem supervisionada para resolver problemas de classificação ou regressão. Para entrada, você dá ao modelo exemplos rotulados (*x*, *y*). *x* é um vetor altamente dimensional e *y* é um rótulo numérico. Para problemas de classificação binária, o rótulo deve ser 0 ou 1. Para problemas de classificação de várias classes, os rótulos devem ser de 0 a `num_classes` - 1. Para problemas de regressão, *y* é um número real. O algoritmo aprende uma função linear ou, para problemas de classificação, uma função de limite linear, e mapeia um vetor *x* para uma aproximação do rótulo *y*.
O algoritmo de aprendizado linear da Amazon SageMaker AI fornece uma solução para problemas de classificação e regressão. Com o algoritmo de SageMaker IA, você pode explorar simultaneamente diferentes objetivos de treinamento e escolher a melhor solução em um conjunto de validação. Você também pode explorar um grande número de modelos e escolher o melhor. O melhor modelo otimiza uma das seguintes opções:
+ Objetivos contínuos, como erro quadrático médio, perda de entropia cruzada e erro absoluto.
+ Objetivos discretos adequados para classificação, como medida F1, precisão, recall ou acurácia.
Em comparação com métodos que fornecem uma solução apenas para objetivos contínuos, o algoritmo de aprendizado linear de SageMaker IA fornece um aumento significativo na velocidade em relação às técnicas ingênuas de otimização de hiperparâmetros. Ele também é mais conveniente.
O algoritmo de aprendizagem linear requer uma matriz de dados, com linhas representando as observações e colunas representando as dimensões dos recursos. Ele também requer uma coluna adicional que contenha os rótulos que correspondem aos pontos de dados. No mínimo, o Amazon SageMaker AI linear learner exige que você especifique os locais dos dados de entrada e saída e o tipo de objetivo (classificação ou regressão) como argumentos. A dimensão do recurso também é necessária. Para obter mais informações, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). É possível especificar parâmetros adicionais no mapa de strings de `HyperParameters` do corpo da solicitação. Esses parâmetros controlam o procedimento de otimização ou as especificidades da função objetiva na qual o treinamento é feito. Por exemplo, o número de epochs, regularização e tipo de perda.
Se você estiver usando o [Managed Spot Training](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html), o algoritmo linear do aluno suporta o uso de [pontos de verificação para tirar uma foto do estado do modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-checkpoints.html).
**Topics**
+ [Interface de entrada/saída para o algoritmo de aprendizagem linear](#ll-input_output)
+ [Recomendação de instâncias do EC2 para o algoritmo de aprendizagem linear](#ll-instances)
+ [Cadernos de amostra para aprendizagem linear](#ll-sample-notebooks)
+ [Como a aprendizagem linear funciona](ll_how-it-works.md)
+ [Hiperparâmetros da aprendizagem linear](ll_hyperparameters.md)
+ [Ajustar um modelo de aprendizagem linear](linear-learner-tuning.md)
+ [Formatos de resposta da aprendizagem linear](LL-in-formats.md)
## Interface de entrada/saída para o algoritmo de aprendizagem linear
O algoritmo de aprendizado linear da Amazon SageMaker AI oferece suporte a três canais de dados: treinamento, validação (opcional) e teste (opcional). Se você fornecer dados de validação, o `S3DataDistributionType` deverá ser `FullyReplicated`. O algoritmo registra a perda de validação em todos os epochs e usa uma amostra dos dados de validação para calibrar e selecionar o melhor modelo. Se você não fornecer dados de validação, o algoritmo usará uma amostra dos dados de treinamento para calibrar e selecionar o modelo. Se você fornecer dados de teste, os logs do algoritmo incluirão a pontuação do teste para o modelo final.
**Para treinamento**, o algoritmo de Aprendizagem linear oferece suporte aos formatos `recordIO-wrapped protobuf` e `CSV`. Para o tipo de entrada `application/x-recordio-protobuf`, há suporte apenas para os tensores Float32. Para o tipo de entrada `text/csv`, a primeira coluna é considerada o rótulo, que é a variável de destino para previsão. É possível usar o modo de Arquivo ou de Pipe para treinar modelos de Aprendizagem linear em dados formatados como `recordIO-wrapped-protobuf` ou como `CSV`.
**Para inferência**, o algoritmo de Aprendizagem linear oferece suporte aos formatos `application/json`, `application/x-recordio-protobuf` e `text/csv`. Quando você faz previsões sobre novos dados, o formato da resposta depende do tipo de modelo. **Para regressão** (`predictor_type='regressor'`), o `score` é a previsão gerada pelo modelo. **Para classificação** (`predictor_type='binary_classifier'` ou `predictor_type='multiclass_classifier'`), o modelo retorna um `score` e um `predicted_label`. O `predicted_label` é a classe prevista pelo modelo e `score` mede a intensidade dessa previsão.
+ **Para classificação binária**, `predicted_label` é `0` ou `1`, e `score` é um único número de ponto flutuante que indica a intensidade com que o algoritmo acredita que o rótulo deve ser 1.
+ **Para classificação multiclasse**, a `predicted_class` será um número inteiro de `0` a `num_classes-1` e a `score` será uma lista de um número de ponto flutuante por classe.
Para interpretar o `score` em problemas de classificação, você deve considerar a função de perda usada. Se o valor do hiperparâmetro `loss` for `logistic` para classificação binária ou `softmax_loss` para classificação de várias classes, o `score` pode ser interpretado como a probabilidade da classe correspondente. Esses são os valores de perda usados pela aprendizagem linear quando o valor `loss` é o valor padrão `auto`. No entanto, se a perda for definido como `hinge_loss`, a pontuação não poderá ser interpretada como probabilidade. Isso ocorre porque a perda da dobradiça corresponde a um classificador Support Vector que não produz estimativas de probabilidade.
Para obter mais informações sobre formatos de arquivo de entrada e saída, consulte [Formatos de resposta da aprendizagem linear](LL-in-formats.md). Para obter mais informações sobre os formatos de inferência e sobre o [Cadernos de amostra para aprendizagem linear](#ll-sample-notebooks).
## Recomendação de instâncias do EC2 para o algoritmo de aprendizagem linear
O algoritmo linear do aluno é compatível com instâncias de CPU e GPU para treinamento e inferência. Para GPU, o algoritmo de aprendizagem linear é compatível com as famílias de GPU P2, P3, G4dn e G5.
Durante os testes, não encontramos evidências substanciais de que instâncias com várias GPUs sejam mais rápidos que as instâncias com uma única GPU. Os resultados podem variar dependendo do seu caso de uso específico.
## Cadernos de amostra para aprendizagem linear
A tabela a seguir descreve uma variedade de exemplos de cadernos que abordam diferentes casos de uso do algoritmo de aprendizado linear de SageMaker IA da Amazon.
| **Título do caderno** | **Descrição** |
| --- | --- |
| [Uma introdução ao conjunto de dados MNIST](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/linear_learner_mnist/linear_learner_mnist.html) | Usando o conjunto de dados MNIST, treinamos um classificador binário para prever um único dígito. |
| [Como construir um classificador multiclasse?](https://sagemaker-examples.readthedocs.io/en/latest/scientific_details_of_algorithms/linear_learner_multiclass_classification/linear_learner_multiclass_classification.html) | Usando o conjunto de dados Covertype da UCI, demonstramos como treinar um classificador multiclasse. |
| [Como criar um pipeline de Machine Learning (ML) para inferência?](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-python-sdk/scikit_learn_inference_pipeline/Inference%20Pipeline%20with%20Scikit-learn%20and%20Linear%20Learner.html) | Usando um contêiner Scikit-learn, demonstramos como criar um end-to-end pipeline de ML. |
Para obter instruções sobre como criar e acessar instâncias do notebook Jupyter que você pode usar para executar o exemplo em SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md) Depois de criar uma instância do notebook e abri-la, escolha a guia **Exemplos de SageMaker IA** para ver uma lista de todas as amostras de SageMaker IA. Os cadernos de exemplo de modelagem de tópicos que usam os algoritmos de aprendizado linear estão localizados na seção **Introdução a algoritmos da Amazon**. Para abrir um caderno, escolha a guia **Uso** e depois escolha **Criar cópia**.
# Como a aprendizagem linear funciona
Há três etapas envolvidas na implementação do algoritmo de aprendizagem linear: pré-processar, treinar e validar.
## Etapa 1: Pré-processar
A normalização, ou o dimensionamento de recursos, é uma etapa de pré-processamento importante para determinadas funções de perda que garante que o modelo que está sendo treinado em um conjunto de dados não se torne dominado pelo peso de um único recurso. O algoritmo Amazon SageMaker AI Linear Learner tem uma opção de normalização para auxiliar nessa etapa de pré-processamento. Se a normalização estiver ativada, o algoritmo primeiro passará por uma pequena amostra dos dados para aprender o valor médio e o desvio padrão para cada recurso e para o rótulo. Cada um dos recursos no conjunto de dados completo é, então, deslocado para ter a média de zero e é dimensionado para ter um desvio padrão de unidade.
**nota**
Para obter melhores resultados, garanta que seus dados sejam embaralhados antes do treinamento. O treinamento com dados não embaralhados pode apresentar falha.
É possível configurar se o algoritmo de aprendizagem linear normaliza os dados do recurso e os rótulos usando os hiperparâmetros `normalize_data` e `normalize_label`, respectivamente. A normalização é habilitada por padrão para recursos e rótulos para regressão. Somente os recursos podem ser normalizados para classificação binária e esse é o comportamento padrão.
## Etapa 2: Treinar
Com o algoritmo de aprendizagem linear, você treina com uma implementação distribuída de descida de gradiente estocástica (SGD). É possível controlar o processo de otimização escolhendo o algoritmo de otimização. Por exemplo, você pode optar por usar Adam AdaGrad, gradiente descendente estocástico ou outros algoritmos de otimização. Você também especifica seus hiperparâmetros, como dinâmica, taxa de aprendizagem e programação de taxa de aprendizagem. Se não tiver certeza de qual algoritmo ou valor de hiperparâmetro usar, escolha um padrão que funcione para a maioria dos conjuntos de dados.
Durante o treinamento, otimize simultaneamente vários modelos, cada um com os objetivos levemente diferentes. Por exemplo, é possível variar a regularização L1 ou L2 e testar diferentes configurações de otimizador.
## Etapa 3: Validar e definir o limite
Ao treinar vários modelos em paralelo, os modelos serão avaliados com relação a um conjunto de validações para selecionar o melhor modelo após a conclusão do treinamento. Para regressão, o melhor modelo é aquele que atinge a melhor perda no conjunto de validações. Para classificação, uma amostra do conjunto de validações é usada para calibrar o limite de classificação. O melhor modelo selecionado é aquele que atende aos melhores critérios da seleção de classificação binária no conjunto de validações. Exemplos desses critérios incluem a medida F1, a acurácia e a perda de entropia cruzada.
**nota**
Se o algoritmo não receber um conjunto de validações, não será possível avaliar e selecionar o melhor modelo. Para aproveitar o treinamento paralelo e a seleção de modelos, forneça um conjunto de validações ao algoritmo.
# Hiperparâmetros da aprendizagem linear
A tabela a seguir contém os hiperparâmetros para o algoritmo de aprendizagem linear. Esses parâmetros são definidos pelos usuários para facilitar a estimativa dos parâmetros do modelo a partir dos dados. Os hiperparâmetros necessários que devem ser definidos são listados primeiro, em ordem alfabética. Os hiperparâmetros opcionais que podem ser configurados são listados em seguida, também em ordem alfabética. Quando um hiperparâmetro é definido como`auto`, a Amazon SageMaker AI calcula e define automaticamente o valor desse hiperparâmetro.
| Nome do parâmetro | Description |
| --- | --- |
| num\$1classes | O número de classes para a variável de resposta. O algoritmo assume que as classes estejam rotuladas como `0`, ..., `num_classes - 1`. **Obrigatório** quando `predictor_type` é `multiclass_classifier`. Caso contrário, o algoritmo o ignorará. Valores válidos: números inteiros de 3 a 1.000.000 |
| predictor\$1type | Especifica o tipo de variável de destino como uma classificação binária, classificação multiclasse ou regressão. **Obrigatório** Valores válidos: `binary_classifier`, `multiclass_classifier` ou `regressor` |
| accuracy\$1top\$1k | Ao calcular a métrica de precisão top-k para classificação multiclasse, o valor de *k*. Se o modelo atribuir uma das pontuações top-k ao rótulo true, um exemplo será pontuado como correto. **Opcional** Valores válidos: números inteiros positivos Valor padrão: 3 |
| balance\$1multiclass\$1weights | Especifica se pesos de classe devem ser usados, que dão a cada classe uma importância igual na função de perda. Usado somente quando `predictor_type` é `multiclass_classifier`. **Opcional** Valores válidos: `true`, `false` Valor padrão: `false` |
| beta\$11 | A taxa de degradação exponencial para estimativas de primeiro momento. Aplica-se apenas quando o valor `optimizer` é `adam`. **Opcional** Valores válidos: `auto` ou um valor de ponto flutuante entre 0 e 1,0 Valor padrão: `auto` |
| beta\$12 | A taxa de degradação exponencial para estimativas de segundo momento. Aplica-se apenas quando o valor `optimizer` é `adam`. **Opcional** Valores válidos: `auto` ou um número inteiro de ponto flutuante entre 0 e 1,0 Valor padrão: `auto` |
| bias\$1lr\$1mult | Permite uma taxa de aprendizagem diferente para o termo de desvio. A taxa real de aprendizagem para a polarização é `learning_rate` \$1 `bias_lr_mult`. **Opcional** Valores válidos: `auto` ou um número inteiro positivo de ponto flutuante Valor padrão: `auto` |
| bias\$1wd\$1mult | Permite regularização diferente para o termo de desvio. O peso da regularização L2 real para a polarização é `wd` \$1 `bias_wd_mult`. Por padrão, não há regularização no termo de polarização. **Opcional** Valores válidos: `auto` ou um número inteiro não negativo de ponto flutuante Valor padrão: `auto` |
| binary\$1classifier\$1model\$1selection\$1criteria | Quando `predictor_type` está definido como `binary_classifier`, o critério de avaliação do modelo para o conjunto de dados de validação (ou para o conjunto de dados de treinamento, se você não fornecer um conjunto de dados de validação). Os critérios incluem: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/ll_hyperparameters.html) **Opcional** Valores válidos: `accuracy`, `f_beta`, `precision_at_target_recall`, `recall_at_target_precision` ou `loss_function` Valor padrão: `accuracy` |
| early\$1stopping\$1patience | Se nenhuma melhoria for feita na métrica relevante, o número de epochs a aguardar antes de terminar o treinamento. Se você forneceu um valor para binary\$1classifier\$1model\$1selection\$1criteria, a métrica é esse valor. Caso contrário, a métrica é igual ao valor especificado para o hiperparâmetro loss. A métrica é avaliada nos dados de validação. Se você não forneceu dados de validação, a métrica é sempre o mesmo que o valor especificado para o hiperparâmetro `loss` e é avaliada nos dados de treinamento. Para desabilitar a interrupção precoce, defina `early_stopping_patience` como um valor maior que o valor especificado para `epochs`.**Opcional**Valores válidos: inteiro positivoValor padrão: 3 |
| early\$1stopping\$1tolerance | A tolerância relativa para medir uma melhoria na perda. Se a proporção for menor que esse valor (em relação à melhora na perda quando dividida pela melhor perda anterior), a interrupção precoce considerará que não houve melhora. **Opcional** Valores válidos: número inteiro positivo de ponto flutuante Valor padrão: 0.001 |
| epochs | O número máximo de passagens nos dados de treinamento. **Opcional** Valores válidos: inteiro positivo Valor padrão: 15 |
| f\$1beta | O valor do beta a ser usado ao calcular métricas de pontuação F para classificação binária ou de várias classes. Também usado se o valor especificado para `binary_classifier_model_selection_criteria` for `f_beta`. **Opcional** Valores válidos: números inteiros positivos de ponto flutuante Valor padrão: 1.0 |
| feature\$1dim | O número de atributos nos dados de entrada. **Opcional** Valores válidos: `auto` ou um número inteiro positivo Valores padrão: `auto` |
| huber\$1delta | O parâmetro para a perda de Huber. Durante o treinamento e a avaliação da métrica, calcula a perda L2 para erros menores do que delta, bem como a perda L1 para erros maiores do que delta. **Opcional** Valores válidos: número inteiro positivo de ponto flutuante Valor padrão: 1.0 |
| init\$1bias | Peso inicial para o termo de polarização. **Opcional** Valores válidos: número inteiro de ponto flutuante Valor padrão: 0 |
| init\$1method | Define a função de distribuição inicial usada para pesos de modelo. As funções incluem: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/ll_hyperparameters.html) **Opcional** Valores válidos: `uniform` ou `normal` Valor padrão: `uniform` |
| init\$1scale | Dimensiona uma distribuição uniforme inicial para pesos de modelo. Aplicável apenas quando o hiperparâmetro `init_method` está definido como `uniform`. **Opcional** Valores válidos: número inteiro positivo de ponto flutuante Valor padrão: 0.07 |
| init\$1sigma | O desvio padrão inicial para a distribuição normal. Aplicável apenas quando o hiperparâmetro `init_method` está definido como `normal`. **Opcional** Valores válidos: número inteiro positivo de ponto flutuante Valor padrão: 0,01 |
| l1 | O parâmetro de regularização L1. Se você não quiser usar a regularização L1, defina o valor como 0. **Opcional** Valores válidos: `auto` ou flutuante não negativo Valor padrão: `auto` |
| learning\$1rate | O tamanho da etapa usado pelo otimizador para atualizações de parâmetros. **Opcional** Valores válidos: `auto` ou um número inteiro positivo de ponto flutuante Valor padrão: `auto`, cujo valor depende do otimizador escolhido. |
| loss | Especifica a função de perda. As funções de perda disponíveis e seus valores padrão dependem do valor de `predictor_type`: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/ll_hyperparameters.html) Valores válidos: `auto`, `logistic`, `squared_loss`, `absolute_loss`, `hinge_loss`, `eps_insensitive_squared_loss`, `eps_insensitive_absolute_loss`, `quantile_loss` ou `huber_loss` **Opcional** Valor padrão: `auto` |
| loss\$1insensitivity | O parâmetro para o tipo de perda insensível a épsilon. Durante o treinamento e a avaliação da métrica, qualquer erro menor do que esse valor será considerado zero. **Opcional** Valores válidos: número inteiro positivo de ponto flutuante Valor padrão: 0,01 |
| lr\$1scheduler\$1factor | Para cada hiperparâmetro `lr_scheduler_step`, a taxa de aprendizagem é diminuída por essa quantidade. Aplicável apenas quando o hiperparâmetro `use_lr_scheduler` está definido como `true`. **Opcional** Valores válidos: `auto` ou um número inteiro positivo de ponto flutuante entre 0 e 1 Valor padrão: `auto` |
| lr\$1scheduler\$1minimum\$1lr | A taxa de aprendizagem nunca diminui para um valor menor que o valor definido para `lr_scheduler_minimum_lr`. Aplicável apenas quando o hiperparâmetro `use_lr_scheduler` está definido como `true`. **Opcional** Valores válidos: `auto` ou um número inteiro positivo de ponto flutuante Valores padrão: `auto` |
| lr\$1scheduler\$1step | O número de passos entre as diminuições da taxa de aprendizagem. Aplicável apenas quando o hiperparâmetro `use_lr_scheduler` está definido como `true`. **Opcional** Valores válidos: `auto` ou um número inteiro positivo Valor padrão: `auto` |
| margin | A margem para a função `hinge_loss`. **Opcional** Valores válidos: número inteiro positivo de ponto flutuante Valor padrão: 1.0 |
| mini\$1batch\$1size | O número de observações por minilote para o iterador de dados. **Opcional** Valores válidos: inteiro positivo Valor padrão: 1000 |
| momentum | A dinâmica do otimizador `sgd`. **Opcional** Valores válidos: `auto` ou um número inteiro de ponto flutuante entre 0 e 1,0 Valor padrão: `auto` |
| normalize\$1data | Normaliza os dados do recurso antes do treinamento. A normalização de dados desloca os dados de cada recurso para ter uma média de zero e os dimensiona para ter um desvio padrão de unidade. **Opcional** Valores válidos: `auto`, `true` ou `false` Valor padrão: `true` |
| normalize\$1label | Normaliza o rótulo. A normalização de rótulos desloca o rótulo para ter uma média de zero e o dimensiona para ter um desvio padrão de unidade. O valor `auto` padrão normaliza o rótulo para problemas de regressão, mas não para problemas de classificação. Se você definir o hiperparâmetro `normalize_label` como `true` para problemas de classificação, o algoritmo o ignorará. **Opcional** Valores válidos: `auto`, `true` ou `false` Valor padrão: `auto` |
| num\$1calibration\$1samples | O número de observações do conjunto de dados de validação a ser usado para calibração do modelo (ao encontrar o melhor limite). **Opcional** Valores válidos: `auto` ou um número inteiro positivo Valor padrão: `auto` |
| num\$1models | O número de modelos para treinar em paralelo. Para o padrão, `auto`, o algoritmo decide o número de modelos paralelos a ser treinado. Um modelo é treinado de acordo com o parâmetro de treinamento indicado (regularização, otimizador e perda), e o restante, por parâmetros aproximados. **Opcional** Valores válidos: `auto` ou um número inteiro positivo Valores padrão: `auto` |
| num\$1point\$1for\$1scaler | O número de pontos de dados a serem usados para calcular a normalização ou a imparcialidade de termos. **Opcional** Valores válidos: inteiro positivo Valor padrão: 10,000 |
| optimizer | O algoritmo de otimização a ser usado. **Opcional** Valores válidos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/ll_hyperparameters.html) Valor padrão: `auto`. A configuração padrão para `auto` é `adam`. |
| positive\$1example\$1weight\$1mult | O peso atribuído a exemplos positivos ao treinar um classificador binário. O peso de exemplos negativos é fixado em 1. Se quiser que o algoritmo escolha um peso, de forma que os erros na classificação de exemplos negativos *vs.* positivos tenham impacto igual na perda de treinamento, especifique `balanced`. Se quiser que o algoritmo escolha o peso que otimiza o desempenho, especifique `auto`. **Opcional** Valores válidos: `balanced`, `auto` ou um número inteiro positivo de ponto flutuante Valor padrão: 1.0 |
| quantile | O quantil para perda de quantil. Para o quantil q, o modelo tenta produzir previsões de modo que o valor de `true_label` seja maior que a previsão com probabilidade q. **Opcional** Valores válidos: Número inteiro de ponto flutuante entre 0 e 1 Valor padrão: 0.5 |
| target\$1precision | A precisão de destino. Se `binary_classifier_model_selection_criteria` for `recall_at_target_precision`, a precisão será mantida nesse valor enquanto o recall for maximizada. **Opcional** Valores válidos: Número inteiro de ponto flutuante entre 0 e 1,0 Valor padrão: 0.8 |
| target\$1recall | O recall de destino. Se `binary_classifier_model_selection_criteria` for `precision_at_target_recall` , o recall será mantido nesse valor enquanto a precisão estiver maximizada. **Opcional** Valores válidos: Número inteiro de ponto flutuante entre 0 e 1,0 Valor padrão: 0.8 |
| unbias\$1data | Imparcializa os recursos antes do treinamento para que a média seja 0. Por padrão, os dados são imparciais quando o hiperparâmetro `use_bias` está definido como `true`. **Opcional** Valores válidos: `auto`, `true` ou `false` Valor padrão: `auto` |
| unbias\$1label | Imparcializa os rótulos antes do treinamento para que a média seja 0. Aplica-se à regressão somente se o hiperparâmetro `use_bias` estiver definido como `true`. **Opcional** Valores válidos: `auto`, `true` ou `false` Valor padrão: `auto` |
| use\$1bias | Especifica se o modelo deve incluir um termo de polarização, que é o termo de interceptação na equação linear. **Opcional** Valores válidos: `true` ou `false` Valor padrão: `true` |
| use\$1lr\$1scheduler | Se um programador deve ou não ser usado para a taxa de aprendizagem. Se quiser usar um agendador, especifique `true`. **Opcional** Valores válidos: `true` ou `false` Valor padrão: `true` |
| wd | O parâmetro de degradação de peso, também conhecido como o parâmetro de regularização L2. Se você não quiser usar a regularização L2, defina o valor como 0. **Opcional** Valores válidos: `auto` ou um número inteiro não negativo de ponto flutuante Valor padrão: `auto` |
# Ajustar um modelo de aprendizagem linear
O *ajuste automático de modelos*, também conhecido como ajuste de hiperparâmetros, localiza a melhor versão de um modelo executando vários trabalhos que testam uma série de hiperparâmetros no seu conjunto de dados. Você escolhe os hiperparâmetros ajustáveis, um intervalo de valores para cada um e uma métrica objetiva. Você escolhe a métrica objetiva entre as métricas que o algoritmo calcula. O ajuste de modelo automático pesquisa os hiperparâmetros escolhidos para encontrar a combinação de valores que resultam no modelo que otimiza a métrica objetiva.
O algoritmo de Aprendizagem linear também tem um mecanismo interno para ajuste de hiperparâmetros separados do recurso de ajuste de modelo automático descrito aqui. Por padrão, o algoritmo de Aprendizagem linear ajusta os hiperparâmetros treinando vários modelos em paralelo. Quando você usa o ajuste automático de modelo, o mecanismo de ajuste interno de Aprendizagem linear é desativado automaticamente. Isso define o número de modelos paralelos, `num_models`, como 1. O algoritmo ignora qualquer valor que você tenha definido para `num_models`.
Para mais informações sobre o ajuste de modelos, consulte [Ajuste automático do modelo com SageMaker IA](automatic-model-tuning.md).
## Métricas calculadas pelo algoritmo de aprendizagem linear
O algoritmo de aprendizagem linear relata as métricas na tabela a seguir, que são calculadas durante o treinamento. Escolha uma deles como a métrica objetiva. Para evitar o sobreajuste, recomendamos ajustar o modelo em uma métrica de validação em vez de em uma métrica de treinamento.
| Nome da métrica | Description | Direção de otimização |
| --- | --- | --- |
| test:absolute\$1loss | A perda absoluta do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para regressão. | Minimizar |
| test:binary\$1classification\$1accuracy | A precisão do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| test:binary\$1f\$1beta | A pontuação F-beta do modelo final no conjunto de dados de teste. Por padrão, é a pontuação F1, que é a média harmônica de precisão e recall. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| test:dcg | O ganho cumulativo descontado do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| test:macro\$1f\$1beta | A pontuação F-beta do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| test:macro\$1precision | A pontuação da precisão do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| test:macro\$1recall | A pontuação do recall do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| test:mse | O erro quadrático médio do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para regressão. | Minimizar |
| test:multiclass\$1accuracy | A precisão do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| test:multiclass\$1top\$1k\$1accuracy | A precisão entre os k principais rótulos previstos no conjunto de dados de teste. Se você escolher essa métrica como objetivo, recomendamos definir o valor de k usando o hiperparâmetro `accuracy_top_k`. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| test:objective\$1loss | O valor médio da função de perda de objetivo no conjunto de dados de teste após o modelo ser treinado. Por padrão, a perda é a perda logística para classificação binária e a perda quadrada para regressão. Para definir a perda como outros tipos, use o hiperparâmetro `loss`. | Minimizar |
| test:precision | A precisão do modelo final no conjunto de dados de teste. Se você escolher essa métrica como objetivo, recomendamos configurar um recall de destino definindo o hiperparâmetro `binary_classifier_model_selection` como `precision_at_target_recall` e definindo o valor do hiperparâmetro `target_recall`. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| test:recall | O recall do modelo final no conjunto de dados de teste. Se você escolher essa métrica como objetivo, recomendamos configurar uma precisão de destino definindo o hiperparâmetro `binary_classifier_model_selection` como `recall_at_target_precision` e definindo o valor do hiperparâmetro `target_precision`. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| test:roc\$1auc\$1score | A área sob a curva característica operacional receptora (curva ROC) do modelo final no conjunto de dados de teste. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| validation:absolute\$1loss | A perda absoluta do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para regressão. | Minimizar |
| validation:binary\$1classification\$1accuracy | A precisão do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| validation:binary\$1f\$1beta | A pontuação F-beta do modelo final no conjunto de dados de validação. Por padrão, a pontuação F-beta é a pontuação F1, que é a média harmônica das métricas `validation:precision` e `validation:recall`. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| validation:dcg | O ganho cumulativo descontado do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| validation:macro\$1f\$1beta | A pontuação F-beta do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| validation:macro\$1precision | A pontuação de precisão do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| validation:macro\$1recall | A pontuação do recall do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| validation:mse | O erro quadrático médio do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para regressão. | Minimizar |
| validation:multiclass\$1accuracy | A precisão do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| validation:multiclass\$1top\$1k\$1accuracy | A precisão entre os k principais rótulos previstos no conjunto de dados de validação. Se você escolher essa métrica como objetivo, recomendamos definir o valor de k usando o hiperparâmetro `accuracy_top_k`. Essa métrica objetiva só é válida para classificação multiclasse. | Maximizar |
| validation:objective\$1loss | O valor médio da função de perda de objetivo no conjunto de dados de validação a cada epoch. Por padrão, a perda é a perda logística para classificação binária e a perda quadrada para regressão. Para definir a perda como outros tipos, use o hiperparâmetro `loss`. | Minimizar |
| validation:precision | A precisão do modelo final no conjunto de dados de validação. Se você escolher essa métrica como objetivo, recomendamos configurar um recall de destino definindo o hiperparâmetro `binary_classifier_model_selection` como `precision_at_target_recall` e definindo o valor do hiperparâmetro `target_recall`. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| validation:recall | O recall do modelo final no conjunto de dados de validação. Se você escolher essa métrica como objetivo, recomendamos configurar uma precisão de destino definindo o hiperparâmetro `binary_classifier_model_selection` como `recall_at_target_precision` e definindo o valor do hiperparâmetro `target_precision`. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
| validation:rmse | A raiz do erro quadrático médio do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para regressão. | Minimizar |
| validation:roc\$1auc\$1score | A área sob a curva característica de operação receptora (curva ROC) do modelo final no conjunto de dados de validação. Essa métrica objetiva só é válida para classificação binária. | Maximizar |
## Ajuste de hiperparâmetros da aprendizagem linear
Você pode ajustar um modelo de aprendizagem linear com os seguintes hiperparâmetros.
| Nome do parâmetro | Tipo de parâmetro | Intervalos recomendados |
| --- | --- | --- |
| wd | `ContinuousParameterRanges` | `MinValue: ``1e-7`, `MaxValue`: `1` |
| l1 | `ContinuousParameterRanges` | `MinValue`: `1e-7`, `MaxValue`: `1` |
| learning\$1rate | `ContinuousParameterRanges` | `MinValue`: `1e-5`, `MaxValue`: `1` |
| mini\$1batch\$1size | `IntegerParameterRanges` | `MinValue`: `100`, `MaxValue`: `5000` |
| use\$1bias | `CategoricalParameterRanges` | `[True, False]` |
| positive\$1example\$1weight\$1mult | `ContinuousParameterRanges` | `MinValue`: 1e-5, `MaxValue`: `1e5` |
# Formatos de resposta da aprendizagem linear
## Formatos de resposta JSON
Todos os algoritmos integrados do Amazon SageMaker AI aderem ao formato comum de inferência de entrada descrito em [Formatos de dados comuns - Inferência](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html). A seguir estão os formatos de saída disponíveis para o algoritmo de aprendizado linear de SageMaker IA.
**Classificação binária**
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
**Classificação multiclasse**
```
let response = {
"predictions": [
{
"score": [0.1, 0.2, 0.4, 0.3],
"predicted_label": 2
}
]
}
```
**Regressão**
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## Formatos de resposta JSONLINES
**Classificação binária**
```
{"score": 0.4, "predicted_label": 0}
```
**Classificação multiclasse**
```
{"score": [0.1, 0.2, 0.4, 0.3], "predicted_label": 2}
```
**Regressão**
```
{"score": 0.4}
```
## Formatos de resposta RECORDIO
**Classificação binária**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
**Classificação multiclasse**
```
[
Record = {
"features": [],
"label": {
"score": {
"values": [0.1, 0.2, 0.3, 0.4]
},
"predicted_label": {
"values": [3]
}
},
"uid": "abc123",
"metadata": "{created_at: '2017-06-03'}"
}
]
```
**Regressão**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
}
}
}
]
```