DataScienceUtils
v1.8.0: New ROC and Precision-Recall Curves with Plotly! ?
Os utilitários de ciência de dados estendem a API Scikit-Learn e a API MatPlotlib para fornecer métodos simples que simplificam tarefas e visualizações para projetos de ciência de dados.
Vamos explorar alguns exemplos e saídas de código.
Você pode encontrar a documentação completa com todos os exemplos de código em: https://datascienceutils.readthedocs.io/en/latest/
Na documentação, você pode encontrar mais métodos e exemplos adicionais.
A API do pacote é criada para trabalhar com a API Scikit-Learn e a API Matplotlib. Aqui estão alguns dos recursos deste pacote:
Calcula e plota uma matriz de confusão, taxa falsa positiva, taxa falsa negativa, precisão e pontuação de F1 de uma classificação.
from ds_utils . metrics import plot_confusion_matrix
plot_confusion_matrix ( y_test , y_pred , [ 0 , 1 , 2 ])Recebe conjuntos de trens e testes e plota a alteração métrica fornecida com um número crescente de instâncias treinadas.
from ds_utils . metrics import plot_metric_growth_per_labeled_instances
from sklearn . tree import DecisionTreeClassifier
from sklearn . ensemble import RandomForestClassifier
plot_metric_growth_per_labeled_instances (
x_train , y_train , x_test , y_test ,
{
"DecisionTreeClassifier" : DecisionTreeClassifier ( random_state = 0 ),
"RandomForestClassifier" : RandomForestClassifier ( random_state = 0 , n_estimators = 5 )
}
)Recebe os rótulos verdadeiros e previsões de probabilidade de classificador, divide e classifica os resultados e, finalmente, plota um gráfico de barras empilhadas com os resultados. Código original
from ds_utils . metrics import visualize_accuracy_grouped_by_probability
visualize_accuracy_grouped_by_probability (
test [ "target" ],
1 ,
classifier . predict_proba ( test [ selected_features ]),
display_breakdown = False
)Sem quebra:
Com colapso:
Plote as curvas ROC com anotações limiares para vários classificadores, usando plotagem como back -end.
from ds_utils . metrics import plot_roc_curve_with_thresholds_annotations
classifiers_names_and_scores_dict = {
"Decision Tree" : tree_clf . predict_proba ( X_test )[:, 1 ],
"Random Forest" : rf_clf . predict_proba ( X_test )[:, 1 ],
"XGBoost" : xgb_clf . predict_proba ( X_test )[:, 1 ]
}
fig = plot_roc_curve_with_thresholds_annotations (
y_true ,
classifiers_names_and_scores_dict ,
positive_label = 1
)
fig . show ()Plote as curvas de precisão de precisão com anotações de limiar para vários classificadores, usando plotagem como back-end.
from ds_utils . metrics import plot_precision_recall_curve_with_thresholds_annotations
classifiers_names_and_scores_dict = {
"Decision Tree" : tree_clf . predict_proba ( X_test )[:, 1 ],
"Random Forest" : rf_clf . predict_proba ( X_test )[:, 1 ],
"XGBoost" : xgb_clf . predict_proba ( X_test )[:, 1 ]
}
fig = plot_precision_recall_curve_with_thresholds_annotations (
y_true ,
classifiers_names_and_scores_dict ,
positive_label = 1
)
fig . show ()Recebe um recurso e visualiza seus valores em um gráfico:
from ds_utils . preprocess import visualize_feature
visualize_feature ( X_train [ "feature" ])| Tipo de recurso | Trama |
|---|---|
| Flutuador | |
| Inteiro | |
| DateTime | |
| Categoria / objeto | |
| Booleano |
Calcule quais recursos estão correlacionados acima de um limite e extraia um quadro de dados com as correlações e correlação com o recurso de destino.
from ds_utils . preprocess import get_correlated_features
correlations = get_correlated_features ( train , features , target )| nível_0 | nível_1 | Level_0_Level_1_Corr | Level_0_target_corr | Level_1_target_corr |
|---|---|---|---|---|
| rendimento_category_low | rendimento_category_medium | 1.0 | 0,1182165609358650 | 0,11821656093586504 |
| Termo_ 36 meses | Termo_ 60 meses | 1.0 | 0,1182165609358650 | 0,11821656093586504 |
| Interes_payments_high | Interes_payments_low | 1.0 | 0,1182165609358650 | 0,11821656093586504 |
Calcule a correlação em pares de colunas, excluindo valores de Na/NULL e visualize -a com um mapa de calor. Código original
from ds_utils . preprocess import visualize_correlations
visualize_correlations ( data )Plote um dendrograma de uma matriz de correlação. Isso consiste em um gráfico que mostra hierarquicamente as variáveis mais correlacionadas pela conexão de árvores. Quanto mais perto da direita é, mais correlacionada os recursos são. Código original
from ds_utils . preprocess import plot_correlation_dendrogram
plot_correlation_dendrogram ( data )Plota a distribuição conjunta entre dois recursos:
from ds_utils . preprocess import plot_features_interaction
plot_features_interaction ( "feature_1" , "feature_2" , data )| Numérico | Categórico | Booleano | DateTime | |
|---|---|---|---|---|
| Numérico | ||||
| Categórico | ||||
| Booleano | ||||
| DateTime |
Este método extrai tags de um determinado campo e as anexa como novas colunas ao DataFrame.
Considere um conjunto de dados que se parece com o seguinte:
x_train :
| artigo_name | artigo_tags |
|---|---|
| 1 | DS, ML, DL |
| 2 | DS, ML |
x_test :
| artigo_name | artigo_tags |
|---|---|
| 3 | DS, ML, PY |
Usando este código:
import pandas as pd
from ds_utils . strings import append_tags_to_frame
x_train = pd . DataFrame ([{ "article_name" : "1" , "article_tags" : "ds,ml,dl" },
{ "article_name" : "2" , "article_tags" : "ds,ml" }])
x_test = pd . DataFrame ([{ "article_name" : "3" , "article_tags" : "ds,ml,py" }])
x_train_with_tags , x_test_with_tags = append_tags_to_frame ( x_train , x_test , "article_tags" , "tag_" )O resultado será:
x_train_with_tags :
| artigo_name | tag_ds | tag_ml | tag_dl |
|---|---|---|---|
| 1 | 1 | 1 | 1 |
| 2 | 1 | 1 | 0 |
x_test_with_tags :
| artigo_name | tag_ds | tag_ml | tag_dl |
|---|---|---|---|
| 3 | 1 | 1 | 0 |
Este método retorna ocorrências interessantes ou incomuns de termos em um subconjunto. É baseado na agregação Elasticsearch Significativa_text.
import pandas as pd
from ds_utils . strings import extract_significant_terms_from_subset
corpus = [ 'This is the first document.' , 'This document is the second document.' ,
'And this is the third one.' , 'Is this the first document?' ]
data_frame = pd . DataFrame ( corpus , columns = [ "content" ])
# Let's differentiate between the last two documents from the full corpus
subset_data_frame = data_frame [ data_frame . index > 1 ]
terms = extract_significant_terms_from_subset ( data_frame , subset_data_frame ,
"content" ) A saída para terms será a tabela a seguir:
| terceiro | um | e | esse | o | é | primeiro | documento | segundo |
|---|---|---|---|---|---|---|---|---|
| 1.0 | 1.0 | 1.0 | 0,67 | 0,67 | 0,67 | 0,5 | 0,25 | 0,0 |
Cardinalidade do cluster é o número de exemplos por cluster. Este método plota o número de pontos por cluster como um gráfico de barras.
import pandas as pd
from matplotlib import pyplot as plt
from sklearn . cluster import KMeans
from ds_utils . unsupervised import plot_cluster_cardinality
data = pd . read_csv ( path / to / dataset )
estimator = KMeans ( n_clusters = 8 , random_state = 42 )
estimator . fit ( data )
plot_cluster_cardinality ( estimator . labels_ )
plt . show ()A magnitude do cluster é a soma das distâncias de todos os exemplos para o centróide do cluster. Este método plota a distância total do ponto a centróide por cluster como um gráfico de barras.
import pandas as pd
from matplotlib import pyplot as plt
from sklearn . cluster import KMeans
from scipy . spatial . distance import euclidean
from ds_utils . unsupervised import plot_cluster_magnitude
data = pd . read_csv ( path / to / dataset )
estimator = KMeans ( n_clusters = 8 , random_state = 42 )
estimator . fit ( data )
plot_cluster_magnitude ( data , estimator . labels_ , estimator . cluster_centers_ , euclidean )
plt . show ()A cardinalidade mais alta tende a resultar em uma magnitude mais alta do cluster, que intuitivamente faz sentido. Os clusters são considerados anômalos quando a cardinalidade não se correlaciona com a magnitude em relação aos outros aglomerados. Este método ajuda a encontrar grupos anômalos, plotando magnitude contra a cardinalidade como um gráfico de dispersão.
import pandas as pd
from matplotlib import pyplot as plt
from sklearn . cluster import KMeans
from scipy . spatial . distance import euclidean
from ds_utils . unsupervised import plot_magnitude_vs_cardinality
data = pd . read_csv ( path / to / dataset )
estimator = KMeans ( n_clusters = 8 , random_state = 42 )
estimator . fit ( data )
plot_magnitude_vs_cardinality ( data , estimator . labels_ , estimator . cluster_centers_ , euclidean )
plt . show () O cluster de K-Means exige que você decida o número de clusters k com antecedência. Este método executa o algoritmo Kmeans e aumenta o número do cluster em cada iteração. A magnitude total ou a soma das distâncias é usada como métrica de perda.
Nota: Atualmente, esse método funciona apenas com sklearn.cluster.KMeans .
import pandas as pd
from matplotlib import pyplot as plt
from scipy . spatial . distance import euclidean
from ds_utils . unsupervised import plot_loss_vs_cluster_number
data = pd . read_csv ( path / to / dataset )
plot_loss_vs_cluster_number ( data , 3 , 20 , euclidean )
plt . show ()Esse método das parcelas apresenta importância como um gráfico de barras, ajudando a visualizar quais recursos têm o impacto mais significativo nas decisões do modelo.
import pandas as pd
from matplotlib import pyplot as plt
from sklearn . tree import DecisionTreeClassifier
from ds_utils . xai import plot_features_importance
# Load the dataset
data = pd . read_csv ( path / to / dataset )
target = data [ "target" ]
features = data . columns . tolist ()
features . remove ( "target" )
# Train a decision tree classifier
clf = DecisionTreeClassifier ( random_state = 42 )
clf . fit ( data [ features ], target )
# Plot feature importance
plot_features_importance ( features , clf . feature_importances_ )
plt . show ()Essa visualização ajuda a entender quais recursos são mais influentes no processo de tomada de decisão do modelo, fornecendo informações valiosas para a seleção de recursos e interpretação do modelo.
Animado com o que você viu até agora? Há ainda mais para descobrir! Mergulhe mais fundo em cada módulo para desbloquear todo o potencial do DataCienceUtils:
Métricas - Métodos poderosos para calcular e visualizar avaliação de desempenho do algoritmo. Obtenha informações sobre como seus modelos estão se saindo.
Pré -processo - Técnicas essenciais de pré -processamento de dados para preparar seus dados para treinamento. Melhore a entrada do seu modelo para obter melhores resultados.
Strings - Métodos eficientes para manipular e processamento de seqüências de dados em quadros de dados. Lidar com dados de texto com facilidade.
Ferramentas não supervisionadas para calcular e visualizar o desempenho de modelos não supervisionados. Entenda melhor seus resultados de agrupamento e redução de dimensionalidade.
XAI - Métodos para ajudar a explicar as decisões do modelo, tornando sua IA mais interpretável e confiável.
Cada módulo foi projetado para otimizar seu fluxo de trabalho de ciência de dados, fornecendo as ferramentas necessárias para pré -processar dados, treinar modelos, avaliar o desempenho e interpretar resultados. Confira a documentação detalhada de cada módulo para ver como o DataCienceUtils pode aprimorar seus projetos!
Estamos entusiasmados por você estar interessado em contribuir com os utilitários de ciência de dados! Suas contribuições ajudam a melhorar este projeto para todos. Seja você um desenvolvedor experiente ou apenas começando, há um lugar para você aqui.
Encontre uma área para contribuir : Confira nossa página de problemas para tarefas abertas ou pense em um recurso que você gostaria de adicionar.
Fork the Repository : faça sua própria cópia do projeto para trabalhar.
Crie uma filial : faça suas alterações em uma nova filial Git.
Faça suas alterações : adicione suas melhorias ou correções. Agradecemos:
Teste suas alterações : verifique se seu código funciona conforme o esperado e não apresente novos problemas.
Envie uma solicitação de tração : Abra um PR com um título claro e descrição de suas alterações.
Seguimos o Código de Conduta do Python Software Foundation e o Matplotlib Usage Guide. Por favor, siga essas diretrizes em suas contribuições.
Se você é novo para abrir o código aberto ou precisar de ajuda, não hesite em fazer perguntas na seção de problemas ou entrar em contato com os mantenedores. Estamos aqui para ajudar!
Lembre -se, nenhuma contribuição é muito pequena. Seja consertando um erro de digitação na documentação ou adicionando um recurso importante, todas as contribuições são valorizadas e apreciadas.
Obrigado por ajudar a melhorar a ciência dos dados para todos!
Aqui estão várias maneiras de instalar o pacote:
A maneira mais simples de instalar os utilitários de ciência de dados e suas dependências é do Pypi usando o PIP, o instalador de pacote preferido do Python:
pip install data-science-utilsPara atualizar os utilizadores de ciência de dados para a versão mais recente, use:
pip install -U data-science-utilsSe você preferir instalar a partir da fonte, poderá clonar o repositório e instalar:
git clone https://github.com/idanmoradarthas/DataScienceUtils.git
cd DataScienceUtils
pip install .Como alternativa, você pode instalar diretamente no GitHub usando o PIP:
pip install git+https://github.com/idanmoradarthas/DataScienceUtils.gitSe você estiver usando o Anaconda, pode instalar usando o CONDA:
conda install idanmorad::data-science-utilsA Data Science UTILS possui várias dependências, incluindo Numpy, Pandas, Matplotlib, Plotly e Scikit-Learn. Eles serão instalados automaticamente quando você instalar o pacote usando os métodos acima.
A Data Science UTILS é um projeto ativo que publica rotineiramente novos lançamentos com métodos e melhorias adicionais. Recomendamos verificar periodicamente as atualizações para acessar os recursos mais recentes e correções de bugs.
Se você encontrar algum problema durante a instalação, verifique nossa página de problemas do GitHub ou abra um novo problema para obter assistência.
