DataScienceUtils
v1.8.0: New ROC and Precision-Recall Curves with Plotly! ?
Data Science Utils extiende la API Scikit-Learn y la API Matplotlib para proporcionar métodos simples que simplifiquen tareas y visualizaciones para proyectos de ciencia de datos.
Exploremos algunos ejemplos y salidas de código.
Puede encontrar la documentación completa con todos los ejemplos de código en: https://datascienceutils.readthedocs.io/en/latest/
En la documentación, puede encontrar más métodos y ejemplos adicionales.
La API del paquete está construida para funcionar con la API Scikit-Learn y la API Matplotlib. Estas son algunas de las capacidades de este paquete:
Calcula y traza una matriz de confusión, tasa de falsos positivos, tasa de falsos negativos, precisión y puntaje F1 de una clasificación.
from ds_utils . metrics import plot_confusion_matrix
plot_confusion_matrix ( y_test , y_pred , [ 0 , 1 , 2 ])Recibe conjuntos de trenes y pruebas, y traza el cambio métrico dado con un número creciente de instancias entrenadas.
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 )
}
)Recibe las etiquetas verdaderas de prueba y las predicciones de probabilidad del clasificador, divide y clasifica los resultados, y finalmente traza un gráfico de barras apilado con los 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
)Sin desglose:
Con desglose:
Trazar las curvas ROC con anotaciones umbral para múltiples clasificadores, usando Plotly como un 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 ()Trazar las curvas de recolección de precisión con anotaciones de umbral para múltiples clasificadores, usando Plotly como 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 ()Recibe una característica y visualiza sus valores en un gráfico:
from ds_utils . preprocess import visualize_feature
visualize_feature ( X_train [ "feature" ])| Tipo de característica | Trama |
|---|---|
| Flotar | |
| Entero | |
| De fecha y hora | |
| Categoría / objeto | |
| Booleano |
Calcule qué características se correlacionan por encima de un umbral y extraen un marco de datos con las correlaciones y la correlación con la función de destino.
from ds_utils . preprocess import get_correlated_features
correlations = get_correlated_features ( train , features , target )| nivel_0 | nivel_1 | nivel_0_level_1_corr | nivel_0_target_corr | nivel_1_target_corr |
|---|---|---|---|---|
| ingreso_category_low | ingreso_category_medium | 1.0 | 0.1182165609358650 | 0.11821656093586504 |
| Term_ 36 meses | término_ 60 meses | 1.0 | 0.1182165609358650 | 0.11821656093586504 |
| intereses_payments_high | intereses_payments_low | 1.0 | 0.1182165609358650 | 0.11821656093586504 |
Calcule la correlación por pares de las columnas, excluyendo los valores de Na/Null, y visualícelo con un mapa de calor. Código original
from ds_utils . preprocess import visualize_correlations
visualize_correlations ( data )Traza un dendrograma de una matriz de correlación. Esto consiste en un gráfico que muestra jerárquicamente las variables que se correlacionan más por la conexión de árboles. Cuanto más cerca de la derecha esté, más correlacionadas están las características. Código original
from ds_utils . preprocess import plot_correlation_dendrogram
plot_correlation_dendrogram ( data )Traza la distribución de la junta entre dos características:
from ds_utils . preprocess import plot_features_interaction
plot_features_interaction ( "feature_1" , "feature_2" , data )| Numérico | Categórico | Booleano | De fecha y hora | |
|---|---|---|---|---|
| Numérico | ||||
| Categórico | ||||
| Booleano | ||||
| De fecha y hora |
Este método extrae etiquetas de un campo determinado y las agrega como nuevas columnas para DataFrame.
Considere un conjunto de datos que se vea así:
x_train :
| artículo_name | artículo_tags |
|---|---|
| 1 | DS, ML, DL |
| 2 | DS, ML |
x_test :
| artículo_name | artículo_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_" )El resultado será:
x_train_with_tags :
| artículo_name | Tag_ds | tag_ml | tag_dl |
|---|---|---|---|
| 1 | 1 | 1 | 1 |
| 2 | 1 | 1 | 0 |
x_test_with_tags :
| artículo_name | Tag_ds | tag_ml | tag_dl |
|---|---|---|---|
| 3 | 1 | 1 | 0 |
Este método devuelve ocurrencias de términos interesantes o inusuales en un subconjunto. Se basa en la agregación ElasticseCearch 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" ) La salida para terms será la siguiente tabla:
| tercero | uno | y | este | el | es | primero | documento | segundo |
|---|---|---|---|---|---|---|---|---|
| 1.0 | 1.0 | 1.0 | 0.67 | 0.67 | 0.67 | 0.5 | 0.25 | 0.0 |
La cardinalidad del clúster es el número de ejemplos por clúster. Este método traza el número de puntos por clúster como 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 ()La magnitud del clúster es la suma de distancias de todos los ejemplos al centroide del clúster. Este método traza la distancia total de punto a centroide por clúster como 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 ()La cardinalidad de racimo más alta tiende a dar como resultado una mayor magnitud del clúster, lo que intuitivamente tiene sentido. Los grupos se consideran anómalos cuando la cardinalidad no se correlaciona con la magnitud en relación con los otros grupos. Este método ayuda a encontrar grupos anómalos trazando la magnitud contra la cardinalidad como una parcela de dispersión.
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 () La agrupación de K-means requiere que decida el número de grupos k de antemano. Este método ejecuta el algoritmo Kmeans y aumenta el número de clúster en cada iteración. La magnitud total o suma de distancias se usa como métrica de pérdida.
Nota: Actualmente, este método solo funciona con 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 ()Este método traza importancia como un gráfico de barras, lo que ayuda a visualizar qué características tienen el impacto más significativo en las decisiones del 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 ()Esta visualización ayuda a comprender qué características son más influyentes en el proceso de toma de decisiones del modelo, proporcionando ideas valiosas para la selección de características e interpretación del modelo.
¿Emocionado por lo que has visto hasta ahora? ¡Hay aún más por descubrir! Sumerja más profundamente en cada módulo para desbloquear todo el potencial de DataScienceUtils:
Métricas: métodos poderosos para calcular y visualizar la evaluación del rendimiento del algoritmo. Obtenga información sobre cómo funcionan sus modelos.
Preprocesos: técnicas de preprocesamiento de datos esenciales para preparar sus datos para la capacitación. Mejore la entrada de su modelo para obtener mejores resultados.
Cadenas: métodos eficientes para manipular y procesar cadenas en marcos de datos. Manejar los datos de texto con facilidad.
Sin supervisión: herramientas para calcular y visualizar el rendimiento de los modelos no supervisados. Comprenda mejor sus resultados de reducción de agrupación y dimensionalidad.
XAI - Métodos para ayudar a explicar las decisiones del modelo, haciendo que su IA sea más interpretable y confiable.
Cada módulo está diseñado para optimizar su flujo de trabajo de ciencia de datos, proporcionándole las herramientas que necesita para preprocesar datos, capacitar modelos, evaluar el rendimiento e interpretar los resultados. ¡Consulte la documentación detallada de cada módulo para ver cómo DataScienceUtils puede mejorar sus proyectos!
¡Estamos encantados de que estés interesado en contribuir a los utilidades de ciencia de datos! Sus contribuciones ayudan a mejorar este proyecto para todos. Ya sea que sea un desarrollador experimentado o simplemente comience, hay un lugar para usted aquí.
Encuentre un área para contribuir a : consulte nuestra página de problemas para obtener tareas abiertas o piense en una característica que desea agregar.
Bifurca el repositorio : haga su propia copia del proyecto para trabajar.
Crea una rama : haga tus cambios en una nueva rama Git.
Haga sus cambios : agregue sus mejoras o correcciones. Apreciamos:
Pruebe sus cambios : asegúrese de que su código funcione como se esperaba y no introduce nuevos problemas.
Envíe una solicitud de extracción : abra un PR con un título claro y una descripción de sus cambios.
Seguimos el Código de Conducta de Python Software Foundation y la Guía de uso de Matplotlib. Adhiera estas pautas en sus contribuciones.
Si es nuevo en el código abierto o necesita ayuda, no dude en hacer preguntas en la sección de problemas o comunicarse con los mantenedores. ¡Estamos aquí para ayudar!
Recuerde, ninguna contribución es demasiado pequeña. Ya sea que esté arreglando un error tipográfico en la documentación o agregando una característica importante, todas las contribuciones se valoran y aprecian.
¡Gracias por ayudar a hacer que la ciencia de datos utilice mejor para todos!
Aquí hay varias formas de instalar el paquete:
La forma más sencilla de instalar Data Science Utils y sus dependencias es de PYPI utilizando el instalador de paquetes preferidos de PIP, Python:
pip install data-science-utilsPara actualizar la ciencia de datos utiliza la última versión, use:
pip install -U data-science-utilsSi prefiere instalar desde la fuente, puede clonar el repositorio e instalar:
git clone https://github.com/idanmoradarthas/DataScienceUtils.git
cd DataScienceUtils
pip install .Alternativamente, puede instalar directamente desde GitHub usando PIP:
pip install git+https://github.com/idanmoradarthas/DataScienceUtils.gitSi está utilizando Anaconda, puede instalar con Conda:
conda install idanmorad::data-science-utilsData Science Utils tiene varias dependencias, incluidas Numpy, Pandas, Matplotlib, Plotly y Scikit-Learn. Estos se instalarán automáticamente cuando instale el paquete utilizando los métodos anteriores.
Data Science Utils es un proyecto activo que publica de manera rutinaria nuevas lanzamientos con métodos y mejoras adicionales. Recomendamos verificar periódicamente las actualizaciones para acceder a las últimas funciones y correcciones de errores.
Si encuentra algún problema durante la instalación, consulte nuestra página de problemas de GitHub o abra un nuevo problema para obtener ayuda.
