Classificação de Íris Usando SVM

Introdução

Neste projeto, você aprenderá como classificar o conjunto de dados iris usando um modelo Support Vector Classifier (SVC). O conjunto de dados iris é um conjunto de dados clássico de aprendizado de máquina que contém informações sobre diferentes espécies de íris, incluindo o comprimento da sépala, a largura da sépala, o comprimento da pétala e a largura da pétala.

🎯 Tarefas

Neste projeto, você aprenderá:

• Como importar as bibliotecas necessárias e carregar o conjunto de dados iris
• Como dividir o conjunto de dados em conjuntos de treinamento e teste
• Como criar e treinar um modelo Support Vector Classifier
• Como fazer previsões usando o modelo treinado
• Como avaliar o desempenho do modelo usando a pontuação de acurácia (accuracy score) e o relatório de classificação (classification report)

🏆 Conquistas

Após concluir este projeto, você será capaz de:

• Usar a biblioteca scikit-learn para trabalhar com o conjunto de dados iris
• Dividir um conjunto de dados em conjuntos de treinamento e teste
• Criar e treinar um modelo Support Vector Classifier
• Fazer previsões usando um modelo treinado
• Avaliar o desempenho de um modelo usando a pontuação de acurácia (accuracy score) e o relatório de classificação (classification report)

Importar as Bibliotecas Necessárias e Carregar o Conjunto de Dados

Nesta etapa, você aprenderá como importar as bibliotecas necessárias e carregar o conjunto de dados iris. Siga os passos abaixo para completar esta etapa:

Em iris_classification_svm.py, importe as bibliotecas necessárias, incluindo aquelas para carregar o conjunto de dados, dividir os dados, criar o modelo SVM e avaliar seu desempenho.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report

Carregue os dados iris de sklearn.datasets e divida o conjunto de dados em conjuntos de treinamento e teste. O conjunto de dados é dividido usando uma proporção de 80-20 para treinamento e teste, com uma semente aleatória de 42 para reprodutibilidade.

## Continue in the same file
def load_and_split_data() -> tuple:
    """
    Returns:
        tuple: [X_train, X_test, y_train, y_test]
    """
    iris = load_iris()
    X, y = iris.data, iris.target
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    return X_train, X_test, y_train, y_test

Este código carrega o conjunto de dados Iris e o divide em conjuntos de treinamento e teste para fins de aprendizado de máquina. Aqui está uma análise de cada parte:

1. Importando as bibliotecas necessárias:
   • sklearn.datasets é usado para carregar conjuntos de dados, incluindo o conjunto de dados Iris.
   • sklearn.model_selection fornece utilitários para dividir conjuntos de dados em conjuntos de treinamento e teste.
   • sklearn.svm contém classes para Máquinas de Vetores de Suporte (Support Vector Machines - SVM), um tipo de algoritmo de aprendizado de máquina.
   • sklearn.metrics inclui ferramentas para avaliar o desempenho de modelos, como acurácia (accuracy) e relatórios de classificação (classification reports).
2. Definição da Função: Uma função chamada load_and_split_data é definida. Esta função realiza as seguintes tarefas:
   • Carrega o conjunto de dados Iris: load_iris() é uma função fornecida por sklearn.datasets que carrega o conjunto de dados de flores Iris, que é um conjunto de dados popular para tarefas de classificação. Ele contém medições de 150 flores de íris de três espécies diferentes.
   • Separação de Dados: O conjunto de dados é separado em características (X) e rótulos alvo (y). Neste caso, X seriam as medições de 4 dimensões das flores de íris, e y seriam os rótulos das espécies correspondentes (0, 1 ou 2).
   • Divisão dos Dados: train_test_split de sklearn.model_selection é usado para dividir os dados em subconjuntos de treinamento e teste. O parâmetro test_size=0.2 significa que 20% dos dados serão usados para teste, enquanto os 80% restantes serão usados para treinamento. random_state=42 garante a reprodutibilidade da divisão; usar a mesma semente (42 aqui) produzirá a mesma divisão toda vez que o código for executado.
   • Valores de Retorno: A função retorna uma tupla contendo X_train, X_test, y_train e y_test, que são os conjuntos de características e alvos para os dados de treinamento e teste.

Criar e Treinar o Modelo SVM

Nesta etapa, você aprenderá como criar um modelo Support Vector Classifier e treiná-lo com os dados de treinamento.

