Scikit-learn é uma biblioteca Python de código aberto que simplifica o processo de construção de modelos de aprendizado de máquina. Ele oferece uma interface limpa e consistente que ajuda usuários iniciantes e experientes a trabalhar com eficiência.

exemplo de formato json

• Suporta tarefas como agrupamento de regressão de classificação e pré-processamento
• Torna a construção de modelos rápida e confiável
• Fornece ferramentas prontas para uso para treinamento e avaliação
• Reduz a complexidade evitando a implementação manual de algoritmos

Instalando e usando o Scikit-learn

Antes de começarmos a construir modelos, precisamos instalar Scikit-aprender. Requer Python 3.8 ou mais recente e depende de duas bibliotecas importantes: NumPy e SciPy. Certifique-se de que eles estejam instalados primeiro.

Para instalar o Scikit-learn execute o seguinte comando:

pip instalar -U scikit-learn

Isso fará o download e instalará a versão mais recente do Scikit-learn junto com suas dependências. Vamos ver as várias etapas envolvidas no processo de construção do modelo usando a biblioteca Scikit-learn.

Etapa 1: carregar um conjunto de dados

Um conjunto de dados consiste em:

• Recursos (X): Variáveis ​​de entrada que descrevem os dados
• Alvo (y): O valor que queremos prever

Scikit-learn fornece conjuntos de dados integrados como Iris Digits e Boston Housing. Usando o conjunto de dados Iris:

• load_iris() carrega os dados
• X armazena dados de recursos
• y armazena rótulos de destino
• feature_names e target_names fornecem nomes descritivos

Podemos inspecionar as primeiras linhas para entender a estrutura. Para conjuntos de dados personalizados, o Pandas é comumente usado para carregar arquivos externos, como CSVs.

from sklearn.datasets import load_iris iris = load_iris() X = iris.data y = iris.target feature_names = iris.feature_names target_names = iris.target_names print('Feature names:' feature_names) print('Target names:' target_names) print('nType of X is:' type(X)) print('nFirst 5 rows of X:n' X[:5]) 

Saída: 

Às vezes, precisamos trabalhar em nossos próprios dados personalizados e depois carregamos um conjunto de dados externo. Para isso podemos usar o biblioteca de pandas para fácil carregamento e manipulação de conjuntos de dados.

Para isso você pode consultar nosso artigo sobre Como importar arquivo csv em pandas ?

Etapa 2: dividir o conjunto de dados

Para avaliar um modelo de forma justa, dividimos os dados em:

• Conjunto de treinamento: usado para treinar o modelo
• Conjunto de testes: usado para avaliar quão bem o modelo generaliza

Usando train_test_split, dividimos o conjunto de dados Iris para que 60% seja para treinamento e 40% para teste (test_size=0,4). random_state=1 garante a reprodutibilidade.

Após a divisão obtemos:

• X_train y_train -> Dados de treinamento
• X_test y_test -> Dados de teste

A verificação das formas garante que os dados sejam divididos corretamente.

from sklearn.model_selection import train_test_split X_train X_test y_train y_test = train_test_split(X y test_size=0.4 random_state=1) 

Agora vamos verificar o Formas dos dados divididos para garantir que ambos os conjuntos tenham proporções corretas de dados, evitando possíveis erros na avaliação ou treinamento do modelo.

print('X_train Shape:' X_train.shape) print('X_test Shape:' X_test.shape) print('Y_train Shape:' y_train.shape) print('Y_test Shape:' y_test.shape) 

Saída:

Etapa 3: Tratamento de dados categóricos

Os algoritmos de aprendizado de máquina funcionam com entradas numéricas, portanto, os dados categóricos (texto) devem ser convertidos em números. Se não forem codificados corretamente, os modelos podem interpretar mal as categorias. Scikit-learn fornece vários métodos de codificação:

1. Codificação de etiqueta : converte cada categoria em um número inteiro exclusivo. Por exemplo, em uma coluna com categorias como 'gato', 'cachorro' e 'pássaro', elas seriam convertidas para 0, 1 e 2, respectivamente. Este método funciona bem quando as categorias têm uma ordem significativa, como Baixo, Médio e Alto.

• LabelEncoder(): Ele é inicializado para criar um objeto codificador que converterá valores categóricos em rótulos numéricos.
• fit_transform(): Este método primeiro ajusta o codificador aos dados categóricos e depois transforma as categorias em rótulos numéricos correspondentes.

from sklearn.preprocessing import LabelEncoder categorical_feature = ['cat' 'dog' 'dog' 'cat' 'bird'] encoder = LabelEncoder() encoded_feature = encoder.fit_transform(categorical_feature) print('Encoded feature:' encoded_feature) 

Saída:

número armstrong

Recurso codificado: [1 2 2 1 0]

2. Codificação One-Hot : A codificação One-Hot cria colunas binárias separadas para cada categoria. Isto é útil quando as categorias não possuem nenhuma ordem natural. Exemplo: gato cachorro pássaro -> 3 novas colunas (gato/cachorro/pássaro) com 1s e 0s.

