Imagem do editor
Scikit-learn é uma das bibliotecas de aprendizado de máquina mais comumente usadas construídas em python. Sua popularidade pode ser atribuída à sua estrutura de código fácil e consistente, que é amigável para desenvolvedores iniciantes. Além disso, há um alto nível de suporte disponível junto com flexibilidade para integrar funcionalidades de terceiros, o que torna a biblioteca robusta e adequada para produção. A biblioteca contém vários modelos de aprendizado de máquina para classificação, regressão e agrupamento. Neste tutorial, exploraremos o problema de classificação multiclasse por meio de vários algoritmos. Vamos mergulhar nisso e construir nossos modelos scikit-learn.
pip install scikit-learn
Usaremos o conjunto de dados “Wine” disponível no módulo de conjuntos de dados do scikit-learn. Este conjunto de dados consiste em 178 amostras e 3 classes no total. O conjunto de dados já está pré-processado e convertido em vetores de recursos, portanto, podemos usá-lo diretamente para treinar nossos modelos.
from sklearn.datasets import load_wine X, y = load_wine(return_X_y=True)
Manteremos 67% dos dados para treinamento e os 33% restantes para teste.
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42
)
Agora, vamos experimentar 5 modelos diferentes de diferentes complexidades e avaliar seus resultados em nosso conjunto de dados.
model_lr = LogisticRegression()
model_lr.fit(X_train, y_train)
y_pred_lr = model_lr.predict(X_test) print("Accuracy Score: ", accuracy_score(y_pred_lr, y_test))
print(classification_report(y_pred_lr, y_test))
saída
Accuracy Score: 0.9830508474576272 precision recall f1-score support 0 1.00 0.95 0.98 21 1 0.96 1.00 0.98 23 2 1.00 1.00 1.00 15 accuracy 0.98 59 macro avg 0.99 0.98 0.98 59
weighted avg 0.98 0.98 0.98 59
model_knn = KNeighborsClassifier(n_neighbors=1)
model_knn.fit(X_train, y_train)
y_pred_knn = model_knn.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_knn, y_test))
print(classification_report(y_pred_knn, y_test))
saída
Accuracy Score: 0.7796610169491526 precision recall f1-score support 0 0.90 0.78 0.84 23 1 0.75 0.82 0.78 22 2 0.67 0.71 0.69 14 accuracy 0.78 59 macro avg 0.77 0.77 0.77 59
weighted avg 0.79 0.78 0.78 59
Ao alterar o parâmetro 'n_vizinhos=2' observamos uma diminuição no valor da precisão. Portanto, mostra que os dados são simples o suficiente e alcançam um melhor aprendizado com um único vizinho a ser considerado.
saída
Accuracy Score: 0.6949152542372882 precision recall f1-score support 0 0.90 0.72 0.80 25 1 0.75 0.69 0.72 26 2 0.33 0.62 0.43 8 accuracy 0.69 59 macro avg 0.66 0.68 0.65 59
weighted avg 0.76 0.69 0.72 59
from sklearn.naive_bayes import GaussianNB model_nb = GaussianNB()
model_nb.fit(X_train, y_train)
y_pred_nb = model_nb.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_nb, y_test))
print(classification_report(y_pred_nb, y_test))
saída
Accuracy Score: 1.0 precision recall f1-score support 0 1.00 1.00 1.00 20 1 1.00 1.00 1.00 24 2 1.00 1.00 1.00 15 accuracy 1.00 59 macro avg 1.00 1.00 1.00 59
weighted avg 1.00 1.00 1.00 59
from sklearn.tree import DecisionTreeClassifier model_dtclassifier = DecisionTreeClassifier()
model_dtclassifier.fit(X_train, y_train)
y_pred_dtclassifier = model_dtclassifier.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_dtclassifier, y_test))
print(classification_report(y_pred_dtclassifier, y_test))
saída
Accuracy Score: 0.9661016949152542 precision recall f1-score support 0 0.95 0.95 0.95 20 1 1.00 0.96 0.98 25 2 0.93 1.00 0.97 14 accuracy 0.97 59 macro avg 0.96 0.97 0.97 59
weighted avg 0.97 0.97 0.97 59
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV def get_best_parameters(): params = { "n_estimators": [10, 50, 100], "max_features": ["auto", "sqrt", "log2"], "max_depth": [5, 10, 20, 50], "min_samples_split": [2, 4, 6], "min_samples_leaf": [2, 4, 6], "bootstrap": [True, False], } model_rfclassifier = RandomForestClassifier(random_state=42) rf_randomsearch = RandomizedSearchCV( estimator=model_rfclassifier, param_distributions=params, n_iter=5, cv=3, verbose=2, random_state=42, ) rf_randomsearch.fit(X_train, y_train) best_parameters = rf_randomsearch.best_params_ print("Best Parameters:", best_parameters) return best_parameters parameters_rfclassifier = get_best_parameters() model_rfclassifier = RandomForestClassifier( **parameters_rfclassifier, random_state=42
) model_rfclassifier.fit(X_train, y_train) y_pred_rfclassifier = model_rfclassifier.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_rfclassifier, y_test))
print(classification_report(y_pred_rfclassifier, y_test))
saída
Best Parameters: {'n_estimators': 100, 'min_samples_split': 6, 'min_samples_leaf': 4, 'max_features': 'log2', 'max_depth': 5, 'bootstrap': True}
Accuracy Score: 0.9830508474576272 precision recall f1-score support 0 1.00 0.95 0.98 21 1 0.96 1.00 0.98 23 2 1.00 1.00 1.00 15 accuracy 0.98 59 macro avg 0.99 0.98 0.98 59
weighted avg 0.98 0.98 0.98 59
Neste algoritmo, realizamos alguns ajustes de hiperparâmetros para obter a melhor precisão. Definimos uma grade de parâmetros que consiste em vários valores para escolher para cada parâmetro. Além disso, usamos o algoritmo Randomized Search CV para pesquisar o melhor espaço de parâmetros para o modelo. Finalmente, alimentamos o classificador com os parâmetros obtidos e treinamos o modelo.
Modelos | Precisão | Observações |
Regressão Logística | 98.30% | Atinge grande precisão. O modelo é capaz de generalizar bem no conjunto de dados de teste. |
Vizinhos mais próximos | 77.96% | O algoritmo não é capaz de aprender bem a representação dos dados. |
Baías ingénuas | 100% | O modelo é menos complexo, portanto, superajusta os dados para obter precisão absoluta. |
Classificador de árvore de decisão | 96.61% | Alcança precisão decente. |
Classificador Random Forest | 98.30% | Sendo uma abordagem baseada em conjunto, ela tem um desempenho melhor do que a Árvore de Decisão. A execução do ajuste de hiperparâmetros faz com que ele alcance uma precisão semelhante à regressão logística. |
Neste tutorial, aprendemos como começar a construir e treinar modelos de aprendizado de máquina no scikit-learn. Implementamos e avaliamos alguns algoritmos para ter uma ideia básica sobre seu desempenho. Sempre é possível adotar estratégias avançadas para engenharia de recursos, ajuste de hiperparâmetros ou treinamento para melhorar o desempenho. Para ler mais sobre as funcionalidades que o scikit-learn oferece, acesse a documentação oficial - Introdução ao aprendizado de máquina com o scikit-learn, Machine Learning em Python com scikit-learn.
Yesha Shastri é um apaixonado desenvolvedor de IA e escritor com mestrado em Machine Learning pela Université de Montréal. Yesha está intrigada em explorar técnicas responsáveis de IA para resolver desafios que beneficiem a sociedade e compartilhar seus aprendizados com a comunidade.
- Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
- Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. Acesse aqui.
- Fonte: https://www.kdnuggets.com/getting-started-with-scikit-learn-for-classification-in-machine-learning.html?utm_source=rss&utm_medium=rss&utm_campaign=getting-started-with-scikit-learn-for-classification-in-machine-learning
- 1
- 10
- 100
- 67
- 77
- 84
- 9
- 98
- a
- Capaz
- Sobre
- absoluto
- precisão
- Alcançar
- adotar
- avançado
- AI
- algoritmo
- algoritmos
- já
- sempre
- e
- abordagem
- auto
- disponível
- basic
- beneficiar
- MELHOR
- Melhor
- Bootstrap
- construir
- construído
- desafios
- mudança
- Escolha
- aulas
- classificação
- agrupamento
- código
- geralmente
- comunidade
- integrações
- complexidades
- Considerar
- consistente
- Consistindo
- contém
- convertido
- dados,
- conjuntos de dados
- decisão
- diminuir
- Developer
- desenvolvedores
- diferente
- diferindo
- diretamente
- documentação
- cada
- Engenharia
- suficiente
- Éter (ETH)
- avaliar
- avaliadas
- experimentar
- explorar
- Característica
- poucos
- Finalmente
- Flexibilidade
- floresta
- amigável
- da
- funcionalidades
- mais distante
- ter
- obtendo
- ótimo
- Grade
- cabeça
- Alta
- Como funciona o dobrador de carta de canal
- Como Negociar
- HTML
- HTTPS
- Ajuste de hiperparâmetros
- idéia
- implementado
- importar
- melhorar
- in
- instalar
- integrar
- IT
- Guarda
- APRENDER
- aprendido
- aprendizagem
- Nível
- bibliotecas
- Biblioteca
- máquina
- aprendizado de máquina
- Macro
- FAZ
- mestre
- modelo
- modelos
- módulo
- mais
- a maioria
- múltiplo
- observar
- obtido
- Oferece
- oficial
- ONE
- parâmetro
- parâmetros
- apaixonado
- atuação
- realização
- executa
- platão
- Inteligência de Dados Platão
- PlatãoData
- popularidade
- Precisão
- Problema
- Produção
- Python
- Randomizado
- Leia
- representação
- responsável
- DESCANSO
- Resultados
- retorno
- uma conta de despesas robusta
- scikit-learn
- Pesquisar
- Partilhar
- Shows
- semelhante
- simples
- solteiro
- Sociedade
- RESOLVER
- alguns
- Espaço
- começado
- estratégias
- estrutura
- adequado
- ajuda
- técnicas
- teste
- ensaio
- A
- deles
- De terceiros
- Através da
- para
- Total
- Trem
- Training
- verdadeiro
- tutorial
- usar
- valor
- Valores
- vário
- qual
- precisarão
- escritor
- X
- zefirnet