Téléchargement de zipml - Téléchargement du code source zipml

zipml

Code Source AI

1.0.0

Télécharger

Zipml

ZIPML est une bibliothèque Automl légère conçue pour les petits ensembles de données, offrant des fonctions d'assistance essentielles comme la division des tests de train, la comparaison du modèle et la génération de matrice de confusion.

Caractéristiques

Formation automatisée du modèle : former et comparer automatiquement les modèles d'apprentissage automatique sur votre ensemble de données.
Fonctions d'assistance :
- Fonctionnalité de division des tests de train pour une gestion facile des données.
- Génération de matrice de confusion et la capacité de le sauver en PNG.
- Fonctionnalités de journalisation personnalisées pour un meilleur suivi des performances de votre modèle.
Comparaison du modèle : comparez les performances de différents modèles avec facilité, en fournissant des mesures et des commentaires visuels.
Prise en charge de la CLI : exécutez les tâches d'apprentissage automatique directement à partir de la ligne de commande.
Extensible : ajoutez vos propres modèles et personnalisez les workflows au besoin.
Outils de visualisation : comprend des outils pour visualiser les mesures de performances du modèle, aider à mieux comprendre le comportement du modèle.
Taping hyperparamètre : support du réglage de l'hyperparamètre pour optimiser les performances du modèle.
Prétraitement des données : étapes de prétraitement des données intégrées pour gérer les valeurs, l'échelle et le codage manquants.

Structure de package

zipml/
│
├── data/
│   ├── encoding.py
│   ├── file_operations.py
│   ├── split_data.py
│
├── model/
│   ├── analyze_model_predictions.py
│   ├── calculate_model_results.py
│   ├── measure_prediction_time.py
│
├── utils/
│   ├── calculate_sentence_length_percentile.py
│   ├── read_time_series_data.py
│
├── visualization/
│   ├── combine_and_plot_model_results.py
│   ├── plot_random_image.py
│   ├── plot_time_series.py
│   ├── save_and_plot_confusion_matrix.py
│
└── zipml.py

Comment utiliser le package `zipml`

Le package zipml fournit une variété d'utilitaires pour le prétraitement des données, l'analyse des modèles et la visualisation des résultats, tous conçus pour simplifier les flux de travail de l'IA et de l'apprentissage automatique. Vous trouverez ci-dessous les instructions pour utiliser certaines des fonctions clés.

1. Évaluation du modèle

analyze_model_predictions.py : évalue les prédictions du modèle en les comparant avec des valeurs réelles et renvoie un effrayage détaillé de prédictions ainsi que les prédictions les plus incorrectes.
```
 from zipml . model import analyze_model_predictions
val_df , most_wrong = analyze_model_predictions ( best_model , X_test , y_test )
```

Installation

Installez le package via PIP:

pip install zipml

Alternativement, cloner le référentiel:

git clone https://github.com/abdozmantar/zipml.git
cd zipml
pip install .

Usage

Exemple d'utilisation avec code

Voici un exemple pratique de la façon d'utiliser ZIPML:

 import pandas as pd
from zipml . model import analyze_model_predictions
from zipml . model import calculate_model_results
from zipml . visualization import save_and_plot_confusion_matrix
from zipml . data import split_data
from zipml import compare_models
from sklearn . ensemble import RandomForestClassifier , GradientBoostingClassifier
from sklearn . linear_model import LogisticRegression


# Sample dataset
data = {
    'feature_1' : [ 0.517 , 0.648 , 0.105 , 0.331 , 0.781 , 0.026 , 0.048 ],
    'feature_2' : [ 0.202 , 0.425 , 0.643 , 0.721 , 0.646 , 0.827 , 0.303 ],
    'feature_3' : [ 0.897 , 0.579 , 0.014 , 0.167 , 0.015 , 0.358 , 0.744 ],
    'feature_4' : [ 0.457 , 0.856 , 0.376 , 0.527 , 0.648 , 0.534 , 0.047 ],
    'feature_5' : [ 0.046 , 0.118 , 0.222 , 0.001 , 0.969 , 0.239 , 0.203 ],
    'target' : [ 0 , 1 , 1 , 1 , 1 , 1 , 0 ]
}

# Creating DataFrame
df = pd . DataFrame ( data )

# Splitting data into features (X) and target (y)
X = df . drop ( 'target' , axis = 1 )
y = df [ 'target' ]

# Split the data into training and test sets
X_train , X_test , y_train , y_test = split_data ( X , y )

# Define models
models = [
    RandomForestClassifier (),
    LogisticRegression (),
    GradientBoostingClassifier ()
]

# Compare models and select the best one
best_model , performance = compare_models ( models , X_train , X_test , y_train , y_test )
print ( f"Best model: { best_model } with performance: { performance } " )

# Calculate performance metrics for the best model
best_model_metrics = calculate_model_results ( y_test , best_model . predict ( X_test ))

# Analyze model predictions
val_df , most_wrong = analyze_model_predictions ( best_model , X_test , y_test )

# Save and plot confusion matrix
save_and_plot_confusion_matrix ( y_test , best_model . predict ( X_test ), save_path = "confusion_matrix.png" )

Utilisation de la CLI

Vous pouvez exécuter ZIPML à partir de la ligne de commande à l'aide des commandes suivantes:

Former un seul modèle

zipml --train train.csv --test test.csv --model randomforest --result results.json

--train : chemin vers le fichier CSV de l'ensemble de données de formation.
--test : chemin vers le fichier CSV de l'ensemble de données de test.
--model : nom du modèle à former (par exemple, randomforest , logisticregression , gradientboosting ).
--result : chemin vers le fichier JSON où les résultats seront enregistrés.

Comparez plusieurs modèles

zipml --train train.csv --test test.csv --compare --compare_models randomforest svc knn --result results.json

--compare : un drapeau pour indiquer une comparaison de modèles multiples.
--compare_models : une liste de modèles à comparer (par exemple, randomforest , logisticregression , gradientboosting ).
--result : chemin vers le fichier JSON où les résultats de comparaison seront enregistrés.

Chargez un modèle pré-formé et faites des prédictions

zipml --load_model trained_model.pkl --test test.csv --result predictions.json

--load_model : Chemin vers le fichier du modèle enregistré.
--test : chemin vers le fichier CSV de l'ensemble de données de test.
--result : chemin vers le fichier JSON où les prédictions seront enregistrées.

Enregistrer le modèle formé

Pour sauver le modèle qualifié après la formation:

zipml --train train.csv --test test.csv --model randomforest --save_model trained_model.pkl

--result : chemin vers le fichier où le modèle qualifié sera enregistré.

Sortir

La sortie des commandes de formation et de comparaison comprendra diverses mesures de performance telles que la précision, la précision, le rappel et le score F1.
Les résultats seront enregistrés au format JSON, ce qui les rend faciles à réviser et à analyser.