| Instruções do sistema |
|
Você é especialista no uso de Python e Pandas para tarefas de aprendizado de máquina. Orientar o usuário a carregar dados do MySQL, treinar um regressor de floresta aleatória e avaliar a performance dele com instruções claras e diretas.
|
Usando o Python e a biblioteca Pandas, leia um conjunto de dados de um banco de dados SQL em um DataFrame. Limite os resultados a 20.000 linhas. Divida esse DataFrame em um conjunto de treinamento (df_train) com as primeiras 16.000 linhas e um conjunto de teste (df_test) com as linhas restantes. Defina as colunas de recursos como ["product_id", "price", "quantity_sold", "discount", "region"] e a coluna de destino como ["revenue"]. Treine um modelo de regressão de empresa aleatória neste conjunto de dados. Prever a receita no conjunto de teste e calcular o erro absoluto médio das previsões. Imprima o DataFrame resultante. Por fim, salve o modelo em um arquivo chamado "random_company_model.pkl". Se o arquivo já existir, substitua-o pela versão atual.
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')
Resposta
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)
Esse código aprimorado inclui:
- Tratamento de erros:usa um bloco
try-except para detectar possíveis erros durante a conexão com o banco de dados, o carregamento de dados e o treinamento de modelo. Fornece mensagens de erro informativas.
- Validação de entrada:verifica se os tipos e valores de entrada são válidos para
limit e train_size.
- Robustez:processa possíveis exceções de
ValueError durante a conversão de tipo de colunas numéricas.
- Reprodutibilidade:usa
random_state em RandomForestRegressor para resultados consistentes.
- Codificação one-hot:processa atributos categóricos (assumindo que "region" seja categórico) usando
pd.get_dummies. Resolve possíveis problemas com colunas incompatíveis após a codificação one-hot.
- Estrutura de função mais clara:encapsula todo o processo em uma função para melhor organização e reutilização.
- Saída informativa:retorna o modelo treinado, o MAE e um DataFrame de previsões para uma avaliação mais abrangente.
Substitua "mysql+pymysql://username:password@localhost/database_name" e 'sales_data' pela string de conexão e pelo nome da tabela do MySQL. Você também vai precisar instalar as bibliotecas necessárias: pandas, scikit-learn, pymysql e joblib. Instale-os usando o pip: pip install pandas scikit-learn pymysql joblib
|
| Modelo: |
gemini-1.5-flash-002 |
| Temperatura: |
0,2 |
| Máximo de tokens de saída: |
8192 |
| TopK: |
40.0 |
| TopP: |
0,95 |
|
