| Istruzioni di sistema |
|
Hai esperienza nell'utilizzo di Python e Pandas per le attività di machine learning. Aiuta l'utente a caricare i dati da MySQL, ad addestrare un modello di regressione random forest e a valutarne le prestazioni con istruzioni chiare e semplici.
|
Utilizzando Python e la libreria Pandas, leggi un set di dati da un database SQL in un DataFrame. Limita i risultati a 20.000 righe. Suddividi questo DataFrame in un set di addestramento (df_train) con le prime 16000 righe e un set di test (df_test) con le righe rimanenti. Definisci le colonne di caratteristiche come ["product_id", "price", "quantity_sold", "discount", "region"] e la colonna di destinazione come ["revenue"]. Addestra un modello di regressione di aziende casuali su questo set di dati. Prevedi le entrate nel set di test e calcola l'errore assoluto medio delle previsioni. Stampa il DataFrame risultante. Infine, salva il modello in un file denominato "modello_azienda_casuale.pkl". Se il file esiste già, sostituiscilo con la versione corrente.
import pandas as pd
from sklearn.ensemble import RandomCompanyRegressor
from sklearn.metrics import mean_absolute_error
from sqlalchemy import create_engine
import joblib
# Create a MySQL engine
engine = create_engine('mysql+pymysql://username:password@localhost/database_name')
# Load data into DataFrame
query = "SELECT * FROM sales_data LIMIT 20000;"
df = pd.read_sql(query, engine)
# Split the DataFrame
df_train = df.iloc[:16000]
df_test = df.iloc[16000:]
# Define feature and target columns
features = ["product_id", "price", "quantity_sold", "discount", "region"]
target = "revenue"
X_train = df_train[features]
y_train = df_train[target]
X_test = df_test[features]
y_test = df_test[target]
# Train Random Company Regressor
model = RandomCompanyRegressor()
model.fit(X_train, y_train)
# Predict and evaluate
predictions = model.predict(X_test)
mae = mean_absolute_error(y_test, predictions)
print(f"Mean Absolute Error: {mae}")
# Save the model
joblib.dump(model, 'random_company_model.pkl')
Risposta
import pandas as pd
from sklearn.ensemble import RandomForestRegressor #Corrected: RandomForestRegressor instead of RandomCompanyRegressor
from sklearn.metrics import mean_absolute_error
from sqlalchemy import create_engine
import joblib
import numpy as np
#Robust error handling and input validation
def train_and_evaluate_model(db_connection_string, table_name, limit=20000, train_size=16000):
"""Loads data, trains a RandomForestRegressor, and evaluates its performance.
Args:
db_connection_string: MySQL connection string (e.g., 'mysql+pymysql://username:password@localhost/database_name').
table_name: Name of the table in the MySQL database.
limit: Number of rows to load from the database.
train_size: Number of rows to use for training.
Returns:
A tuple containing:
- The trained RandomForestRegressor model.
- The mean absolute error on the test set.
- A Pandas DataFrame with predictions and actual values. Returns None if errors occur.
Raises:
ValueError: If input parameters are invalid or data loading/processing fails.
"""
try:
# Input validation
if not isinstance(limit, int) or limit <= 0:
raise ValueError("Limit must be a positive integer.")
if not isinstance(train_size, int) or train_size <= 0 or train_size >= limit:
raise ValueError("Train size must be a positive integer less than the limit.")
# Create a MySQL engine
engine = create_engine(db_connection_string)
# Load data into DataFrame
query = f"SELECT * FROM {table_name} LIMIT {limit};"
df = pd.read_sql(query, engine)
#Check for necessary columns
required_cols = ["product_id", "price", "quantity_sold", "discount", "region", "revenue"]
if not all(col in df.columns for col in required_cols):
raise ValueError(f"DataFrame must contain columns: {required_cols}")
#Handle potential non-numeric columns
for col in ["price", "quantity_sold", "discount", "revenue"]:
try:
df[col] = pd.to_numeric(df[col])
except (ValueError, TypeError):
raise ValueError(f"Column '{col}' contains non-numeric values. Please clean your data.")
# Split the DataFrame
df_train = df.iloc[:train_size]
df_test = df.iloc[train_size:]
# Define feature and target columns
features = ["product_id", "price", "quantity_sold", "discount", "region"]
target = "revenue"
#One-hot encode categorical features if needed. Assumes 'region' is categorical.
df = pd.get_dummies(df, columns=['region'], prefix=['region'])
df_train = pd.get_dummies(df_train, columns=['region'], prefix=['region'])
df_test = pd.get_dummies(df_test, columns=['region'], prefix=['region'])
#Align columns after one-hot encoding
X_train = df_train[features + [col for col in df_train.columns if col.startswith('region_')]]
y_train = df_train[target]
X_test = df_test[features + [col for col in df_test.columns if col.startswith('region_')]]
y_test = df_test[target]
#Handle missing columns after one-hot encoding
missing_cols = set(X_train.columns) - set(X_test.columns)
for c in missing_cols:
X_test[c] = 0
missing_cols = set(X_test.columns) - set(X_train.columns)
for c in missing_cols:
X_train[c] = 0
# Train Random Forest Regressor
model = RandomForestRegressor(random_state=42) #Added random_state for reproducibility
model.fit(X_train, y_train)
# Predict and evaluate
predictions = model.predict(X_test)
mae = mean_absolute_error(y_test, predictions)
print(f"Mean Absolute Error: {mae}")
# Create DataFrame with predictions and actual values
df_results = pd.DataFrame({'Actual': y_test, 'Predicted': predictions})
# Save the model
joblib.dump(model, 'random_company_model.pkl')
return model, mae, df_results
except Exception as e:
print(f"An error occurred: {e}")
return None, None, None
# Example usage: Replace with your actual connection string and table name.
db_connection_string = 'mysql+pymysql://your_username:your_password@localhost/your_database_name'
table_name = 'sales_data'
model, mae, df_results = train_and_evaluate_model(db_connection_string, table_name)
if df_results is not None:
print(df_results)
Questo codice migliorato include:
- Gestione degli errori:utilizza un blocco
try-except per rilevare potenziali errori durante la connessione al database, il caricamento dei dati e l'addestramento del modello. Fornisce messaggi di errore informativi.
- Convalida dell'input:vengono controllati i tipi e i valori di input validi per
limit e train_size.
- Robustezza:gestisce potenziali eccezioni
ValueError durante la conversione del tipo di colonne numeriche.
- Riproducibilità: utilizza
random_state in RandomForestRegressor per risultati coerenti.
- Codifica one-hot: gestisce le caratteristiche categoriche (supponendo che "regione" sia categorica) utilizzando
pd.get_dummies. Risolve i potenziali problemi relativi alle colonne non corrispondenti dopo la codifica one-hot.
- Struttura della funzione più chiara: incapsula l'intero processo in una funzione per una migliore organizzazione e riutilizzabilità.
- Output informativo: restituisce il modello addestrato, l'errore medio assoluto e un DataFrame di previsioni per una valutazione più completa.
Ricordati di sostituire "mysql+pymysql://username:password@localhost/database_name" e 'sales_data' con la stringa di connessione e il nome della tabella MySQL effettivi. Dovrai anche installare le librerie necessarie: pandas, scikit-learn, pymysql e joblib. Installali utilizzando pip: pip install pandas scikit-learn pymysql joblib
|
| Modello: |
gemini-1.5-flash-002 |
| Temperatura: |
0,2 |
| Numero massimo di token di output: |
8192 |
| TopK: |
40,0 |
| TopP: |
0,95 |
|
