Download do zipml - Download do código fonte zipml

zipml

Código-Fonte de IA

1.0.0

Baixar

Zipml

O ZIPML é uma biblioteca leve Automl projetada para pequenos conjuntos de dados, oferecendo funções de auxiliar essencial, como divisão de teste de trem, comparação de modelos e geração de matriz de confusão.

Características

Treinamento do modelo automatizado : treine e compare automaticamente modelos de aprendizado de máquina no seu conjunto de dados.
Funções auxiliares :
- Funcionalidade dividida no teste de trem para fácil gerenciamento de dados.
- Geração da matriz de confusão e a capacidade de salvá -la como um PNG.
- Recursos de registro personalizados para melhor rastreamento do desempenho do seu modelo.
Comparação do modelo : compare o desempenho de diferentes modelos com facilidade, fornecendo métricas e feedback visual.
Suporte da CLI : Execute tarefas de aprendizado de máquina diretamente da linha de comando.
Extensible : adicione seus próprios modelos e personalize os fluxos de trabalho conforme necessário.
Ferramentas de visualização : inclui ferramentas para visualizar métricas de desempenho do modelo, ajudando a entender melhor o comportamento do modelo.
Ajuste hiperparâmetro : Suporte para ajuste hiperparâmetro para otimizar o desempenho do modelo.
Pré-processamento de dados : Etapas de pré-processamento de dados interno para lidar com valores ausentes, escala e codificação.

Estrutura do pacote

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

Como usar o pacote `zipml`

O pacote zipml fornece uma variedade de utilitários para pré -processamento de dados, analisando modelos e visualizando resultados, todos projetados para simplificar os fluxos de trabalho de IA e aprendizado de máquina. Abaixo estão as instruções para usar algumas das principais funções.

1. Avaliação do modelo

analyze_model_predictions.py : Avalia previsões do modelo, comparando -as com valores reais e retorna um quadro de dados detalhado de previsões junto com as previsões mais incorretas.
```
 from zipml . model import analyze_model_predictions
val_df , most_wrong = analyze_model_predictions ( best_model , X_test , y_test )
```

Instalação

Instale o pacote via PIP:

pip install zipml

Como alternativa, clone o repositório:

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

Uso

Exemplo de uso com código

Aqui está um exemplo prático de como usar o 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" )

Uso da CLI

Você pode executar o ZIPML na linha de comando usando os seguintes comandos:

Treinar um único modelo

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

--train : caminho para o arquivo CSV do conjunto de dados de treinamento.
--test : caminho para o arquivo CSV do conjunto de dados de teste.
--model : Nome do modelo a ser treinado (por exemplo, randomforest , logisticregression , gradientboosting ).
--result : caminho para o arquivo JSON, onde os resultados serão salvos.

Compare vários modelos

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

--compare : um sinalizador para indicar comparação de múltiplos modelos.
--compare_models : Uma lista de modelos a serem comparados (por exemplo, randomforest , logisticregression , gradientboosting ).
--result : caminho para o arquivo JSON, onde os resultados da comparação serão salvos.

Carregue um modelo pré-treinado e faça previsões

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

--load_model : caminho para o arquivo de modelo salvo.
--test : caminho para o arquivo CSV do conjunto de dados de teste.
--result : caminho para o arquivo JSON, onde as previsões serão salvas.

Salve o modelo treinado

Para salvar o modelo treinado após o treinamento:

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

--result : caminho para o arquivo em que o modelo treinado será salvo.

Saída

A saída dos comandos de treinamento e comparação incluirá várias métricas de desempenho, como precisão, precisão, recall e pontuação de F1.
Os resultados serão salvos no formato JSON, facilitando a revisão e análise.