modeloAgro.py

# Modelo Preditivo para Avaliação de Riscos no Agronegócio

## Visão Geral ###
"""
Este modelo preditivo tem como objetivo avaliar riscos para tomada de decisão de crédito
no agronegócio, considerando múltiplas variáveis como dados históricos de safras,
condições climáticas, preços de commodities e índices de inadimplência.
"""

## Arquitetura do Modelo

### 1. Coleta e Pré-processamento de Dados

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer


def preprocess_data(data):
    # Tratamento de valores ausentes
    imputer = SimpleImputer(strategy="median")
    data_imputed = imputer.fit_transform(data)

    # Normalização dos dados
    scaler = StandardScaler()
    data_scaled = scaler.fit_transform(data_imputed)

    return data_scaled, imputer, scaler


### 2. Engenharia de Features


def feature_engineering(df):

    # Dados históricos de safras
    result = (
        df.groupby(["ID_produtor"])
        .agg({"Producao_ton": "mean"})
        .rename(columns={"Producao_ton": "produtividade_media_5anos_ok"})
    )

    # df['produtividade_media_5anos'] = df[['safra_2019', 'safra_2020', 'safra_2021',
    #                                      'safra_2022', 'safra_2023']].mean(axis=1)

    df = df.merge(result, on="ID_produtor")

    df2019 = df[df["Ano"] == df["Ano"].min()][["ID_produtor", "Producao_ton"]].rename(
        columns={"Producao_ton": "safra2019"}
    )
    df2023 = df[df["Ano"] == df["Ano"].max()][["ID_produtor", "Producao_ton"]].rename(
        columns={"Producao_ton": "safra2023"}
    )

    df = df.merge(df2019, on="ID_produtor")
    df = df.merge(df2023, on="ID_produtor")

    df["variacao_produtividade_ok"] = df["safra2023"] / df["safra2019"] - 1

    # Dados climáticos - Evoluir com fonte meteriologica
    # df['deficit_hidrico'] = df['evapotranspiracao'] - df['precipitacao']

    # Dados econômicos - Evoluir com fonte reais
    # df['preco_commodity_ajustado'] = df['preco_commodity'] * df['taxa_cambio']

    # Inadimplência - Evoluir com fonte real
    # df['inadimplencia_media_setor'] = df.groupby('tipo_cultura')['inadimplencia'].transform('mean')

    return df


### 3. Modelo Preditivo (XGBoost com Explicabilidade)

import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score
import shap


class CreditRiskModel:
    def __init__(self):
        self.model = xgb.XGBClassifier(
            objective="binary:logistic",
            n_estimators=200,
            max_depth=5,
            learning_rate=0.1,
            subsample=0.8,
            colsample_bytree=0.8,
            random_state=42,
        )
        self.explainer = None

    def train(self, X_train, y_train):
        self.model.fit(X_train, y_train)
        # Criar explainer SHAP para interpretabilidade
        self.explainer = shap.TreeExplainer(self.model)

    def predict_proba(self, X):
        return self.model.predict_proba(X)[:, 1]

    def evaluate(self, X_test, y_test):
        y_pred = self.model.predict(X_test)
        y_proba = self.predict_proba(X_test)

        print(classification_report(y_test, y_pred))
        print(f"AUC-ROC: {roc_auc_score(y_test, y_proba):.4f}")

    def explain(self, X):
        if self.explainer:
            shap_values = self.explainer.shap_values(X)
            return shap_values
        else:
            raise Exception("Model not trained yet")


### 4. Pipeline Completo


def main():
    import shap

    # Carregar dados
    data = pd.read_csv("dados_agrocredito_5.csv")

    # Engenharia de features
    data = feature_engineering(data)

    # Definir variáveis
    features = [
        "ID_produtor",
        "produtividade_media_5anos_ok",
        "variacao_produtividade_ok",
        "Deficit_hidrico_mm",
        "Preco_commodity_ajustado",
        "Inadimplencia_media_setor",
        "Endividamento",
        "Area_plantada_ha",
        "Idade_produtor",
        "Score_credito",
    ]

    target = "inadimplente"  # 1 para inadimplente, 0 para bom pagador

    X = data[features]
    y = data[target]

    # Pré-processamento
    X_scaled, imputer, scaler = preprocess_data(X)

    # Dividir dados
    X_train, X_test, y_train, y_test = train_test_split(
        X_scaled, y, test_size=0.3, random_state=42, stratify=y
    )

    # Treinar modelo
    model = CreditRiskModel()
    model.train(X_train, y_train)

    # Avaliar
    model.evaluate(X_test, y_test)

    # Exemplo de interpretação
    sample_idx = 0
    shap_values = model.explain(X_test[sample_idx : sample_idx + 1])
    shap.force_plot(model.explainer.expected_value, shap_values[0], features)

    return model, imputer, scaler


def callMain():
    import pickle
    from sklearn.pipeline import Pipeline

    resultModel = main()

    pipeline = Pipeline(
        [
            ("model", resultModel[0]),
            ("imputer", resultModel[1]),
            ("scaler", resultModel[2]),
        ]
    )

    # Salvar todo o pipeline em um único arquivo
    with open("pipeline_modeloAgro.pkl", "wb") as f:
        pickle.dump(pipeline, f)


callMain()

## Variáveis Principais do Modelo

"""
1. **Variáveis Agronômicas**:
   - Produtividade histórica (5 anos)
   - Variação interanual de produtividade
   - Tipo de cultura/commodity
   - Área plantada

2. **Variáveis Climáticas**:
   - Precipitação acumulada
   - Déficit hídrico
   - Temperaturas médias
   - Eventos extremos (geadas, secas)

3. **Variáveis Econômicas**:
   - Preços de commodities (soja, milho, café, etc.)
   - Taxas de câmbio
   - Custos de insumos

4. **Variáveis de Crédito**:
   - Histórico de inadimplência
   - Endividamento do produtor
   - Score de crédito existente
   - Garantias oferecidas

"""

"""
## Implementação em Produção

#Para implementação em produção, recomenda-se:

#1. **API REST**:

from flask import Flask, request, jsonify
import joblib

app = Flask(__name__)

# Carregar modelo e pré-processadores
model, imputer, scaler = joblib.load('modelo_agrocredito.pkl')

@app.route('/predict', methods=['POST'])
def predict():
    data = request.json
    df = pd.DataFrame([data])
    
    # Pré-processamento
    X = df[features]
    X_imputed = imputer.transform(X)
    X_scaled = scaler.transform(X_imputed)
    
    # Predição
    proba = model.predict_proba(X_scaled)[0][1]
    risk_category = "Alto Risco" if proba > 0.7 else "Médio Risco" if proba > 0.3 else "Baixo Risco"
    
    # Explicação (opcional)
    explanation = model.explain(X_scaled)
    
    return jsonify({
        'probabilidade_inadimplencia': float(proba),
        'categoria_risco': risk_category,
        'explicacao': explanation.tolist()
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
"""

"""
2. **Monitoramento Contínuo**:
   - Re-treinamento periódico com novos dados
   - Monitoramento de drift de dados
   - Ajuste de limiares de decisão conforme políticas de crédito

## Considerações Finais

Este modelo oferece:
- Avaliação quantitativa de risco de crédito
- Explicabilidade das decisões (importante para conformidade regulatória)
- Capacidade de incorporar novos dados e variáveis
- Adaptabilidade para diferentes culturas e regiões

Recomenda-se validar o modelo com dados históricos antes da implementação em produção e ajustar os parâmetros conforme a política de risco da instituição financeira.
"""