File size: 4,822 Bytes
9a69862
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
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 = {
    '0-5%': 0.592715,
    '5-10%': 0.519316,
    '10-15%': 0.524543,
    '15-20%': 0.636364,
    '20-25%': 0.666905,
    '25-30%': 0.678614,
    '30-35%': 0.694686,
    '35-40%': 0.727428,
    '40-45%': 0.732558,
    '45-50%': 0.750000,
    '50-55%': 0.784753,
    '55-60%': 0.788012,
    '60-65%': 0.786517,
    '65-70%': 0.793349,
    '70-75%': 0.818182,
    '75-80%': 0.853535,
    '80-85%': 0.822222,
    '85-90%': 0.841962,
    '90-95%': 0.853618,
    '95-100%': 0.902997
}

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 = [
        '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%'
    ]
    bin_width = 5
    for b in bins:
        lower, upper = map(int, b.split('-'))
        if lower <= probabilidade < upper:
            return b
    return '95-100%'

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]

    if previsao_LayAway == previsao_LayHome:
        resultado = 'Não entre!'
    else:
        if previsao_LayAway == 1:
            entrada_LayAway = 'SIM'
        else:
            entrada_LayAway = 'NAO'

        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)
        
        # Determinar faixa de probabilidade e precisão correspondente
        faixa = determinar_faixa(probabilidade_LayAway_calibrated)
        precision = precision_by_bin[faixa]

        # 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

# 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="text",
    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()