## Continue in the same file
def create_and_train_SVM(X_train: list, y_train: list) -> SVC:
    """
    Args:
        X_train: [features for training]
        y_train: [labels for training]

    Returns:
        SVC: [Trained Support Vector Classifier model]
    """
    svm = SVC()
    svm.fit(X_train, y_train)
    return svm

Esta função, create_and_train_SVM, é projetada para instanciar um modelo Support Vector Classifier (SVM) usando a classe sklearn.svm.SVC e, em seguida, treiná-lo com os dados de treinamento fornecidos. Aqui está uma explicação detalhada:

• Assinatura da Função: A função recebe dois argumentos:
  • X_train: Uma lista ou objeto semelhante a um array contendo as características (variáveis de entrada) para o conjunto de dados de treinamento.
  • y_train: Uma lista ou objeto semelhante a um array contendo os rótulos correspondentes (variáveis de saída) para o conjunto de dados de treinamento.
• Instanciando um Modelo SVM: Dentro da função, SVC() é chamado sem nenhum parâmetro. Isso cria um modelo Support Vector Classifier padrão. A classe SVC no scikit-learn oferece vários parâmetros para personalizar o modelo, como tipo de kernel, regularização, etc., mas neste exemplo básico, os valores padrão são usados.
• Treinando o Modelo: O método fit do objeto svm é chamado com X_train e y_train. É aqui que o treinamento real ocorre — o modelo aprende padrões a partir das características (X_train) associadas aos seus respectivos rótulos de classe (y_train).
• Retornando o Modelo Treinado: Após o treinamento, a função retorna o modelo SVC treinado. Este modelo pode então ser usado para fazer previsões em dados novos e não vistos ou para avaliar seu desempenho usando um conjunto de dados de teste.

Fazer Previsões

Nesta etapa, você aprenderá como fazer previsões usando o modelo SVM treinado.

## Continue in the same file
def make_predictions(model: SVC, X_test: list) -> list:
    """
    Args:
        model: [Trained Support Vector Classifier model]
        X_test: [features for testing]

    Returns:
        list: [Predictions]
    """
    predictions = model.predict(X_test)
    return predictions

A função make_predictions recebe um modelo SVM treinado e um conjunto de características de teste como entradas e retorna uma lista de rótulos previstos para os dados de teste. Aqui está uma análise:

• Argumentos da Função:
  • model: Esta é uma instância da classe SVC (Support Vector Classifier) que já foi treinada em um conjunto de dados. Assume-se que o modelo sabe como classificar novas instâncias com base nos padrões que aprendeu durante a fase de treinamento.
  • X_test: Uma lista ou objeto semelhante a um array contendo as características (variáveis de entrada) para o conjunto de dados de teste. Estes são os exemplos não vistos para os quais o modelo fará previsões de rótulos.
• Fazendo Previsões: Dentro da função, o método predict do model é invocado com X_test como seu argumento. O método predict aplica o modelo aprendido a cada instância no conjunto de teste para estimar seus rótulos de classe. Ele não requer os rótulos verdadeiros (y_test), apenas as características de entrada.
• Retornando Previsões: A função então retorna esses rótulos estimados como uma lista. Cada elemento na lista retornada corresponde ao rótulo de classe previsto da respectiva instância no conjunto de dados X_test.

Avaliar o Modelo

Avalie o modelo calculando a pontuação de acurácia e exibindo o relatório de classificação.

## Continue in the same file
if __name__ == "__main__":
    ## Load and split the data
    X_train, X_test, y_train, y_test = load_and_split_data()

    ## Create and train the SVM model
    svm_model = create_and_train_SVM(X_train, y_train)

    ## Make predictions
    predictions = make_predictions(svm_model, X_test)

    ## Evaluate the model
    accuracy = accuracy_score(y_test, predictions)
    print(f"Accuracy: {accuracy:.2f}")

    ## Display classification report
    print("Classification Report:")
    print(classification_report(y_test, predictions))

Agora, execute o script a partir do terminal:

python iris_classification_svm.py

A saída deve ser:

Accuracy: 1.00
Classification Report:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        10
           1       1.00      1.00      1.00         9
           2       1.00      1.00      1.00        11

    accuracy                           1.00        30
   macro avg       1.00      1.00      1.00        30
weighted avg       1.00      1.00      1.00        30

Seguindo estas etapas, você concluiu o projeto de classificação do conjunto de dados iris usando um modelo Support Vector Classifier (SVC).

Resumo

Parabéns! Você concluiu este projeto. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.