AI: Introdução ao Aprendizado de Máquina

Última atualização: 2026-08-26

Aprendizado de Máquina (Machine Learning - ML) é o subcampo mais fundamental da IA—praticamente todas as aplicações modernas de IA (sistemas de recomendação, reconhecimento de fala, condução autônoma) são construídas sobre ML. Este capítulo ajudará você a compreender a essência do ML, seus três principais paradigmas e os tipos de tarefas que ele aborda, e irá guiá-lo na implementação do seu primeiro classificador completo de ML usando sklearn.

1. O Que Você Vai Aprender

• A Diferença Fundamental Entre Aprendizado de Máquina e Programação Tradicional
• Os Três Principais Paradigmas: Aprendizado Supervisionado, Aprendizado Não Supervisionado e Aprendizado por Reforço
• Tipos de Tarefa: Classificação vs. Regressão vs. Agrupamento
• Visão Geral do Fluxo de Trabalho de ML (Definição do Problema → Dados → Recursos → Treinamento → Avaliação → Implantação)
• Implemente seu primeiro classificador usando sklearn

2. História: Quando Há Regras Demais para Listar

(1) Ponto de Dor: Quanto mais regras são escritas, menor a acurácia se torna

A empresa de e-commerce do Bob precisa prever se os usuários comprarão um determinado produto. Ele começou a escrever regras:

IF idade > 30 AND contagem_visitas > 3 THEN comprar = sim
IF idade < 25 AND contagem_carrinho > 0 THEN comprar = talvez
IF região = "leste" AND desconto > 20% THEN comprar = sim
... (mais 300 regras depois) ...

Expandimos as regras de 10 para 300, mas a taxa de acurácia subiu de 60% para 72% e depois estagnou. Toda vez que uma nova categoria de produto é introduzida, precisamos reescrever todas as regras novamente—é simplesmente impossível de concluir.

(2) Soluções de Aprendizado de Máquina

Alice sugeriu: "Não vamos escrever nenhuma regra—vamos deixar o algoritmo encontrar padrões sozinho a partir de 100 mil registros históricos."

▶ Exemplo: Previsão de Comportamento de Compra Baseada em Regras vs. Baseada em Dados (Dificuldade: ⭐)

# Abordagem baseada em regras: você escreve a lógica
def vai_comprar_regras(usuario):
    """Prevê compra usando regras escritas manualmente"""
    if usuario['idade'] > 30 and usuario['contagem_visitas'] > 3:
        return True
    if usuario['contagem_carrinho'] > 0 and usuario['percentual_desconto'] > 20:
        return True
    return False

# Abordagem de AM: o algoritmo aprende a partir dos dados
# from sklearn.neighbors import KNeighborsClassifier
# modelo = KNeighborsClassifier(n_neighbors=5)
# modelo.fit(X_train, y_train)  # Aprende padrões a partir de 100 mil registros
# previsao = modelo.predict(dados_novo_usuario)

Saída: (Execute o exemplo para ver a saída real, ou consulte a nota de saída esperada nos comentários do código acima.)

(3) Retornos: De 72% para 89%

Bob treinou um modelo usando aprendizado de máquina, e a acurácia saltou de 72% para 89%. Além disso, para novas categorias de produtos, tudo o que é necessário é adicionar mais dados e retreinar o modelo—sem escrever uma única linha de regras.

3. O que é Machine Learning?

(1) Definição de Arthur Samuel (1959)

"Machine Learning é o campo de estudo que dá aos computadores a capacidade de aprender sem serem explicitamente programados."

Idea-chave: Não se trata de você escrever regras para o computador seguir; trata-se de fornecer dados para que o computador aprenda as regras sozinho.

(2) Definição de Tom Mitchell (1997)

"Diz-se que um programa de computador aprende com a experiência E com respeito a alguma classe de tarefas T e medida de desempenho P, se seu desempenho nas tarefas em T, medido por P, melhora com a experiência E."

Em linguagem simples: Quando o desempenho P de um programa na tarefa T melhora à medida que sua experiência E aumenta, diz-se que ele está "aprendendo".

Tomemos o cenário de Bob como exemplo:

(3) Regras Tradicionais vs. Machine Learning

4. Os Três Principais Paradigmas: Aprendizado Supervisionado / Não Supervisionado / Por Reforço

O aprendizado de máquina é dividido em três grandes paradigmas com base nos "métodos de aprendizado":

