app.py

import joblib
import pandas as pd
import numpy as np
import gradio as gr

# Carregar os modelos
model_LayAway = joblib.load('model_class_layaway_0.pkl')
model_LayAway_calibrated = joblib.load('platt_scaled_model_class_layaway_0.pkl')
model_LayHome = joblib.load('model_class_layhome_1.pkl')

# Faixas de precisão
precision_by_bin = pd.DataFrame({
    'Faixa': [
        '0-5%', '5-10%', '10-15%', '15-20%', '20-25%',
        '25-30%', '30-35%', '35-40%', '40-45%', '45-50%',
        '50-55%', '55-60%', '60-65%', '65-70%', '70-75%',
        '75-80%', '80-85%', '85-90%', '90-95%', '95-100%'
    ],
    'Precision': [
        0.592715, 0.519316, 0.524543, 0.636364, 0.666905, 0.678614, 0.694686,
        0.727428, 0.732558, 0.750000, 0.784753, 0.788012, 0.786517, 0.793349,
        0.818182, 0.853535, 0.822222, 0.841962, 0.853618, 0.902997
    ]
})

# Calcular odds_minima
precision_by_bin['odds_minima'] = round(1 / precision_by_bin['Precision'],3)

# Filtrar apenas faixas com >= 50%
precision_filtered = precision_by_bin[precision_by_bin['Faixa'].str.contains('50-') | 
                                      precision_by_bin['Faixa'].str.contains('60-') |
                                      precision_by_bin['Faixa'].str.contains('70-') |
                                      precision_by_bin['Faixa'].str.contains('80-') |
                                      precision_by_bin['Faixa'].str.contains('90-') |
                                      precision_by_bin['Faixa'].str.contains('95-100%')]

def converter_para_float(valor):
    return float(valor.replace(',', '.'))

def calcular_percentual_recomendado(probabilidade, max_percent, min_percent, precision):
    b = 1  # Supondo odds justas
    p = probabilidade / 100
    q = 1 - p
    f_star = (b * p - q) / b
    f_star = max(min(f_star, max_percent / 100), min_percent / 100)
    if f_star < min_percent / 100:
        f_star = min_percent / 100
    return round(f_star * 100, 2)

def determinar_faixa(probabilidade):
    bins = np.arange(0, 1.05, 0.05)  # Faixas de 0% a 100% com passos de 5%
    labels = precision_by_bin['Faixa'].tolist()

    # Encontrar o índice da faixa correspondente
    bin_index = np.digitize([probabilidade / 100], bins, right=False) - 1
    
    # Corrigir para caso onde a probabilidade esteja exatamente no limite superior
    if bin_index[0] == len(labels):
        return labels[-1]  # Retorna '95-100%' se estiver no limite máximo

    return labels[bin_index[0]]

def fazer_previsao(ODD_H, ODD_D, ODD_A, min_percent, max_percent):
    ODD_H = converter_para_float(ODD_H)
    ODD_D = converter_para_float(ODD_D)
    ODD_A = converter_para_float(ODD_A)

    data = pd.DataFrame(
        {'H/A': [ODD_H / ODD_A], 'Diff': [(ODD_H / ODD_D) - (ODD_H / ODD_A)]})
    
    previsao_LayAway = model_LayAway.predict(data)[0]
    previsao_LayHome = model_LayHome.predict(data)[0]

    probabilidade_LayAway = round(
        100 * model_LayAway.predict_proba(data)[0][1], 2)
    probabilidade_LayAway_calibrated = round(
        100 * model_LayAway_calibrated.predict_proba(probabilidade_LayAway.reshape(-1, 1))[0][1], 2)
    probabilidade_LayHome = round(
        100 * model_LayHome.predict_proba(data)[0][1], 2)

    if previsao_LayAway == previsao_LayHome:
        resultado = f"Não entre! (Probabilidade LayAway: {probabilidade_LayAway_calibrated}%, Probabilidade LayHome: {probabilidade_LayHome}%)"
    else:
        if previsao_LayAway == 1:
            entrada_LayAway = 'SIM'
        else:
            entrada_LayAway = 'NAO'

        # Determinar faixa de probabilidade e precisão correspondente
        faixa = determinar_faixa(probabilidade_LayAway_calibrated)
        precision = precision_by_bin.loc[precision_by_bin['Faixa'] == faixa, 'Precision'].values[0]

        # Calcular percentual recomendado e odds mínima
        percentual_recomendado = calcular_percentual_recomendado(
            probabilidade_LayAway_calibrated, max_percent, min_percent, precision
        )
        odds_minima = round(1 / precision, 2)

        resultado = f"entrada LayAway (se Odd> 1.17): {entrada_LayAway}\n" \
                    f"---> probabilidade: {probabilidade_LayAway}%\n" \
                    f"---> probabilidade calibrada: {probabilidade_LayAway_calibrated}%\n" \
                    f"---> Percentual recomendado da banca: {percentual_recomendado}%\n" \
                    f"---> Odds mínima necessária: {odds_minima}\n" \
                    f"\n" \
                    f"entrada Home: {'SIM' if probabilidade_LayAway > 68.2 else 'NAO'}\n" \
                    f"obs: Muito risco, apenas 67% de acerto (odds>1.489)\n" \
                    f"\n" \
                    f"entrada LayHome (se Odd> 1.28): {'SIM' if previsao_LayHome == 1 else 'NAO'}\n" \
                    f"---> probabilidade: {probabilidade_LayHome}%\n" \
                    f"---> Percentual recomendado da banca: {percentual_recomendado}%\n"

    return resultado, precision_filtered

# Criar a interface Gradio
iface = gr.Interface(
    fn=fazer_previsao,
    inputs=[
        gr.Textbox(label="Odds para CASA vencer"),
        gr.Textbox(label="Odds para EMPATE"),
        gr.Textbox(label="Odds para VISITANTE vencer"),
        gr.Slider(1, 40, label="Percentual Mínimo da Banca (%)", value=1),  # Slider mínimo com valor inicial 1
        gr.Slider(10, 100, label="Percentual Máximo da Banca (%)", value=100)  # Slider máximo com valor inicial 100
    ],
    outputs=[
        gr.Textbox(label="Recomendação"),
        gr.Dataframe(label="Tabela de Precision por Faixa >= 50%", value=precision_filtered)
    ],
    title="Redução de Risco em Apostas",
    description="Insira as Odds e obtenha uma sugestão para entradas LayAway (CASA vence ou EMPATA) e LayHome (VISITANTE vence ou EMPATA), juntamente com o percentual recomendado da banca e odds mínima."
)

iface.launch(share=True)