Phase 2: CLI Tools

import argparse
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from imblearn.combine import SMOTEENN
from loguru import logger
import os
import pandas as pd
import pickle

# Parse command-line arguments
parser = argparse.ArgumentParser()
parser.add_argument('--data_file', required=True, type=str, help='a csv file with train data')
parser.add_argument('--model_file', required=True, type=str, help='where the trained model will be stored')
parser.add_argument('--overwrite_model', default=False, action='store_true', help='if sets overwrites the model file if it exists')

args = parser.parse_args()

model_file = args.model_file
data_file = args.data_file
overwrite = args.overwrite_model

# Check if model file already exists
if os.path.isfile(model_file):
    if overwrite:
        logger.info(f"overwriting existing model file {model_file}")
    else:
        logger.info(f"model file {model_file} exists. exitting. use --overwrite_model option")
        exit(-1)

# Load training data
logger.info("loading train data")
z = pd.read_csv(data_file)

# Encode training data
logger.info("encoding train data")
gender_dict = {'Female': 0, 'Male': 1, 'Other': 2}
smoking_history_dict = {'No Info': 0, 'current': 1, 'ever': 2, 'former': 3, 'never': 4, 'not current': 5}
z = z.replace({'gender': gender_dict, 'smoking_history': smoking_history_dict})

# Separate features and labels
Xtr = z.drop('diabetes', axis=1)
ytr = z[['diabetes']]

# Scale training data
logger.info("scaling train data")
scaler = StandardScaler()
Xtr = scaler.fit_transform(Xtr)

# Apply oversampling and undersampling with SMOTEENN
smote_enn = SMOTEENN(random_state=42)
Xtr, ytr = smote_enn.fit_resample(Xtr, ytr)

# Train the model
logger.info("fitting model")
m = RandomForestClassifier()
m.fit(Xtr, ytr)

# Save model to file
logger.info(f"saving model to {model_file}")
with open(model_file, "wb") as f:
    pickle.dump(m, f)

import argparse
import numpy as np
from loguru import logger
from sklearn.preprocessing import StandardScaler
import os
import pandas as pd
import pickle

# Parse command-line arguments
parser = argparse.ArgumentParser()
parser.add_argument('--input_file', required=True, type=str, help='a csv file with input data (no targets)')
parser.add_argument('--predictions_file', required=True, type=str, help='a csv file where predictions will be saved to')
parser.add_argument('--model_file', required=True, type=str, help='a pkl file with a model already stored (see train.py)')

args = parser.parse_args()

model_file = args.model_file
input_file = args.input_file
predictions_file = args.predictions_file

# Verify model file exists
if not os.path.isfile(model_file):
    logger.error(f"model file {model_file} does not exist")
    exit(-1)

# Verify input file exists
if not os.path.isfile(input_file):
    logger.error(f"input file {input_file} does not exist")
    exit(-1)

# Load input data
logger.info("loading input data")
Xts = pd.read_csv(input_file)

# Encode input data
logger.info("encoding data")
gender_dict = {'Female': 0, 'Male': 1, 'Other': 2}
smoking_history_dict = {'No Info': 0, 'current': 1, 'ever': 2, 'former': 3, 'never': 4, 'not current': 5}
Xts = Xts.replace({'gender': gender_dict, 'smoking_history': smoking_history_dict})

# Scale input data
logger.info("scaling data")
scaler = StandardScaler()
Xts = scaler.fit_transform(Xts)

# Load model
logger.info("loading model")
with open(model_file, 'rb') as f:
    m = pickle.load(f)

# Make predictions
logger.info("making predictions")
preds = m.predict(Xts)

# Save predictions to file
logger.info(f"saving predictions to {predictions_file}")
pd.DataFrame(preds.reshape(-1,1), columns=['preds']).to_csv(predictions_file, index=False)

# Select Python base image
FROM python:3.12

# Set working directory
WORKDIR /app

# Copy necessary files to application directory
ADD train.py /app
ADD predict.py /app
ADD requirements.txt /app

# Install dependencies
RUN pip install --no-cache-dir -r requirements.txt

#!/bin/bash

# Build image
docker build -t ai-proyecto-sustituto .

# Run container
docker run -d --name ai-container ai-proyecto-sustituto sleep infinity

# Copy data files
docker cp train.csv ai-container:/app
docker cp test.csv ai-container:/app

# Train model
docker exec ai-container python train.py \
  --model_file model.pkl \
  --data_file train.csv \
  --overwrite_model

# Make predictions
docker exec ai-container python predict.py \
  --model_file model.pkl \
  --input_file test.csv \
  --predictions_file predictions.csv

# Copy results
docker cp ai-container:/app/predictions.csv ./results/

# Cleanup
docker stop ai-container
docker rm ai-container