graph TB
    ML[Machine Learning] --> SL[Supervised Learning]
    ML --> UL[Unsupervised Learning]
    ML --> RL[Reinforcement Learning]

    SL --> SL1[Classification]
    SL --> SL2[Regression]

    UL --> UL1[Clustering]
    UL --> UL2[Dim. Reduction]

    RL --> RL1[Game AI]
    RL --> RL2[Robot Control]

    style ML fill:#e8f5e9
    style SL fill:#e1f5fe
    style UL fill:#fff3e0
    style RL fill:#f3e5f5

graph TB
    ML[Machine Learning] --> SL[Supervised Learning]
    ML --> UL[Unsupervised Learning]
    ML --> RL[Reinforcement Learning]

    SL --> SL1[Classification]
    SL --> SL2[Regression]

    UL --> UL1[Clustering]
    UL --> UL2[Dim. Reduction]

    RL --> RL1[Game AI]
    RL --> RL2[Robot Control]

    style ML fill:#e8f5e9
    style SL fill:#e1f5fe
    style UL fill:#fff3e0
    style RL fill:#f3e5f5

(1) Aprendizado Supervisionado

Característica-chave: Os dados de treinamento são rotulados (com respostas).

É como um professor guiando os alunos através de problemas práticos—cada problema tem uma resposta padrão, e os alunos aprendem seguindo o processo de “resolver problemas → verificar respostas → corrigir erros.”

▶ Exemplo: Carregando o conjunto de dados Iris com sklearn e realizando classificação (Dificuldade: ⭐)

# Load the Iris dataset and inspect its structure
from sklearn.datasets import load_iris

iris = load_iris()
print(f"Feature names: {iris.feature_names}")
print(f"Target names:  {list(iris.target_names)}")
print(f"Samples:       {iris.data.shape[0]}")
print(f"Features:      {iris.data.shape[1]}")
print(f"\nFirst 5 samples:")
for i in range(5):
    print(f"  {iris.data[i]} → {iris.target_names[iris.target[i]]}")

Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Target names:  ['setosa', 'versicolor', 'virginica']
Samples:       150
Features:      4

First 5 samples:
  [5.1 3.5 1.4 0.2] → setosa
  [4.9 3.0 1.4 0.2] → setosa
  [4.7 3.2 1.3 0.2] → setosa
  [4.6 3.1 1.5 0.2] → setosa
  [5.0 3.6 1.4 0.2] → setosa

(2) Aprendizado Não Supervisionado

Característica-chave: Os dados de treinamento não são rotulados.

É como dar a uma criança um monte de fotos e deixar que ela as organize sozinha com base no que elas "parecem"—sem ninguém dizer a ela "Isto é um gato" ou "Aquele é um cachorro."

(3) Aprendizado por Reforço

Característica-chave: Aprendizado por tentativa e erro e sinais de recompensa.

É exatamente como treinar um filhote de cachorro—dê um petisco (recompensa) quando ele fizer algo certo, e ignore-o (punição) quando fizer algo errado. O filhote gradualmente aprende quais comportamentos lhe rendem uma recompensa.

(4) Comparação dos Três Paradigmas

5. Tipos de Tarefas: Classificação / Regressão / Agrupamento

(1) Classificação

Preveja rótulos de categorias discretas. Por exemplo: Um e-mail é spam ou não? A imagem é de um gato ou de um cachorro?

(2) Regressão

Preveja valores contínuos. Por exemplo: Qual é o preço de uma casa? Qual será a temperatura amanhã?

(3) Agrupamento (Clustering)

Agrupe automaticamente os dados por similaridade, sem categorias predefinidas. Por exemplo: Os clientes são divididos automaticamente em 3 grupos.

(4) Comparação entre Classificação, Regressão e Agrupamento

6. Uma Visão Geral do Fluxo de Trabalho de ML

Um projeto completo de ML consiste em seis etapas, das quais nenhuma pode ser pulada:

graph TB
    A[1. Definir o Problema] --> B[2. Coletar Dados]
    B --> C[3. Engenharia de Features]
    C --> D[4. Treinar o Modelo]
    D --> E[5. Avaliar]
    E --> F{Bom o suficiente?}
    F -->|Não| C
    F -->|Sim| G[6. Implantar]
    G --> H[Monitorar & Retreinar]

    style A fill:#e1f5fe
    style B fill:#e8f5e9
    style C fill:#fff3e0
    style D fill:#f3e5f5
    style E fill:#fce4ec
    style G fill:#e0f2f1
    style H fill:#f1f8e9

