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 k-nearest neighbors (k-NN) O algoritmo de k-Nearest Neighbors (k-NN) da Amazon SageMaker AI é um algoritmo baseado em índices. Ele usa um método não paramétrico para classificação ou regressão. Para problemas de classificação, o algoritmo consulta os *k* pontos que estão mais próximos do ponto de amostragem e retorna o rótulo mais utilizado da sua classe como o rótulo previsto. Para problemas de regressão, o algoritmo consulta os *k* pontos mais próximos do ponto de amostragem e retorna a média de seus valores de atributos como o valor previsto. O treinamento com o algoritmo k-NN possui três etapas: amostragem, redução de dimensão e criação do índice. A amostragem reduz o tamanho do conjunto de dados inicial para que ele caiba na memória. Para a redução da dimensão, o algoritmo diminui a dimensão do atributo dos dados para reduzir a área de ocupação do modelo k-NN na latência de memória e da inferência. Fornecemos dois métodos de redução da dimensão: a projeção aleatória e a transformação rápida de Johnson-Lindenstrauss. Normalmente, você usa a redução de dimensão para conjuntos de dados altamente dimensionais (d > 1000) para evitar a "maldição da dimensionalidade" que perturba as análises estatísticas de dados que se tornam esparsos à medida que a dimensionalidade aumenta. O principal objetivo do treinamento do k-NN é construir o índice. Esse índice permite pesquisas eficientes de distâncias entre pontos cujos valores ou rótulos de classe ainda não foram determinados e dos k pontos mais próximos a serem usados para inferência. **Topics** + [Interface de entrada/saída para o algoritmo k-NN](#kNN-input_output) + [Cadernos k-NN de exemplo](#kNN-sample-notebooks) + [Como funciona o algoritmo k-NN](kNN_how-it-works.md) + [Recomendação de instância do EC2 para o algoritmo k-NN](#kNN-instances) + [Hiperparâmetros de k-NN](kNN_hyperparameters.md) + [Ajustar um modelo k-NN](kNN-tuning.md) + [Formatos de dados para entrada de treinamento de k-NN](kNN-in-formats.md) + [Formatos de resposta e solicitação para k-NN](kNN-inference-formats.md) ## Interface de entrada/saída para o algoritmo k-NN SageMaker O AI k-NN suporta canais de dados de treinamento e teste. + Use um *canal de treinamento* para os dados que você deseja amostrar e construir no índice k-NN. + Use um *canal de teste* para emitir pontuações em arquivos de log. Essas pontuações são listadas com uma linha por minilote: precisão para `classifier`, erro quadrático médio (mse) para `regressor` da pontuação. Para entradas de treinamento, k-NN oferece apoio aos formatos de dados `text/csv` e `application/x-recordio-protobuf`. Para o tipo de entrada `text/csv`, as primeiras `label_size` colunas são interpretadas como o vetor de rótulo dessa linha. É possível usar o modo de Arquivo ou de Pipe para treinar modelos em dados formatados como `recordIO-wrapped-protobuf` ou `CSV`. Para entradas de inferência, k-NN oferece apoio aos formatos de dados `application/json`, `application/x-recordio-protobuf` e `text/csv`. O formato `text/csv` aceita um `label_size` e um parâmetro de codificação. Ele assume um `label_size` de 0 e uma codificação UTF-8. Para saídas de inferência, k-NN oferece apoio aos formatos de dados `application/json` e `application/x-recordio-protobuf`. Esses dois formatos de dados também oferecem apoio a um modo de saída detalhado. No modo de saída detalhada, a API fornece aos resultados da pesquisa o vetor de distâncias, classificadas da menor para a maior, bem como os elementos correspondentes no vetor de rótulos. Para transformação em lote, o k-NN oferece apoio ao formato de dados `application/jsonlines` para a entrada e a saída. Veja a seguir um exemplo de entrada: ``` content-type: application/jsonlines {"features": [1.5, 16.0, 14.0, 23.0]} {"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}} ``` Veja a seguir um exemplo de saída: ``` accept: application/jsonlines {"predicted_label": 0.0} {"predicted_label": 2.0} ``` Para obter mais informações sobre formatos de arquivo de entrada e saída, consulte [Formatos de dados para entrada de treinamento de k-NN](kNN-in-formats.md) para treinamento, [Formatos de resposta e solicitação para k-NN](kNN-inference-formats.md) para inferência e os [Cadernos k-NN de exemplo](#kNN-sample-notebooks). ## Cadernos k-NN de exemplo [Para ver um exemplo de caderno que usa o algoritmo SageMaker AI k-Nearest Neighbor para prever tipos de cobertura selvagem a partir de dados geológicos e de serviços florestais, consulte o K-Nearest Neighbor Covertype.](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/k_nearest_neighbors_covtype/k_nearest_neighbors_covtype.html) Use uma instância do notebook Jupyter para executar o exemplo em SageMaker IA. Para saber como criar e abrir uma instância do notebook Jupyter na SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md) Depois de criar uma instância de notebook e abri-la, selecione a guia **Exemplos de SageMaker IA** para ver uma lista de todos os cadernos de exemplo de SageMaker IA. Encontre cadernos do K-Nearest Neighbor na seção **Introdução aos algoritmos do Amazon**. Para abrir um caderno, clique em sua guia **Uso** e selecione **Criar cópia**. # Como funciona o algoritmo k-NN O algoritmo de k-Nearest Neighbors (k-NN) da Amazon SageMaker AI segue um processo de treinamento de várias etapas que inclui a amostragem dos dados de entrada, a redução da dimensão e a criação de um índice. Os dados indexados são em seguida usados durante a inferência para encontrar com eficiência os k-nearest neighbors de um determinado ponto de dados e fazer predições com base nos rótulos ou valores vizinhos. ## Etapa 1: Amostra Para especificar o número total de pontos de dados dos quais obter uma amostra com base no conjunto de dados de treinamento, use o parâmetro `sample_size`. Por exemplo, se o conjunto de dados inicial tivesse 1.000 pontos de dados e `sample_size` estivesse definido como 100, em que o número total de instâncias é 2, cada operador obteria a amostra de 50 pontos. Um conjunto total de 100 pontos de dados seria coletado. A amostragem é executada em tempo linear em relação ao número de pontos de dados. ## Etapa 2: Executar a redução da dimensão A implementação atual do algoritmo k-NN tem dois métodos de redução de dimensão. Você especifica o método no hiperparâmetro `dimension_reduction_type`. O método `sign` especifica uma projeção aleatória, que usa uma projeção linear com uma matriz de sinais aleatórios, enquanto o método `fjlt` especifica uma transformação rápida de Johnson-Lindenstrauss, um método baseado na transformação de Fourier. Ambos os métodos preservam as distâncias L2 e interna do produto. O método `fjlt` deve ser usado quando a dimensão de destino é grande e tem melhor desempenho com inferência de CPU. Os métodos diferem em sua complexidade computacional. O método `sign` requer um tempo de O(ndk) para reduzir a dimensão de um lote de n pontos de dimensão d para uma dimensão de destino k. O método `fjlt` requer um tempo de O(nd log(d)), mas as constantes envolvidas são maiores. O uso da redução de dimensão introduz ruído nos dados, e esse ruído pode reduzir a precisão da predição. ## Etapa 3: Construir um índice Durante a inferência, o algoritmo consulta o índice de um ponto k-nearest-neighbors de amostra. Com base nas referências aos pontos, o algoritmo faz a predição de classificação ou regressão. Ele faz a predição com base nos rótulos de classe ou nos valores fornecidos. O algoritmo k-NN fornece três tipos diferentes de índices: um índice fixo, um índice invertido e um índice invertido com quantização de produto. Você especifica o tipo com o parâmetro `index_type`. ## Serializar o modelo Quando o algoritmo k-NN termina o treinamento, ele serializa três arquivos para preparar a inferência. + model\$1algo-1: contém o índice serializado para calcular os vizinhos mais próximos. + model\$1algo-1.labels: contém rótulos serializados (formato binário np.float32) para calcular o rótulo previsto com base no resultado da consulta do índice. + model\$1algo-1.json: Contém os metadados do modelo em formato JSON que armazena os hiperparâmetros `k` e `predictor_type` do treinamento para inferência junto com outros estados relevantes. Com a implementação atual do k-NN, você pode modificar o arquivo de metadados para alterar a maneira como as predições são calculadas. Por exemplo, você pode alterar `k` para 10 ou alterar `predictor_type` para *regressor*. ``` { "k": 5, "predictor_type": "classifier", "dimension_reduction": {"type": "sign", "seed": 3, "target_dim": 10, "input_dim": 20}, "normalize": False, "version": "1.0" } ``` ## Recomendação de instância do EC2 para o algoritmo k-NN Recomendamos treinar em uma instância de CPU (como ml.m5.2xlarge) ou em uma instância de GPU. O algoritmo k-NN oferece apoio às famílias de instâncias de GPU P2, P3, G4dn e G5 para treinamento e inferência. As solicitações de inferência CPUs geralmente têm uma latência média menor do que as solicitações de GPUs porque há uma sobrecarga na CPU-to-GPU comunicação quando você usa hardware de GPU. No entanto, GPUs geralmente têm maior produtividade para lotes maiores. # Hiperparâmetros de k-NN A tabela a seguir lista os hiperparâmetros que você pode definir para o algoritmo de k-vizinhos mais próximos (k-NN) da Amazon SageMaker AI. | Nome do parâmetro | Description | | --- | --- | | feature\$1dim | O número de atributos nos dados de entrada. **Obrigatório** Valores válidos: inteiro positivo. | | k | O número de vizinhos mais próximos. **Obrigatório** Valores válidos: inteiro positivo | | predictor\$1type | O tipo de inferência a ser usada nos rótulos de dados. **Obrigatório** Valores válidos: *classificador* para classificação ou *regressor* para regressão. | | sample\$1size | O número de pontos de dados dos quais obter uma amostra no conjunto de dados de treinamento. **Obrigatório** Valores válidos: inteiro positivo | | dimension\$1reduction\$1target | A dimensão de destino para a qual reduzir. **Obrigatório** quando você especifica o parâmetro `dimension_reduction_type`. Valores válidos: inteiro positivo maior que 0 e menor que `feature_dim`. | | dimension\$1reduction\$1type | O tipo de método de redução da dimensão. **Opcional** Valores válidos: *sign* para projeção aleatória ou *fjlt* para a transformação rápida de Johnson-Lindenstrauss. Valor padrão: Nenhuma redução da dimensão | | faiss\$1index\$1ivf\$1nlists | *O número de centróides a serem construídos no índice quando `index_type` é faiss. IVFFlat*ou *FAISS.ivfpq*. **Opcional** Valores válidos: inteiro positivo Valor padrão: *auto*, que é resolvido como `sqrt(sample_size)`. | | faiss\$1index\$1pq\$1m | O número de subcomponentes vetoriais a serem construídos no índice quando `index_type` está definido como *faiss.IVFPQ*. A biblioteca FaceBook AI Similarity Search (FAISS) exige que o valor de `faiss_index_pq_m` seja um divisor da dimensão dos dados. Se `faiss_index_pq_m` não for um divisor da dimensão de dados, aumentaremos a dimensão de dados para o menor número inteiro divisível por `faiss_index_pq_m`. Se nenhuma redução de dimensão for aplicada, o algoritmo adicionará um preenchimento de zeros. Se a redução de dimensão for aplicada, o algoritmo aumentará o valor do hiperparâmetro `dimension_reduction_target`. **Opcional** Valores válidos: Um dos seguintes números inteiros positivos: 1, 2, 3, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 96 | | index\$1metric | A métrica para medir a distância entre os pontos ao encontrar os vizinhos mais próximos. Ao treinar com `index_type` definido como `faiss.IVFPQ`, a distância `INNER_PRODUCT` e a similaridade `COSINE` não são compatíveis. **Opcional** Valores válidos: *L2* para distância euclidiana, *INNER\$1PRODUCT* para distância interna do produto, *COSINE* para similaridade de cosseno. Valor padrão: *L2* | | index\$1type | O tipo de índice. **Opcional** *Valores válidos: *FAISS.flat*, faiss. IVFFlat*, *FAISS. IVFPq*. Valores padrão: *faiss.Flat* | | 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: 5000 | # Ajustar um modelo k-NN O algoritmo de k-vizinhos mais próximos da Amazon SageMaker AI é um algoritmo supervisionado. O algoritmo consome um conjunto de dados de teste e emite uma métrica sobre a precisão para uma tarefa de classificação ou sobre o erro quadrático médio para uma tarefa de regressão. Essas métricas de precisão comparam as predições de modelo de suas respectivas tarefas com a verdade básica fornecida pelos dados de teste empíricos. Para encontrar o melhor modelo que reporta a maior precisão ou o menor erro no conjunto de dados de teste, execute um trabalho de ajuste de hiperparâmetros para k-NN. 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 adequada para a tarefa de predição do algoritmo. 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. Os hiperparâmetros são usados apenas para ajudar a estimar os parâmetros do modelo e não são usados pelo modelo treinado para fazer predições. 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 k-NN O algoritmo k-nearest neighbors computa uma das duas métricas na tabela a seguir durante o treinamento, dependendo do tipo de tarefa especificado pelo hiperparâmetro `predictor_type`. + *classificador* especifica uma tarefa de classificação e computa `test:accuracy` + *regressor* especifica uma tarefa de regressão e computa `test:mse`. Escolha o valor `predictor_type` apropriado para o tipo de tarefa realizada para calcular a métrica objetiva relevante ao ajustar um modelo. | Nome da métrica | Description | Direção de otimização | | --- | --- | --- | | test:accuracy | Quando `predictor_type` está definido como *classificador*, k-NN compara o rótulo previsto, com base na média dos rótulos dos k vizinhos mais próximos, com o rótulo de verdade de terreno fornecido nos dados do canal de teste. A precisão relatada varia de 0,0 (0%) a 1,0 (100%). | Maximizar | | test:mse | Quando `predictor_type` está definido como *regressor*, k-NN compara o rótulo previsto, com base na média dos rótulos dos k vizinhos mais próximos, com o rótulo de verdade de terreno fornecido nos dados do canal de teste. O erro quadrático médio é calculado comparando os dois rótulos. | Minimizar | ## Hiperparâmetros ajustáveis de k-NN Ajuste o modelo do vizinho mais próximo do Amazon SageMaker AI com os seguintes hiperparâmetros. | Nome do parâmetro | Tipo de parâmetro | Intervalos recomendados | | --- | --- | --- | | k | IntegerParameterRanges | MinValue: 1, MaxValue 1024 | | sample\$1size | IntegerParameterRanges | MinValue: 256, MaxValue 2000000 | # Formatos de dados para entrada de treinamento de k-NN Todos os algoritmos integrados do Amazon SageMaker AI aderem aos formatos comuns de treinamento de entrada descritos em [Formatos de dados comuns - Treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html). Este tópico contém uma lista dos formatos de entrada disponíveis para o k-nearest-neighbor algoritmo de SageMaker IA. ## Formatos de dados CSV content-type: text/csv; label\$1size=1 ``` 4,1.2,1.3,9.6,20.3 ``` As primeiras colunas `label_size` são interpretadas como o vetor de rótulo para essa linha. ## Formato de dados para RECORDIO tipo de conteúdo: aplicativo/ x-recordio-protobuf ``` [ Record = { features = { 'values': { values: [1.2, 1.3, 9.6, 20.3] # float32 } }, label = { 'values': { values: [4] # float32 } } } ] } ``` # Formatos de resposta e solicitação para k-NN 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). Este tópico contém uma lista dos formatos de saída disponíveis para o k-nearest-neighbor algoritmo de SageMaker IA. ## ENTRADA: Formato da solicitação CSV content-type: text/csv ``` 1.2,1.3,9.6,20.3 ``` Aceita `label_size` ou um parâmetro de codificação. Ele assume um `label_size` de 0 e uma codificação utf-8. ## ENTRADA: Formato de solicitação JSON content-type: application/json ``` { "instances": [ {"data": {"features": {"values": [-3, -1, -4, 2]}}}, {"features": [3.0, 0.1, 0.04, 0.002]}] } ``` ## ENTRADA: Formato de solicitação JSONLINES content-type: application/jsonlines ``` {"features": [1.5, 16.0, 14.0, 23.0]} {"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}} ``` ## ENTRADA: Formato de solicitação RECORDIO tipo de conteúdo: aplicativo/ x-recordio-protobuf ``` [ Record = { features = { 'values': { values: [-3, -1, -4, 2] # float32 } }, label = {} }, Record = { features = { 'values': { values: [3.0, 0.1, 0.04, 0.002] # float32 } }, label = {} }, ] ``` ## SAÍDA: Formato de resposta JSON accept: application/json ``` { "predictions": [ {"predicted_label": 0.0}, {"predicted_label": 2.0} ] } ``` ## SAÍDA: Formato de resposta JSONLINES accept: application/jsonlines ``` {"predicted_label": 0.0} {"predicted_label": 2.0} ``` ## SAÍDA: Formato de resposta VERBOSE JSON No modo detalhado, a API fornece aos resultados da pesquisa o vetor de distâncias, classificadas da menor para a maior, com os elementos correspondentes no vetor de rótulos. Neste exemplo, k está definido como 3. accept: application/json; verbose=true ``` { "predictions": [ { "predicted_label": 0.0, "distances": [3.11792408, 3.89746071, 6.32548437], "labels": [0.0, 1.0, 0.0] }, { "predicted_label": 2.0, "distances": [1.08470316, 3.04917915, 5.25393973], "labels": [2.0, 2.0, 0.0] } ] } ``` ## SAÍDA: Formato de resposta RECORDIO-PROTOBUF tipo de conteúdo: aplicativo/ x-recordio-protobuf ``` [ Record = { features = {}, label = { 'predicted_label': { values: [0.0] # float32 } } }, Record = { features = {}, label = { 'predicted_label': { values: [2.0] # float32 } } } ] ``` ## SAÍDA: Formato de resposta VERBOSE RECORDIO-PROTOBUF No modo detalhado, a API fornece aos resultados da pesquisa o vetor de distâncias, classificadas da menor para a maior, com os elementos correspondentes no vetor de rótulos. Neste exemplo, k está definido como 3. aceitar: aplicativo/; verbose=true x-recordio-protobuf ``` [ Record = { features = {}, label = { 'predicted_label': { values: [0.0] # float32 }, 'distances': { values: [3.11792408, 3.89746071, 6.32548437] # float32 }, 'labels': { values: [0.0, 1.0, 0.0] # float32 } } }, Record = { features = {}, label = { 'predicted_label': { values: [0.0] # float32 }, 'distances': { values: [1.08470316, 3.04917915, 5.25393973] # float32 }, 'labels': { values: [2.0, 2.0, 0.0] # float32 } } } ] ``` ## SAÍDA DE AMOSTRA para o algoritmo k-NN Para tarefas de regressor: ``` [06/08/2018 20:15:33 INFO 140026520049408] #test_score (algo-1) : ('mse', 0.013333333333333334) ``` Para tarefas de classificador: ``` [06/08/2018 20:15:46 INFO 140285487171328] #test_score (algo-1) : ('accuracy', 0.98666666666666669) ```