pydfs-lineup-optimizer Documentation

Transcription

1 pydfs-lineup-optimizer Documentation Release 2.0 Dima Kudosh Jun 27, 2018

2

3 Contents 1 Contents Installation Usage Constraints Export lineups Performance and Optimization i

4 ii

5 pydfs-lineup-optimizer is a tool for creating optimal lineups for daily fantasy sport. Currently it supports following dfs sites: League DraftKings FanDuel FantasyDraft Yahoo NFL NBA NHL MLB WNBA Golf Soccer CFL LOL Contents 1

6 2 Contents

7 CHAPTER 1 Contents 1.1 Installation Compatibility pydfs-lineup-optimizer works with following versions of python: Python: 2.7, Installation pydfs-lineup-optimizer can be installed with pip: $ pip install pydfs-lineup-optimizer 1.2 Usage Base Usage Creating optimal lineups with pydfs-lineup-optimizer is very simple. Firstly you should create optimizer. You can do this using shortcut get_optimizer. You must provide daily fantasy site for it and kind of sport. If site doesn t support specified sport you will get NotImplementedError. from pydfs_lineup_optimizer import get_optimizer, Site, Sport optimizer = get_optimizer(site.fanduel, Sport.BASKETBALL) After that you need to load players into your optimizer. You have 2 options: First is to load players from CSV file like this: 3

8 optimizer.load_players_from_csv("path_to_csv") Note: CSV file must have the same format as export file in specified dfs site, if you have custom CSV file this method will not work. Or you can load players using load_players method and pass list with players. from pydfs_lineup_optimizer import Player optimizer.load_players(players) # players is list of Player objects After player loading you can create your optimal lineups with following code: lineups = optimizer.optimize(n=10) Where n is a number of lineups that you want generate. Note: Optimize method returns generator instead of list Example of base usage Below is a full example of how pydfs-lineup-optimizer can be used to generate optimal lineups. optimizer = get_optimizer(site.yahoo, Sport.BASKETBALL) optimizer.load_players_from_csv("yahoo-nba.csv") for lineup in optimizer.optimize(n=10): print(lineup) print(lineup.players) # list of players print(lineup.fantasy_points_projection) print(lineup.salary_costs) Advanced Usage For generating optimal lineups you may need to lock some players that you want to see in your lineup. You can do this using following code: player = optimizer.get_player_by_name('rodney Hood') # find player with specified name in your optimizer optimizer.add_player_to_lineup(player) # lock this player in lineup Locked players can be unlocked as well: optimizer.remove_player_from_lineup(player) Also you can exclude some players from optimization process and restore players as well: optimizer.remove_player(player) optimizer.restore_player(player) You can specify maximum exposure for some players or for all players, you have several ways how to do this. You can add Max Exposure column with exposure percentage for some players to csv that you will parse when load players. 4 Chapter 1. Contents

9 Or you can set max_exposure property in Player object. If you want to set fixed exposure for all players you can pass max_exposure parameter to optimize method player = optimizer.players[0] # get random player from optimizer players player.max_exposure = 0.5 # set 50% exposure lineups = optimizer.optimize(n=10, max_exposure=0.3) players # set 30% exposure for all Note: Exposure working with locked players, so if you lock some player and set exposure for 50% percentage this player will appears only in 50% lineups. Player exposure has higher priority than max_exposure that you pass in optimize method. Exposure percentage rounds to ceil. Optimizer also have randomness feature. It adds some deviation for players projection for creating less optimized but more randomized lineups. For activating randomness feature you must set randomness parameter to True. By default min deviation is 6% and max deviation is 12%. You can change it with set_deviation method. lineups = optimizer.optimize(n=10, randomness=true) lineups = optimizer.set_deviation(0.2, 0.4) # for making more random lineups lineups = optimizer.optimize(n=10, randomness=true) Note: With randomness = True optimizer generate lineups without ordering by max points projection Example of advanced usage Below is an full example of how pydfs-lineup-optimizer can be used to generate optimal lineups with user constraints. optimizer = get_optimizer(site.yahoo, Sport.BASKETBALL) optimizer.load_players_from_csv("yahoo-nba.csv") nets_centers = filter(lambda p: p.team == 'Nets' and 'C' in p.positions, optimizer. players) for player in nets_centers: optimizer.remove_player(player) # Remove all Nets centers from optimizer harden = optimizer.get_player_by_name('harden') westbrook = optimizer.get_player_by_name('westbrook') # Get Harden and Westbrook harden.max_exposure = 0.6 westbrook.max_exposure = 0.4 # Set exposures for Harden and Westbrook optimizer.add_player_to_lineup(harden) optimizer.add_player_to_lineup(westbrook) # Lock Harden and Westbrook for lineup in optimizer.optimize(n=10, max_exposure=0.3): print(lineup) 1.3 Constraints pydfs-lineup-optimizer has ability to set custom constraints for optimizer. It has following constraints: Number of players from same team. Positions for same team. Number of specific positions Constraints 5

10 Minimum salary cap. Maximum repeating players Number of players from same team For setting number of players from same team constraint you should call set_players_from_one_team method of optimizer. It accepts dict where key is a team name and value is number of players for this team. optimizer.set_players_from_one_team({'okc': 4}) Positions for same team For setting positions for same team you should call set_positions_for_same_team method of optimizer. It accepts list with positions that must be selected from one team. optimizer.set_positions_for_same_team(['qb', 'WR', 'WR']) Number of specific positions For setting specific players positions for multi-position slots optimizer has set_players_with_same_position method. It accepts dict where key is a position name and value is number of players with this position. optimizer.set_players_with_same_position({'pg': 2}) Note: Positions constraint hasn t effect for dfs sites without multi-position slots(g, UTIL, etc.) Minimum salary cap You can set minimum salaries cap using set_min_salary_cap method. If you set min salary cap greater than maximum budget LineupOptimizerException will be raised. optimizer.set_min_salary_cap(49000) Maximum repeating players If you want to make more random lineups you can use set_max_repeating_players method. This method adds constraint that restrict players combinations that used in previous lineup. It accepts only one argument: number of maximum repeating players. optimizer.set_max_repeating_players(5) 1.4 Export lineups You can export lineups into a csv file. pydfs-lineup-optimizer has helper class for this called CSVLineupExporter. You should pass iterable with lineups to constructor and then call export method with filename argument. 6 Chapter 1. Contents

11 from pydfs_lineup_optimizer import get_optimizer, Site, Sport, CSVLineupExporter optimizer = get_optimizer(site.draftkings, Sport.BASKETBALL) optimizer.load_players_from_csv("players.csv") exporter = CSVLineupExporter(optimizer.optimize(10)) exporter.export('result.csv') Exported file has following format. Position 1... Position n Budget FPPG Player Name 1 (id)... Player Name n (id) Player Name 1 (id)... Player Name n (id) Player Name 1 (id)... Player Name n (id) If you want to display another information for player you can pass your own function for rendering player data as second argument to export. exporter.export('result.csv', lambda p: p.id) 1.5 Performance and Optimization Sometimes optimization process takes a lot of time to generate single lineup. It usually happens in mlb and nfl because all teams plays in same day and each team has a lot of players and total number of players used in optimization is >500. In this case a good approach is to remove from optimization players with small fppg value and big salary. optimizer = get_optimizer(site.draftkings, Sport.BASEBALL) optimizer.load_players_from_csv('dk_mlb.csv') for player in optimizer.players: if player.efficiency == 0: optimizer.remove_player(player) for lineup in optimizer.optimize(10): print(lineup) 1.5. Performance and Optimization 7