graph TB
    A[1. Definir o Problema] --> B[2. Coletar Dados]
    B --> C[3. Engenharia de Features]
    C --> D[4. Treinar o Modelo]
    D --> E[5. Avaliar]
    E --> F{Bom o suficiente?}
    F -->|Não| C
    F -->|Sim| G[6. Implantar]
    G --> H[Monitorar & Retreinar]

    style A fill:#e1f5fe
    style B fill:#e8f5e9
    style C fill:#fff3e0
    style D fill:#f3e5f5
    style E fill:#fce4ec
    style G fill:#e0f2f1
    style H fill:#f1f8e9

(1) Definindo o Problema

Defina claramente o problema a ser resolvido, se a tarefa envolve classificação ou regressão, e quais são os critérios para o sucesso.

(2) Coletando Dados

Dados são a base do aprendizado de máquina. A qualidade dos dados determina diretamente o limite superior do desempenho de um modelo.

(3) Engenharia de Features

Converta os dados brutos em features numéricas que o modelo possa entender:

Dados Brutos → Engenharia de Features → Features
"Homem de 25 anos de Pequim" → [25, 1, 39]  (idade, código_gênero, código_cidade)

(4) Treinando o Modelo

Selecione um algoritmo, defina os hiperparâmetros e ajuste o modelo aos dados de treino.

(5) Avaliando o Modelo

Avalie o desempenho no conjunto de teste (dados que o modelo nunca viu antes) para garantir que o modelo possa generalizar.

(6) Implantação e Lançamento

Implante o modelo como uma API ou incorpore-o em uma aplicação, monitore continuamente seu desempenho e o retreine periodicamente.

7. Paradigma Unificado da API do sklearn

O scikit-learn (sklearn) é a biblioteca de aprendizado de máquina (ML) mais popular para Python, e seu design de API é extremamente consistente—todos os modelos seguem o mesmo conjunto de interfaces:

model = SomeClassifier(params)    # 1. Criar modelo
model.fit(X_train, y_train)      # 2. Treinar modelo
model.predict(X_new)             # 3. Prever
model.score(X_test, y_test)      # 4. Avaliar

▶ Exemplo: Treinamento e Previsão com o Classificador KNN (Dificuldade: ⭐⭐)

# Classificador KNN: treinar e prever
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

# Carregar e dividir dados
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Criar e treinar modelo
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)

# Prever
y_pred = knn.predict(X_test)

# Avaliar
train_acc = knn.score(X_train, y_train)
test_acc = knn.score(X_test, y_test)
print(f"Acurácia no treino: {train_acc:.3f}")
print(f"Acurácia no teste:  {test_acc:.3f}")

# Prever uma nova amostra
import numpy as np
new_sample = np.array([[5.0, 3.4, 1.5, 0.2]])
pred = knn.predict(new_sample)
print(f"Classe prevista da nova amostra: {load_iris().target_names[pred[0]]}")

Acurácia no treino: 0.971
Acurácia no teste:  0.978
Classe prevista da nova amostra: setosa

(1) Referência Rápida para Classificadores Comuns do sklearn

8. Exemplo Completo: Usando KNN para Concluir o Fluxo de Trabalho Completo de ML no Conjunto de Dados Iris

Abaixo está um exemplo completo que percorre todo o fluxo de trabalho de ML, desde o carregamento dos dados até a fronteira de decisão para visualização:

▶ Exemplo: Comparando Taxas de Acurácia para Diferentes Valores de k (Dificuldade: ⭐⭐)

# Compare KNN with different k values
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

print("=== KNN: Effect of k value ===")
for k in [1, 3, 5, 7, 9, 15, 30]:
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train, y_train)
    train_acc = knn.score(X_train, y_train)
    test_acc = knn.score(X_test, y_test)
    print(f"k={k:2d} | Train: {train_acc:.3f} | Test: {test_acc:.3f}")

=== KNN: Effect of k value ===
k= 1 | Train: 1.000 | Test: 0.956
k= 3 | Train: 0.971 | Test: 0.978
k= 5 | Train: 0.971 | Test: 0.978
k= 7 | Train: 0.971 | Test: 0.978
k= 9 | Train: 0.971 | Test: 0.978
k=15 | Train: 0.971 | Test: 0.978
k=30 | Train: 0.952 | Test: 0.956

▶ Exemplo: Interpretando um Relatório de Classificação (Dificuldade: ⭐⭐)

# Detailed classification report
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)

print("=== Classification Report ===")
print(classification_report(y_test, y_pred, target_names=load_iris().target_names))

=== Classification Report ===
              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        15
  versicolor       1.00      0.93      0.97        15
   virginica       0.94      1.00      0.97        15

    accuracy                           0.98        45
   macro avg       0.98      0.98      0.98        45
weighted avg       0.98      0.98      0.98        45

Como Interpretar o Relatório de Classificação:

