DataScienceUtils
v1.8.0: New ROC and Precision-Recall Curves with Plotly! ?
Data Science Utils étend l'API Scikit-Learn et l'API Matplotlib pour fournir des méthodes simples qui simplifient les tâches et visualisations pour les projets de science des données.
Explorons quelques exemples et sorties de code.
Vous pouvez trouver la documentation complète avec tous les exemples de code à: https://datasmiceutils.readthedocs.io/en/latest/
Dans la documentation, vous pouvez trouver plus de méthodes et d'exemples supplémentaires.
L'API du package est conçue pour fonctionner avec l'API Scikit-Learn et l'API Matplotlib. Voici quelques-unes des capacités de ce package:
Calcule et trace une matrice de confusion, le taux de faux positifs, le taux de faux négatifs, la précision et le score F1 d'une classification.
from ds_utils . metrics import plot_confusion_matrix
plot_confusion_matrix ( y_test , y_pred , [ 0 , 1 , 2 ])Reçoit des ensembles de train et de tests et trace le changement métrique donné avec un nombre croissant d'instances formées.
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 )
}
)Reçoit des prévisions de probabilité de véritables étiquettes et des classificateurs de test, divise et classe les résultats, et trace enfin un graphique à barres empilé avec les résultats. Code d'origine
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
)Sans panne:
Avec panne:
Tracer les courbes ROC avec des annotations de seuil pour plusieurs classificateurs, en utilisant Plotly comme backend.
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 ()Tracer les courbes de recueil de précision avec des annotations de seuil pour plusieurs classificateurs, en utilisant Plotly comme backend.
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 ()Reçoit une fonctionnalité et visualise ses valeurs sur un graphique:
from ds_utils . preprocess import visualize_feature
visualize_feature ( X_train [ "feature" ])| Type de fonctionnalité | Parcelle |
|---|---|
| Flotter | |
| Entier | |
| DateTime | |
| Catégorie / objet | |
| Booléen |
Calculez quelles caractéristiques sont corrélées au-dessus d'un seuil et extraire un cadre de données avec les corrélations et la corrélation avec la caractéristique cible.
from ds_utils . preprocess import get_correlated_features
correlations = get_correlated_features ( train , features , target )| niveau_0 | niveau_1 | niveau_0_level_1_corr | niveau_0_target_corr | niveau_1_target_corr |
|---|---|---|---|---|
| revenu_category_low | revenu_category_medium | 1.0 | 0.1182165609358650 | 0.11821656093586504 |
| Terme_ 36 mois | Terme_ 60 mois | 1.0 | 0.1182165609358650 | 0.11821656093586504 |
| intérêt_payments_high | Interest_payments_low | 1.0 | 0.1182165609358650 | 0.11821656093586504 |
Calculez la corrélation par paire des colonnes, excluant les valeurs Na / NULL et visualisez-la avec une carte thermique. Code d'origine
from ds_utils . preprocess import visualize_correlations
visualize_correlations ( data )Tracer un dendrogramme d'une matrice de corrélation. Il s'agit d'un graphique qui montre hiérarchiquement les variables les plus corrélées par les arbres de connexion. Plus la connexion est proche, plus les fonctionnalités sont corrélées. Code d'origine
from ds_utils . preprocess import plot_correlation_dendrogram
plot_correlation_dendrogram ( data )Trace la distribution conjointe entre deux caractéristiques:
from ds_utils . preprocess import plot_features_interaction
plot_features_interaction ( "feature_1" , "feature_2" , data )| Numérique | Catégorique | Booléen | DateTime | |
|---|---|---|---|---|
| Numérique | ||||
| Catégorique | ||||
| Booléen | ||||
| DateTime |
Cette méthode extrait les balises d'un champ donné et les ajoute sous forme de nouvelles colonnes vers le DataFrame.
Considérez un ensemble de données qui ressemble à ceci:
x_train :
| Article_name | Article_tags |
|---|---|
| 1 | DS, ML, DL |
| 2 | DS, ML |
x_test :
| Article_name | Article_tags |
|---|---|
| 3 | DS, ML, PY |
Utilisation de ce code:
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_" )Le résultat sera:
x_train_with_tags :
| Article_name | tag_d | tag_ml | tag_dl |
|---|---|---|---|
| 1 | 1 | 1 | 1 |
| 2 | 1 | 1 | 0 |
x_test_with_tags :
| Article_name | tag_d | tag_ml | tag_dl |
|---|---|---|---|
| 3 | 1 | 1 | 0 |
Cette méthode renvoie des occurrences intéressantes ou inhabituelles de termes dans un sous-ensemble. Il est basé sur l'agrégation Elasticsearch significative_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" ) La sortie des terms sera le tableau suivant:
| troisième | un | et | ce | le | est | d'abord | document | deuxième |
|---|---|---|---|---|---|---|---|---|
| 1.0 | 1.0 | 1.0 | 0,67 | 0,67 | 0,67 | 0,5 | 0,25 | 0.0 |
La cardinalité du cluster est le nombre d'exemples par cluster. Cette méthode trace le nombre de points par cluster en tant que graphique à barres.
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 ()L'amplitude du cluster est la somme des distances de tous les exemples au centroïde du cluster. Cette méthode trace la distance totale point à centroïde par cluster en tant que graphique à barres.
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 ()Une cardinalité en grappe plus élevée a tendance à entraîner une amplitude de cluster plus élevée, ce qui a du sens intuitivement. Les grappes sont considérées comme anormales lorsque la cardinalité ne est pas en corrélation avec l'ampleur par rapport aux autres grappes. Cette méthode aide à trouver des grappes anormales en traçant l'ampleur contre la cardinalité comme tracé de dispersion.
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 () Le clustering K-Means vous oblige à décider du nombre de clusters k au préalable. Cette méthode exécute l'algorithme KMeans et augmente le numéro de cluster à chaque itération. L'amplitude totale ou la somme des distances est utilisée comme métrique de perte.
Remarque: Actuellement, cette méthode ne fonctionne qu'avec 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 ()Ces tracés de méthode présentent l'importance en tant que graphique à barres, aidant à visualiser les fonctionnalités qui ont l'impact le plus significatif sur les décisions du modèle.
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 ()Cette visualisation aide à comprendre les caractéristiques les plus influentes dans le processus de prise de décision du modèle, fournissant des informations précieuses pour la sélection des fonctionnalités et l'interprétation du modèle.
Excité par ce que vous avez vu jusqu'à présent? Il y a encore plus à découvrir! Plongez plus profondément dans chaque module pour déverrouiller le plein potentiel de DatascienceUtils:
Métriques - Méthodes puissantes pour calculer et visualiser l'évaluation des performances des algorithmes. Gardez un aperçu de la façon dont vos modèles fonctionnent.
Prétraitement - Techniques de prétraitement des données essentielles pour préparer vos données à la formation. Améliorez les entrées de votre modèle pour de meilleurs résultats.
Chaînes - Méthodes efficaces de manipulation et de traitement des chaînes dans les dataframes. Gérer facilement les données de texte.
Non supervisé - Outils pour calculer et visualiser les performances des modèles non supervisés. Comprenez mieux vos résultats de réduction du clustering et de la dimensionnalité.
XAI - Méthodes pour aider à expliquer les décisions du modèle, rendant votre IA plus interprétable et digne de confiance.
Chaque module est conçu pour rationaliser votre flux de travail de science des données, vous fournissant les outils dont vous avez besoin pour prétraiter les données, former des modèles, évaluer les performances et interpréter les résultats. Consultez la documentation détaillée pour chaque module pour voir comment DatascienceUtils peut améliorer vos projets!
Nous sommes ravis que vous soyez intéressé à contribuer aux Utils des sciences des données! Vos contributions aident à améliorer ce projet pour tout le monde. Que vous soyez un développeur chevronné ou que vous commenciez simplement, il y a une place pour vous ici.
Trouvez une zone à contribuer : consultez notre page de problèmes pour les tâches ouvertes, ou pensez à une fonctionnalité que vous souhaitez ajouter.
Fourk le référentiel : créez votre propre copie du projet sur lequel travailler.
Créez une branche : effectuez vos modifications dans une nouvelle branche GIT.
Faites vos modifications : ajoutez vos améliorations ou correctifs. Nous apprécions:
Testez vos modifications : assurez-vous que votre code fonctionne comme prévu et n'introduisez pas de nouveaux problèmes.
Soumettez une demande de traction : ouvrez un PR avec un titre clair et la description de vos modifications.
Nous suivons le code de conduite de la Fondation du logiciel Python et le guide d'utilisation Matplotlib. Veuillez respecter ces directives dans vos contributions.
Si vous êtes nouveau à l'open source ou si vous avez besoin d'aide, n'hésitez pas à poser des questions dans la section des problèmes ou à contacter les responsables. Nous sommes là pour aider!
N'oubliez pas qu'aucune contribution n'est trop petite. Qu'il s'agisse de réparer une faute de frappe dans la documentation ou d'ajouter une fonctionnalité majeure, toutes les contributions sont appréciées et appréciées.
Merci d'avoir contribué à améliorer les utilisateurs des sciences des données pour tout le monde!
Voici plusieurs façons d'installer le package:
Le moyen le plus simple d'installer les utils de science des données et ses dépendances provient de PYPI en utilisant PIP, le programme d'installation de package préféré de Python:
pip install data-science-utilsPour mettre à niveau les utilisation de la science des données vers la dernière version, utilisez:
pip install -U data-science-utilsSi vous préférez installer à partir de Source, vous pouvez cloner le référentiel et installer:
git clone https://github.com/idanmoradarthas/DataScienceUtils.git
cd DataScienceUtils
pip install .Alternativement, vous pouvez installer directement à partir de GitHub à l'aide de PIP:
pip install git+https://github.com/idanmoradarthas/DataScienceUtils.gitSi vous utilisez Anaconda, vous pouvez installer à l'aide de conda:
conda install idanmorad::data-science-utilsData Science Utils a plusieurs dépendances, notamment Numpy, Pandas, Matplotlib, Plotly et Scikit-Learn. Ceux-ci seront automatiquement installés lorsque vous installez le package à l'aide des méthodes ci-dessus.
Data Science Utils est un projet actif qui publie régulièrement de nouvelles versions avec des méthodes et des améliorations supplémentaires. Nous vous recommandons de vérifier périodiquement les mises à jour pour accéder aux dernières fonctionnalités et corrections de bogues.
Si vous rencontrez des problèmes lors de l'installation, veuillez consulter notre page GitHub Issues ou ouvrir un nouveau problème à l'aide.
