预测一下图中比赛结果

python
# Implied probabilities from decimal odds extracted
moneyline_odds = {'home':1.16, 'draw':6.4, 'away':9}
imp_probs = {k:1/v for k,v in moneyline_odds.items()}
imp_probs

{'home': 0.8620689655172414, 'draw': 0.15625, 'away': 0.1111111111111111}

python
odds = {'3-1':8.8,'2-0':9.5,'2-1':8,'3-0':9}
budget=100
# Optimize equal profit: allocate w_i such that w_i*odds_i = K for all, sum w_i = budget
# K unknown; weights = budget / sum(1/odds_i)
denom=sum(1/o for o in odds.values())
K=budget/denom
stakes={score: K/odd for score,odd in odds.items()}
stakes

{'3-1': 24.974441361180077,
 '2-0': 23.134219366145757,
 '2-1': 27.471885497298086,
 '3-0': 24.419453775376077}

python
profit = {}
for score, stake in stakes.items():
    profit[score] = stake*odds[score]-budget
profit

{'3-1': 119.77508397838469,
 '2-0': 119.77508397838469,
 '2-1': 119.77508397838469,
 '3-0': 119.77508397838469}

python
p=sp.symbols('p')
S=1
a=p*S
b=(1-p)*S
expr= a*4.2 - S - (b*2.45 - S)
sp.solve(expr, p)

[0.368421052631579]

python
p=0.368421052631579
S=1
profit_diff2 = p*S*4.2 - S
profit_diffge3 = (1-p)*S*2.45 - S
profit_diff2, profit_diffge3

(0.5473684210526317, 0.5473684210526315)

python
#Kelly for -2 draw 4.2 with p=0.6
p=0.6
b=4.2-1
f = (p*(b+1)-1)/b
f

0.475

python
from PIL import Image
import matplotlib.pyplot as plt

img = Image.open('/mnt/data/Screenshot_20250712_202412.jpg')
plt.imshow(img)
plt.axis('off')

(-0.5, 719.5, 1599.5, -0.5)

python
import math

def poisson_pmf(k, lam):
    return math.exp(-lam) * (lam**k) / math.factorial(k)

home_avg=2.8
away_avg=0.9

# compute probabilities for up to maybe 7 goals each
scores_prob={}
total_prob=0
for h in range(8):
    for a in range(8):
        p=poisson_pmf(h,home_avg)*poisson_pmf(a,away_avg)
        scores_prob[(h,a)]=p
        total_prob+=p
total_prob

0.9918644799474604

python
total_goal_probs = {g:0 for g in range(8)}  # 0-7 inclusive; we will aggregated >7 into 7
for (h,a),p in scores_prob.items():
    g=h+a
    if g>=7:
        total_goal_probs[7]+=p
    else:
        total_goal_probs[g]+=p
total_goal_probs

{0: 0.024723526470339395,
 1: 0.09147704794025577,
 2: 0.16923253868947316,
 3: 0.2087201310503502,
 4: 0.19306612122157393,
 5: 0.1428689297039647,
 6: 0.08810250665077823,
 7: 0.07367367822072479}

python
odds={0:38,1:10.5,2:5.8,3:3.95,4:4.25,5:5.6,6:8.25,7:8.25}
# Suppose we allocate stake x3 and x4 to 3 and 4 goals to have equal return R.
# Let stake3 = s3, stake4 = s4, payoffs when wins: s3*3.95 or s4*4.25.
# Want s3*3.95 == s4*4.25
# Let total stake =100. solve.
total_stake=100
# solve s3 = k, s4/ s3 ratio
ratio = 3.95/4.25
# s4=ratio*s3
# s3 + s4 = total
s3 = total_stake/(1+ratio)
s4 = total_stake - s3
s3, s4

(51.829268292682926, 48.170731707317074)

python
score_odds = {(1,0):12,(2,0):9.5,(2,1):8,(3,0):9,(3,1):8.8,(3,2):17,(4,0):12.5,(4,1):13,(4,2):25,(5,0):21,(5,1):22}
# compute probability
for key in score_odds:
    print(key, scores_prob.get(key,0))

python
# Suppose we dutch 2-0,2-1,3-0,3-1 equal profit R.
# Let stakes s_{i} satisfy s_i * odds_i = R.
odds_d = {'2-0':9.5,'2-1':8,'3-0':9,'3-1':8.8}
# We'll compute stakes for R=some constant times maybe 1
# Use total investment 100. Solve R such that sum(R/odds_i) = 100
inv = sum(1/o for o in odds_d.values())
R = 100 / inv
stakes = {score: R/odds for score,odds in odds_d.items()}
R,stakes

(219.77508397838469,
 {'2-0': 23.134219366145757,
  '2-1': 27.471885497298086,
  '3-0': 24.419453775376077,
  '3-1': 24.974441361180077})

python
# Probability for win other: home score >=6? or combos not enumerated.
prob_win_other = 0
for (h,a),p in scores_prob.items():
    if h>a and (h,a) not in score_odds:
        prob_win_other += p
prob_win_other

0.0842962948455561

python
odds_win_other = 9
p = prob_win_other
EV_per_unit = p*(odds_win_other-1) - (1-p)
EV_per_unit

-0.24133334638999504

python
# compute EV for each total goals pick and correct scores
ev_total={}
for g in odds:
    p=total_goal_probs[g]
    ev = p*(odds[g]-1) - (1-p) # EV per unit
    ev_total[g]=ev
ev_total

{0: -0.060505994127103,
 1: -0.03949099662731437,
 2: -0.01845127560105564,
 3: -0.17555548235111673,
 4: -0.17946898480831075,
 5: -0.19993399365779774,
 6: -0.27315432013107954,
 7: -0.39219215467902047}

python
ev_score={}
for (h,a),odds_val in score_odds.items():
    p=scores_prob[(h,a)]
    ev=p*(odds_val-1) - (1-p)
    ev_score[(h,a)] = ev
# compute win-other
ev_score_other = prob_win_other*(9-1) - (1-prob_win_other)
max(ev_score.values()), min(ev_score.values()), ev_score_other

(-0.07929587424456097, -0.37721634609426835, -0.24133334638999504)

python
home_avg=3.1
away_avg=1.1
scores_prob2={}
for h in range(9):
    for a in range(9):
        scores_prob2[(h,a)]=poisson_pmf(h,home_avg)*poisson_pmf(a,away_avg)
total_goals_prob2={}
for g in range(8):
    total_goals_prob2[g]=0
for (h,a),p in scores_prob2.items():
    g=h+a
    if g>=7:
        total_goals_prob2[7]+=p
    else:
        total_goals_prob2[g]+=p
total_goals_prob2

{0: 0.014995576820477705,
 1: 0.06298142264600635,
 2: 0.13226098755661336,
 3: 0.1851653825792587,
 4: 0.19442365170822168,
 5: 0.16331586743490617,
 6: 0.11432110720443434,
 7: 0.12785035673571904}

python
odds_sel = {3:3.95,4:4.25,5:5.6}
# Solve stakes such that payouts equal R; we let stakes s3= a, s4=b, s5=c
# returns: a*3.95 = b*4.25 = c*5.6 = R
# So b = (3.95/4.25) a , c = (3.95/5.6) a
s3=1
s4=3.95/4.25
s5=3.95/5.6
s3,s4,s5

(1, 0.9294117647058824, 0.7053571428571429)

python
def dutch_stakes(odds, T=100):
    S = sum(1/o for o in odds)
    c = T / S
    stakes = [c / o for o in odds]
    profit = c - T
    return stakes, profit
odds = [5.25, 5.45, 6.75]
stakes, profit = dutch_stakes(odds)
stakes, profit

([36.48196355522499, 35.14317590182224, 28.37486054295277], 91.5303086649312)

python
sum(1/o for o in odds)


0.5221105771564487

python
odds = [5.25,5.45,4]
stakes, profit = dutch_stakes(odds)
stakes, profit

([30.52686854542272, 29.406616488709957, 40.06651496586732], 60.26605986346928)

python
odds = [7.25,5.25,5.45]
stakes, profit = dutch_stakes(odds)
stakes, profit

([26.945261918775753, 37.2101236021189, 35.84461447910536], 95.35314891112421)

python
odds=[7.25,5.25,5.45,6.75]
stakes, profit = dutch_stakes(odds)
stakes, profit

([20.89732405510134,
  28.85820940942566,
  27.799192550364165,
  22.445273985108845],
 51.50559939948471)

python
odds=[5.25,5.45,7.25,14]
stakes, profit = dutch_stakes(odds)
stakes, profit

([32.65369368438722, 31.45539299872164, 23.64577818524592, 12.24513513164521],
 71.43189184303293)

python
odds=[5.25,5.45,14]
stakes, profit = dutch_stakes(odds)
stakes, profit

([42.766061794997555, 41.196665031878375, 16.03727317312408],
 124.52182442373714)

python
odds=[5.25,5.45,7.25,14]
stakes=[32.65369368438722,31.45539299872164,23.64577818524592,12.24513513164521]
returns=[s*o -100 for s,o in zip(stakes,odds)]
returns

[71.4318918430329, 71.43189184303293, 71.43189184303293, 71.43189184303293]

python
import math
def poisson(k, lam):
    return math.exp(-lam)*lam**k/math.factorial(k)
lam_c=3.7
lam_t=0.4
probs={}
for hc in range(6):  # home/Taipei
    for ac in range(6):
        prob=poisson(hc, lam_t)*poisson(ac, lam_c)
        probs[(hc,ac)]=prob
# Compute cluster: 0:2,0:3,0:4,1:3
cluster = [(0,2),(0,3),(0,4),(1,3)]
sum_cluster = sum(probs[x] for x in cluster)
sum_cluster

0.4387290573861531

python
def cluster_prob(lc, lt, cluster):
    p=0
    for ht, cw in cluster:  # oh it uses cluster mapping tuple (home goals, away goals)
        p+=poisson(ht, lt)*poisson(cw, lc)
    return p
cluster = [(0,2),(0,3),(0,4),(1,3)]
for lc in [3.5,3.7,4.0,4.2]:
    for lt in [0.3,0.4,0.6]:
        print(lc,lt, cluster_prob(lc,lt,cluster))

python
odds=[7.25,5.25,5.45,6.75,14,16]
stakes, profit = dutch_stakes(odds)
stakes, profit

([17.37231919085605,
  23.9903455492774,
  23.10996589609291,
  18.65915764943798,
  8.996379580979026,
  7.871832133356647],
 25.949314133706352)

python
odds=[5.25,5.45,6.75,14,16] #0:3,0:4,0:5,1:3,1:4
stakes, profit = dutch_stakes(odds)
stakes, profit

([29.034271946578126,
  27.968794076978927,
  22.58221151400521,
  10.887851979966797,
  9.526870482470947],
 52.42992771953516)

python
from math import exp, factorial
lam1=0.4
lam2=3.5
def pois(k,l): return exp(-l)*l**k/factorial(k)
prob=dict()
for g1 in range(0,6):
    for g2 in range(0,8):
        prob[(g1,g2)]=pois(g1,lam1)*pois(g2,lam2)
# Normalize approximate, but sum approx to 1 for k up to ranges truncated; maybe 99% coverage.

sum(prob.values())

0.9732571433224968

python
cluster_scores=[(0,3),(0,4),(0,2),(1,3),(1,4),(0,5),(1,5)]
sum_p=sum(prob.get(sc,0) for sc in cluster_scores)
sum_p

0.6277090537979421

python
prob.get((0,1),0), prob.get((0,2),0), prob.get((0,3),0), prob.get((0,4),0), prob.get((0,5),0)

(0.07084669006031535,
 0.12398170760555188,
 0.14464532553981052,
 0.12656465984733423,
 0.08859526189313395)

python
odds={
    (0,1):15,
    (0,2):7.25,
    (0,3):5.25,
    (0,4):5.45,
    (0,5):6.75,
    (1,2):19,
    (1,3):14,
    (1,4):16,
    (1,5):20
}
ev={sc:(odds[sc]-1)*prob.get(sc,0)- (1-prob.get(sc,0)) for sc in odds}
ev

{(0, 1): 0.06270035090473025,
 (0, 2): -0.10113261985974886,
 (0, 3): -0.24061204091599475,
 (0, 4): -0.3102226038320285,
 (0, 5): -0.40198198222134585,
 (1, 2): -0.05773902219780558,
 (1, 3): -0.189986176977061,
 (1, 4): -0.18998617697706088,
 (1, 5): -0.2912379048549283}

python
ev={}
for sc,o in odds.items():
    p=prob.get(sc,0)
    ev[sc]=p*o -1 # correct expectation for stake 1
ev

{(0, 1): 0.06270035090473036,
 (0, 2): -0.10113261985974886,
 (0, 3): -0.24061204091599475,
 (0, 4): -0.3102226038320285,
 (0, 5): -0.40198198222134585,
 (1, 2): -0.05773902219780558,
 (1, 3): -0.189986176977061,
 (1, 4): -0.18998617697706088,
 (1, 5): -0.2912379048549283}

python
cluster=[(0,3),(0,4),(0,5),(1,3),(1,4)]  # weights earlier
weights={ (0,3):29.03,(0,4):27.97,(0,5):22.58,(1,3):10.89,(1,4):9.53}
total=100
expected=0
for sc, stake in weights.items():
    p=prob.get(sc,0)
    o=odds[sc]
    expected+=p*(stake*(o-1)) - (1-p)*stake
expected

-28.618164669402738

python
cluster2=[(0,2),(0,3),(0,4),(0,5),(1,3),(1,4)]
# compute weights equal return for stake 100
# Use algorithm to compute weight proportional to 1/O_i normalized so net return equal
odds_cluster=[odds[sc] for sc in cluster2]
sum_inv=sum(1/o for o in odds_cluster)
T=100
weights2={sc: (T/sum_inv)*(1/odds[sc]) for sc in cluster2}
weights2

{(0, 2): 17.372319190856047,
 (0, 3): 23.9903455492774,
 (0, 4): 23.109965896092906,
 (0, 5): 18.659157649437976,
 (1, 3): 8.996379580979024,
 (1, 4): 7.871832133356647}

python
expected2=0
for sc, stake in weights2.items():
    p=prob.get(sc,0)
    o=odds[sc]
    expected2+=p*stake*(o-1) - (1-p)*stake
expected2

-25.403880187005946

python
from math import exp, factorial
lam1=0.2 # CT
lam2=4.5
prob2={}
for g1 in range(0,8):
    for g2 in range(0,10):
        prob2[(g1,g2)] = exp(-lam1)*lam1**g1/factorial(g1) * exp(-lam2)*lam2**g2/factorial(g2)
sum(prob2.values())

0.9829072670483683

python
prob_cluster2=sum(prob2.get(sc,0) for sc in cluster2)
prob_cluster2

0.5841939116530636

python
expected_cluster2=0
for sc, stake in weights2.items():
    p=prob2.get(sc,0)
    o=odds[sc]
    expected_cluster2+=p*stake*(o-1) - (1-p)*stake
expected_cluster2

-26.421177506209595

python
from math import comb
# compute probability of Chinese goals >=6
p_goals_ge6 = sum(pois(k,lam2) for k in range(6,15))
p_goals_ge6

0.29699590461557623

python
enumerated_losses=[(0,1),(0,2),(0,3),(0,4),(0,5),
                   (1,2),(1,3),(1,4),(1,5),
                   (2,3),(2,4),(2,5)]
# probability for g1<g2
p_lose=0
p_enum=0
for (g1,g2),p in prob2.items():
    if g1<g2:
        p_lose+=p
        if (g1,g2) in enumerated_losses:
            p_enum+=p
p_other=p_lose-p_enum
p_lose, p_enum, p_other

(0.9605606063602393, 0.6801807764321055, 0.2803798299281338)

python
odds_extended={(0,3):5.25,(0,4):5.45,(0,5):6.75,'other':4}
odds_list=list(odds_extended.values())
sum_inv=sum(1/o for o in odds_list)
sum_inv

0.7721105771564487

python
T=100
weights3={sc: (T/sum_inv)*(1/odds_extended[sc]) for sc in odds_extended}
weights3

{(0, 3): 24.66954813359528,
 (0, 4): 23.76424361493123,
 (0, 5): 19.187426326129664,
 'other': 32.37878192534381}

python
return_amount = weights3[(0,3)]*5.25
returns=[weights3[sc]*odds_extended[sc] for sc in odds_extended]
returns

[129.51512770137523, 129.5151277013752, 129.51512770137523, 129.51512770137523]

python
probcluster = prob2.get((0,3),0)+prob2.get((0,4),0)+prob2.get((0,5),0)+p_other
probcluster

0.7137768895091752

python
ev = probcluster*29.51512770137523 - (1-probcluster)*100
ev

-7.555095004928781

python
lam2=5.5
prob3={}
from math import exp, factorial
for g1 in range(0,8):
    for g2 in range(0,12):
        prob3[(g1,g2)] = exp(-lam1)*lam1**g1/factorial(g1) * exp(-lam2)*lam2**g2/factorial(g2)
# probability cluster
p_loose=0
p_enum=0
for (g1,g2),p in prob3.items():
    if g1<g2:
        p_loose+=p
        if (g1,g2) in enumerated_losses:
            p_enum+=p
p_other_new=p_loose - p_enum
probcluster_new=prob3.get((0,3),0)+prob3.get((0,4),0)+prob3.get((0,5),0)+p_other_new
probcluster_new

0.8211452135028008

python
ev_new=probcluster_new*29.515 - (1-probcluster_new)*100
ev_new

6.350622326815245