▶ Exemplo: Visualizando Fronteiras de Decisão (Dificuldade: ⭐⭐⭐)

# Visualize KNN decision boundaries on Iris (2 features)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier

iris = load_iris()
X = iris.data[:, :2]  # Use only first 2 features for 2D plot
y = iris.target

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X, y)

# Create mesh grid for decision boundary
h = 0.02
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))
Z = knn.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)

# Plot
plt.figure(figsize=(8, 6))
plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Set1)
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1, edgecolors='black')
plt.xlabel('Sepal length (cm)')
plt.ylabel('Sepal width (cm)')
plt.title('KNN (k=5) Decision Boundary on Iris')
plt.legend(handles=scatter.legend_elements()[0], labels=list(iris.target_names))
plt.savefig('knn_decision_boundary.png', dpi=150, bbox_inches='tight')
plt.show()
print("Decision boundary plot saved.")

Saída: (Execute o exemplo para ver a saída real, ou consulte a nota de saída esperada nos comentários do código acima.)

▶ Exemplo: Exemplo Abrangente — Fluxo de Trabalho Completo de ML Usando KNN no Conjunto de Dados Iris (Dificuldade: ⭐⭐⭐)

# ============================================
# Complete ML Workflow: KNN on Iris Dataset
# Step 1-6: Full pipeline with evaluation
# ============================================

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import (accuracy_score, classification_report,
                             confusion_matrix)

# Step 1: Load data
iris = load_iris()
X, y = iris.data, iris.target
print(f"Step 1 - Data loaded: {X.shape[0]} samples, {X.shape[1]} features")
print(f"  Classes: {list(iris.target_names)}")
print(f"  Class distribution: {np.bincount(y)}")

# Step 2: Split data (70% train, 30% test)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)
print(f"\nStep 2 - Data split: Train={len(X_train)}, Test={len(X_test)}")

# Step 3: Feature scaling (important for KNN!)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
print(f"\nStep 3 - Features scaled (mean≈0, std≈1)")
print(f"  Before scaling - mean: {X_train.mean(axis=0).round(2)}")
print(f"  After scaling  - mean: {X_train_scaled.mean(axis=0).round(2)}")

# Step 4: Train model
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)
print(f"\nStep 4 - Model trained: KNN (k=5)")