• A entrada deve ser remodelada em uma matriz 2D
• OneHotEncoder(sparse_output=False) gera colunas binárias

from sklearn.preprocessing import OneHotEncoder import numpy as np categorical_feature = ['cat' 'dog' 'dog' 'cat' 'bird'] categorical_feature = np.array(categorical_feature).reshape(-1 1) encoder = OneHotEncoder(sparse_output=False) encoded_feature = encoder.fit_transform(categorical_feature) print('OneHotEncoded feature:n' encoded_feature) 

Saída:

Além da codificação de rótulo e da codificação one-hot, existem outras técnicas como Codificação Média .

conectar-se a um banco de dados java

Etapa 4: treinar o modelo

Agora que nossos dados estão prontos, é hora de treinar um modelo de aprendizado de máquina. Scikit-learn possui muitos algoritmos com uma interface consistente para previsão e avaliação de treinamento. Aqui vamos usar Regressão Logística como exemplo.

Observação : Não entraremos em detalhes de como o algoritmo funciona, pois estamos interessados ​​apenas em entender sua implementação. 

• log_reg = LogísticaRegressão(max_iter=200): Criando um objeto classificador de regressão logística.
• log_reg.fit(X_train y_train): Usando isso o modelo de regressão logística ajusta os parâmetros do modelo para melhor ajustar os dados.

from sklearn.linear_model import LogisticRegression log_reg = LogisticRegression(max_iter=200) log_reg.fit(X_train y_train) 

Etapa 5: faça previsões

Uma vez treinado, usamos o modelo para fazer previsões nos dados de teste X_test chamando o método de previsão. Isso retorna rótulos previstos y_pred.

• log_reg.predict: Ele usa modelo de regressão logística treinado para prever rótulos para os dados de teste X_test.

y_pred = log_reg.predict(X_test) 

Etapa 6: avaliando a precisão do modelo

Verifique o desempenho do nosso modelo comparando y_test e y_pred. Aqui estamos usando o método Precision_score do módulo de métricas.

from sklearn import metrics print('Logistic Regression model accuracy:' metrics.accuracy_score(y_test y_pred)) 

Saída:

Precisão do modelo de regressão logística: 0,9666666666666667

Agora queremos que nosso modelo faça previsões sobre novos dados de amostra. Então, a entrada da amostra pode simplesmente ser passada da mesma maneira que passamos qualquer matriz de recursos. Aqui usamos como amostra = [[3 5 4 2] [2 3 5 4]]

sample = [[3 5 4 2] [2 3 5 4]] preds = log_reg.predict(sample) pred_species = [iris.target_names[p] for p in preds] print('Predictions:' pred_species) 

Saída: 

Previsões: [np.str_('virginica') np.str_('virginica')]

Recursos do Scikit-learn

O Scikit-learn é usado porque torna a construção de modelos de aprendizado de máquina simples e eficiente. Aqui estão alguns motivos importantes:

1. Ferramentas prontas para usar : fornece funções integradas para tarefas comuns, como modelos de treinamento de pré-processamento de dados e realização de previsões. Isso economiza tempo, evitando a necessidade de codificar algoritmos do zero.
2. Avaliação fácil do modelo : Com ferramentas como validação cruzada e métricas de desempenho, ajuda a medir o quão bem nosso modelo funciona e a identificar áreas de melhoria.
3. Amplo suporte a algoritmos : oferece muitos algoritmos populares de aprendizado de máquina, incluindo regressão de classificação e clustering, o que nos dá flexibilidade para escolher o modelo certo para o nosso problema.
4. Integração Suave : construído com base em bibliotecas Python importantes, como NumPy e SciPy, para que se encaixe em nosso fluxo de trabalho de análise de dados existente.
5. Interface simples e consistente : a mesma sintaxe simples funciona em diferentes modelos e ajuda a facilitar o aprendizado e a alternância entre algoritmos.
6. Ajuste de modelo facilitado : Ferramentas como a pesquisa em grade nos ajudam a ajustar as configurações do nosso modelo para melhorar a precisão sem complicações extras.

Benefícios de usar o Scikit-learn

• Amigo do usuário : A interface simples e consistente do Scikit-learn o torna acessível para iniciantes e ideal para especialistas.
• Economia de tempo: Ferramentas e algoritmos pré-construídos reduzem o tempo de desenvolvimento, o que nos permite focar mais na resolução de problemas do que na codificação de detalhes.
• Melhor desempenho do modelo : Ferramentas de ajuste e avaliação fáceis de usar ajudam a melhorar a precisão e a confiabilidade do modelo.
• Flexível e escalável : suporta uma ampla gama de algoritmos e integra-se perfeitamente com outras bibliotecas Python, ajudando a torná-lo adequado para projetos de qualquer tamanho.
• Forte apoio comunitário : Uma grande comunidade ativa garante atualizações regulares de documentação extensa e muitos recursos para ajudar quando tivermos dúvidas.