app.py

import gradio as gr
import pandas as pd
import numpy as np
from itertools import product
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

# Funções para transformar as variáveis
def apply_transformation(data, transformation):
    # Evita transformação exponencial se houver valores altos
    if transformation == "exp" and (data > 50).any():
        return data  # Mantém como "direct" se valores forem muito altos
    
    if transformation == "direct":
        return data
    elif transformation == "inverse":
        return 1 / (data + 0.001)  # Adiciona um valor pequeno para evitar divisão por zero
    elif transformation == "log":
        return np.log(data + 0.001)  # Adiciona um valor pequeno para evitar log(0)
    elif transformation == "exp":
        return np.exp(data)

# Função principal para encontrar a melhor combinação de transformações
def find_best_transformations(file):
    # Carrega o arquivo Excel e separa variáveis independentes e dependentes
    df = pd.read_excel(file.name, engine='openpyxl')
    
    # Remove linhas com valores ausentes
    df = df.dropna()
    
    X = df.iloc[:, :-1]
    y = df.iloc[:, -1]

    # Definições de transformações e combinações
    transformations = ["direct", "inverse", "log", "exp"]
    best_score = -np.inf
    best_combination = None
    best_model = None

    # Testa todas as combinações possíveis de transformações
    for transformation_combo in product(transformations, repeat=X.shape[1]):
        X_transformed = X.copy()
        
        # Aplicar transformações
        for i, transformation in enumerate(transformation_combo):
            column = X.iloc[:, i]
            
            # Condição para variáveis dicotômicas
            if set(column.unique()).issubset({0, 1}):  # Verifica se a variável é dicotômica
                if transformation in ["inverse", "log", "exp"]:
                    X_transformed.iloc[:, i] = column  # Mantém como "direct" se for dicotômica
                else:
                    X_transformed.iloc[:, i] = apply_transformation(column, transformation)
            else:
                X_transformed.iloc[:, i] = apply_transformation(column, transformation)

        # Treina o modelo de regressão linear
        model = LinearRegression()
        model.fit(X_transformed, y)
        
        # Calcula o R2_Score
        predictions = model.predict(X_transformed)
        score = r2_score(y, predictions)

        # Atualiza a melhor combinação e modelo se o R2_Score for maior
        if score > best_score:
            best_score = score
            best_combination = transformation_combo
            best_model = model

    # Retorna os resultados
    equation = f"y = {best_model.intercept_:.4f} " + " + ".join(
        [f"({coef:.4f}) * {trans}" for coef, trans in zip(best_model.coef_, X.columns)]
    )
    transformation_info = dict(zip(X.columns, best_combination))

    return {
        "Equação": equation,
        "Transformações": transformation_info,
        "R2_Score": best_score,
    }

# Configuração da interface Gradio
iface = gr.Interface(
    fn=find_best_transformations,
    inputs=gr.File(label="Arquivo Excel"),
    outputs=[
        gr.Textbox(label="Equação"),
        gr.JSON(label="Transformações Aplicadas"),
        gr.Number(label="R2_Score")
    ],
    title="Modelo de Regressão com Transformações Variáveis",
    description="Carregue um arquivo Excel com variáveis independentes e uma variável dependente na última coluna. O app testa combinações de transformações para maximizar o R2_Score."
)

# Executa a interface Gradio com link público
iface.launch(share=True)