# Step 5: Evaluate
y_pred = knn.predict(X_test_scaled)
test_acc = accuracy_score(y_test, y_pred)
print(f"\nStep 5 - Evaluation:")
print(f"  Test accuracy: {test_acc:.3f}")
print(f"\n{classification_report(y_test, y_pred, target_names=iris.target_names)}")
print("Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))

# Step 6: Predict new samples
new_data = np.array([
    [5.1, 3.5, 1.4, 0.2],   # Likely setosa
    [6.7, 3.0, 5.2, 2.3],   # Likely virginica
    [5.9, 3.0, 4.2, 1.5],   # Likely versicolor
])
new_data_scaled = scaler.transform(new_data)
predictions = knn.predict(new_data_scaled)
print("\nStep 6 - New predictions:")
for i, pred in enumerate(predictions):
    print(f"  Sample {i+1} → {iris.target_names[pred]}")

Step 1 - Data loaded: 150 samples, 4 features
  Classes: ['setosa', 'versicolor', 'virginica']
  Class distribution: [50 50 50]

Step 2 - Data split: Train=105, Test=45

Step 3 - Features scaled (mean≈0, std≈1)
  Before scaling - mean: [5.86 3.06 3.78 1.2 ]
  After scaling  - mean: [ 0. -0.  0. -0.]

Step 4 - Model trained: KNN (k=5)

Step 5 - Evaluation:
  Test accuracy: 1.000

              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        15
  versicolor       1.00      1.00      1.00        15
   virginica       1.00      1.00      1.00        15

    accuracy                           1.00        45
   macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

Confusion Matrix:
[[15  0  0]
 [ 0 15  0]
 [ 0  0 15]]

Step 6 - New predictions:
  Sample 1 → setosa
  Sample 2 → virginica
  Sample 3 → versicolor

❓ Perguntas Frequentes

P: Qual é a diferença entre aprendizado de máquina e aprendizado profundo? R: O aprendizado profundo é um subconjunto do aprendizado de máquina (ML). O ML abrange todos os métodos de "aprender com dados" (KNN, SVM, árvores de decisão, etc.), enquanto o DL refere-se especificamente a métodos que utilizam redes neurais multicamadas. O DL tem melhor desempenho em dados não estruturados, como imagens, fala e linguagem natural, mas requer mais dados e poder computacional; o ML tradicional permanece muito prático para dados estruturados. Relação: IA ⊃ ML ⊃ DL.

P: O aprendizado supervisionado sempre requer rótulos? R: Sim, o aprendizado supervisionado é definido como "aprender com dados rotulados". Sem rótulos, é utilizado o aprendizado não supervisionado (como agrupamento e redução de dimensionalidade). No entanto, o "aprendizado semissupervisionado" pode usar uma pequena quantidade de dados rotulados combinada com uma grande quantidade de dados não rotulados — o que é muito prático em cenários onde a rotulação é custosa.

P: Qual é a diferença entre agrupamento e classificação? R: A classificação é aprendizado supervisionado — as categorias são predefinidas (gato/cachorro) e os dados de treinamento são rotulados. O agrupamento é aprendizado não supervisionado — as categorias são descobertas automaticamente pelo algoritmo e os dados de treinamento não são rotulados. A classificação responde à pergunta "Em qual categoria isso se encaixa?", enquanto o agrupamento responde a "Como os dados podem ser agrupados?".

P: O que é sklearn? R: O scikit-learn (sklearn) é a biblioteca de aprendizado de máquina mais popular para Python, fornecendo um conjunto completo de ferramentas para classificação, regressão, agrupamento, redução de dimensionalidade, engenharia de recursos, seleção de modelos e mais. Sua API é extremamente consistente (fit/predict/score), tornando-a fácil de usar e a ferramenta de escolha para aprender ML. Instalação: pip install scikit-learn.

P: Quanto tempo leva para treinar um modelo de aprendizado de máquina? R: Depende de três fatores: a quantidade de dados, a complexidade do modelo e o hardware. Treinar um modelo KNN no conjunto de dados Iris (150 registros) leva menos de 1 segundo; treinar uma floresta aleatória em 1 milhão de registros pode levar de alguns minutos a algumas horas; treinar um modelo grande no nível do GPT requer milhares de GPUs e leva várias semanas. Para projetos de iniciantes, geralmente leva apenas alguns segundos a alguns minutos.

P: Como escolher o valor de k no KNN? R: Geralmente, a validação cruzada é usada para selecioná-lo. Se k for muito pequeno (por exemplo, k=1), é provável que ocorra overfitting; se k for muito grande (por exemplo, k=50), é provável que ocorra underfitting. Regra prática: Comece com k=5, depois experimente k=1, 3, 5, 7, 9 e 11 para ver qual tem o melhor desempenho no conjunto de validação. Geralmente, escolha um número ímpar para evitar empates.

📖 Resumo

• A essência do aprendizado de máquina é "deixar os algoritmos aprenderem regras a partir dos dados, em vez de os humanos escrevê-las"—uma mudança de abordagens orientadas por regras para orientadas por dados
• Três principais paradigmas: aprendizado supervisionado (dados rotulados, previsão), aprendizado não supervisionado (dados não rotulados, descoberta de padrões) e aprendizado por reforço (tentativa e erro + recompensas)
• Tipos de tarefa: classificação (rótulos discretos), regressão (valores contínuos), agrupamento (agrupamento automático)—a escolha depende do problema e dos dados
• As seis etapas de um fluxo de trabalho de AM—definir o problema → coletar dados → engenharia de recursos → treinamento → avaliação → implantação—constituem um processo iterativo.
• Paradigma unificado da API do sklearn: fit() Treinamento → predict() Previsão → score() Avaliação; ao mudar de algoritmo, apenas os nomes das classes precisam ser modificados
• O KNN é o classificador mais intuitivo: a classe de uma nova amostra = a classe majoritária de seus k vizinhos mais próximos

📝 Exercícios

1. Problema Básico (Dificuldade ⭐): Use o sklearn para treinar um KNeighborsClassifier (k=5) no conjunto de dados Wine (load_wine()), e imprima a acurácia no treino e no teste. O conjunto de dados Wine possui 13 características e 3 classes.
2. Problema Avançado (Dificuldade ⭐⭐): Compare a acurácia do KNN e das árvores de decisão (DecisionTreeClassifier) no conjunto de dados Wine. Tente diferentes valores de k (1, 3, 5, 7, 9) e diferentes profundidades da árvore (2, 3, 5, None) para encontrar os parâmetros ótimos para cada algoritmo.
3. Questão Desafiadora (Dificuldade ⭐⭐⭐): Plote a curva de acurácia para diferentes valores de k — com k (1–30) no eixo x e a acurácia no teste no eixo y — e marque o pico. Dica: Use matplotlib.pyplot.plot(), observe a tendência da curva e explique por que um k muito grande ou muito pequeno é indesejável.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós