Choosing a Fantasy Football Team
co-starring: IPython Notebook, matplotlib, and lp_solve
Bill Mill
billmill.org
github.com/llimllib
@llimllib
This talk is available at: billmill.org/fantasypl
You have a limited budget
And each player costs a certain amount
That sounds like an optimization problem...
I bet I could solve that with code
In []:
import requests, cPickle, shutil, time
all = {}
errorout = open("errors.log", "w")
for i in range(600):
playerurl = "http://fantasy.premierleague.com/web/api/elements/%s/"
r = requests.get(playerurl % i)
# skip non-existent players
if r.status_code != 200: continue
all[i] = r.json()
cPickle.dump(all, outfile)
In [63]:
website("http://ipython.org/notebook.html")
Out[63]:
In [5]:
import cPickle
players = cPickle.load(open("players.data.pickle"))
players[1]
Out[5]:
In [25]:
points = {}
for p in players.itervalues():
for game in p['fixture_history']['all']:
if game[3] > 0:
points.setdefault(p['type_name'], []).append(game[19])
def poshist(axis, position):
axis.hist(points[position])
axis.set_title(position)
return axis
fig, (ax0, ax1, ax2, ax3) = plt.subplots(ncols=4, sharey=True, figsize=(18,4))
poshist(ax0, "Forward")
poshist(ax1, "Midfielder")
poshist(ax2, "Defender")
poshist(ax3, "Goalkeeper")
fig.show()
In [8]:
opponents = {}
for player in players.itervalues():
for game in player["fixture_history"]["all"]:
#skip games where the player played 0 minutes
if game[3] == 0: continue
opp = game[2][:3]
pts = game[19]
opponents.setdefault(opp, [0,0])[0] += pts
opponents[opp][1] += 1
from collections import OrderedDict
avgs = {}
for opponent, (score, n) in opponents.iteritems():
avgs[opponent] = score/float(n)
sorted_avgs = OrderedDict(sorted(avgs.items(), key=lambda t: t[1]))
fig, ax = plt.subplots(figsize=(18,4))
x_pos = np.arange(0, len(sorted_avgs.keys()))
ax.set_xticks(x_pos)
ax.set_xticklabels(sorted_avgs.keys(), rotation=45)
ax.plot(x_pos, sorted_avgs.values(), linewidth=3)
fig.show()
In [30]:
class Player(object):
def __init__(self, player_json):
self.raw = player_json
self.games = [Game(g) for g in player_json["fixture_history"]["all"]]
self.name = u"{first_name} {second_name}".format(**player_json)
self.cost = player_json["event_cost"]
self.position = player_json["type_name"]
self.team = team_abbreviations[player_json["team_name"]]
self.idn = player_json["id"]
self.news = player_json["news"]
self.news_return = player_json["news_return"]
self.pos = self.shortname(self.position)
self.upcoming = self.get_upcoming_fixtures(player_json["fixtures"]["all"])
def get_upcoming_fixtures(self, fixtures):
upcoming = []
for _, gameweek, opponent in fixtures:
week = int(gameweek.split()[-1])
if opponent == "-":
continue
opp, loc = opponent.split('(')
opp = team_abbreviations[opp.strip()]
loc = loc[0]
upcoming.append((week, opp, loc))
return upcoming
def shortname(self, position):
pos_abbreviations = {
"Goalkeeper": "gk",
"Defender": "d",
"Midfielder": "m",
"Forward": "f"
}
return pos_abbreviations[position]
def __repr__(self):
return "#%s %s %s £%s %s" % (self.idn, self.team, self.name.encode("ascii", "ignore"), self.cost, self.pos)
def __unicode__(self):
return "#%s %s £%s %s" % (self.idn, self.name, self.cost, self.pos)
player_objs = [Player(p) for p in players.itervalues()]
def find_player(needle):
return [p for p in player_objs if needle.lower() in p.name.lower()]
In [31]:
p = find_player('Van Persie')[0]
print p.name
print p.position
print p.cost
print p.idn
print p.upcoming[:3] # upcoming games
print p.games[:3] # games he's already played
print p
In [11]:
homeaway = {"A": 0, "H": 0}
n = 0.
for player in player_objs:
#only consider full games to eliminate minute bias
for game in [p for p in player.games if p.minutes == 90]:
homeaway[game.loc] += game.points
n += 1
homeaway["A"] /= n
homeaway["H"] /= n
homefield = homeaway["H"] - homeaway["A"]
print homefield, homeaway
fig, ax = plt.subplots(figsize=(2,4))
x_pos = np.arange(0, len(homeaway.keys()))
ax.set_xticks(x_pos+.4)
ax.set_xticklabels(["Away", "Home"], rotation=45)
ax.bar(x_pos, homeaway.values())
fig.show()
\(ev = \sum_{i=0}^5 opp_i + home_i + adj\_avg\)
In [15]:
def adjusted_score(game):
pts = game.points
pts += homefield/2 if game.loc == "A" else -homefield/2
pts += avg_opponent - avgs[game.opp]
return pts
def adjusted_average(player):
return sum(adjusted_score(g) for g in player.games) / len(player.games)
def game_value(game):
adj = 0
adj += homefield/2 if game[2] == "H" else -homefield/2
adj += avgs[game[1]] - avg_opponent
return adj
def expected_points(player, n=5):
"""return the number of expected points in the next n games"""
av = adjusted_average(player)
ev = 0.
for game in player.upcoming[:n]:
ev += av + game_value(game)
return ev/n
print expected_points(find_player(u"Mutch")[0])
print expected_points(find_player(u"Suárez")[0])
print expected_points(find_player(u"Sanogo")[0])
Given the constraints:
- Total player cost < 100
- 2 goalkeepers
- 5 defenders
- 5 midfielders
- 3 forwards
Maximize expected team value
Given this simple optimization problem:
x1 >= 1 x2 >= 1 x1 + x2 >= 2 minimize x1 + x2 where x1 is an integer
lp_solve takes a file that looks like:
min: x1 + x2; x1 >= 1; x2 >= 1; x1 + x2 >= 2; int x1, x2;
Which, when run, results in:
$ lp_solve /tmp/simple_example Value of objective function: 2.00000000 Actual values of the variables: x1 1 x2 1
max: 5.6 gk1 + 4.3 mf2 + …; /* maximize expected points */ 3.7 gk1 + 9.3 mf2 + … < 100; /* team must cost <100£ */ gk1 + gk12 + gk34 + … = 2; /* limit to 2 goalkeepers */ d3 + d4 + d23 + … = 5; /* limit to 5 defenders */ … /* repeat for all positions */ bin gk1, mf2, d3, f4, d5, …; /* all variables are binary */
In [17]:
def objective_function():
m = " + ".join("{ev} {p.pos}{p.idn}".format(p=p, ev=p.expected_points())
for p in player_objs)
return "max: " + m + ";\n"
In [18]:
def cost_constraint(max_price):
c = " + ".join("{p.cost} {p.pos}{p.idn}".format(p=p)
for p in player_objs)
return "cost_constraint: " + c + " <= %s;\n" % max_price
In [19]:
def position_constraints():
constraints = StringIO.StringIO()
gks = [p for p in player_objs if p.position == "Goalkeeper"]
gk_list = " + ".join(("gk{p.idn}".format(**locals()) for p in gks))
constraints.write("gk_limit: " + gk_list + " = 2;\n")
ds = [p for p in player_objs if p.position == "Defender"]
d_list = " + ".join(("d{p.idn}".format(**locals()) for p in ds))
constraints.write("d_limit: " + d_list + " = 5;\n")
ms = [p for p in player_objs if p.position == "Midfielder"]
m_list = " + ".join(("m{p.idn}".format(**locals()) for p in ms))
constraints.write("m_limit: " + m_list + " = 5;\n")
fs = [p for p in player_objs if p.position == "Forward"]
f_list = " + ".join(("f{p.idn}".format(**locals()) for p in fs))
constraints.write("f_limit: " + f_list + " = 3;\n")
return constraints.getvalue()
In [24]:
import subprocess, re
def get_player(idn):
"""given an id, return a player"""
for p in player_objs:
if p.idn == idn: return p
raise ValueError("Unable to find player")
def return_team(lp):
"""run lp_solve ands return a list of player objects"""
cmd = "echo '%s' | lp_solve" % lp
val = subprocess.check_output(cmd, shell=True).split('\n')
get_id = lambda l: int(re.search("^\w+?(\d+)", l).group(1))
team_ids = [get_id(l) for l in val if re.search(r" 1$", l)]
return map(get_player, team_ids)
return_team(buf.getvalue())
Out[24]:
