Join the Dynamic Pricing Competition
Benchmark your algorithm. Rise on the leaderboard.
Win a prize
Compete for victory – the top performer will be rewarded with a 200€ prize.
Performance Evalutation
Get a detailed analysis of how your algorithms perform across diverse market scenarios.
Scoring & Benchmark
Receive a clear benchmark showing your algorithm’s ranking against all competitors.
Why Join the Competition
Pricing isn’t just about numbers – it’s about winning or losing in the real market. Small changes can decide profit or loss, and today, algorithms set the pace. But how good is your algorithm when it faces real competition, unpredictable demand, and diverse customer behavior?
This challenge gives you the arena to find out.
Get Started in 5 Steps
Sign-up: Register here for free and get access to the competition platform.
Create Your Algorithm: Build a pricing strategy in Python – start simple, improve over time.
Upload & Compete: Submit your algorithm and join the daily competition runs.
Get Results: Check your performance, ranking, and detailed feedback.
Tweak & Improve: Refine your strategy, re-submit, and climb the leaderboard – until the final submission deadline on December 31st.
Before you start coding, make sure to review the Knowledge Base –
it covers all requirements and rules of the competition.
The Challenge
Each time period, each player posts a price, this is given as input into the unknown demand mechanism. Each player in the competition receives then their own sales realization and competitors’ prices. The demand mechanism that generates the sales based on the prices is unknown to all competitors
Players are randomly selected to play against each other in small competition matches. Each match consists of multiple simulations, and the player with the overall highest generated revenue overall simulations is winning the match.
Duopoly: The Airline Challenge
You sell a finite inventory of 80 units, e.g. seats on a plane, over a selling season of 100 time periods, think of it as days. You are playing against one other competitor in the market, who also has an initial inventory of 80 units. Each time period, you post a price and then observe your own sales and your competitor’s price. The demand mechanism that generates the sales based on the prices is unknown to both competitors.
The following example illustrates a single time period. The competitors post prices of $8 and $7, which generates sales of 5 and 6 units, respectively:
This process repeats itself over the selling season of 100 time periods in total:
After these 100 time periods, the selling season is finished. A new selling season starts and the competitors receive again a new inventory of 80 units. The two competitors play many selling seasons, usually 100. The demand mechanism is the same within a single selling season, but can change across selling seasons.
The player, who generated the most revenue over all selling seasons, wins.
Note: in practice we execute 101 time periods per selling season in order to provide your algorithm the information (competitor price & own demand) from time period 100. Your algorithms’ returned price in time period 101 will not be used for evaluation.
A detailed explanation of this challenge can be found here.
Knowledge Base
This is your playbook: the rules, the setup, the tools.
Explore each section to prepare your algorithm for the competition.
Key Deadlines
Weekly training run: Simulations run weekly on multiple days at 0:30 UTC. Check the login area for exact dates – each run takes 12–15 hours.
Final submission deadline: December 31st of each edition year
Algorithm Requirements
- Your code will be executed in a docker container with Python 3.9 and Anaconda distribution 2022.05. We have also added: tensorflow==2.13.0, tf-agents==0.14.0, tornado==6.3.3, torch==2.0.1, xgboost==1.6.2, botorch==0.8.5. If you need further packages, please contact us.
- The container in which your code runs has 1 CPU and 512 MB of memory and your code is not allowed to use the local file system to save your own log files or anything like this. Further, there is no need for printing out things in your functions, we are not logging your output.
- When uploading your algorithms on the platform, please name the pricing algorithms “duopoly.py” (1-airline case). This is essential for the competition setup on AWS.
- The competition setup expects that each of the main scripts contains a function p(.), which we will call, the function is expected to return the price and the information dump.
- The information dump allows you to pass yourself any kind of information from one time period to the next. But note, that the information dump is reset to None at the beginning of every competition. So you can use the information dump only during the competition to pass back information to yourself in the next time period, but not across simulations. For this you can use the ‘duopoly_feedback.data‘ file, see explanation below.
- You can use supporting python scripts by simply importing them in your scripts from the current working directory. All your files will be placed in the same directory.
- Your algorithms need to return a price response on average within 0.2 seconds per time period/iteration and the maximum time for a single price response is 5 seconds. Further, the algorithm needs to be error free in 99% of the price requests.
- In case we do not receive a valid price response (>0) from your function, we will use your old price from the previous time period. In case your function is not working on the first period in the selling season, we will draw a random price and use that.
Code: duopoly.py with the price function p(.)
A simple example algorithm code with the explanation of the main functionalities can be found here.
The submitted algorithm file needs to be exactly called ‘duopoly.py’ and it needs to contain a pricing function p, which takes the following parameter. The function p(.) returns the tuple of (price, information_dump).
def p(
current_selling_season: int,
selling_period_in_current_season: int,
prices_historical_in_current_season: Union[np.ndarray, None],
demand_historical_in_current_season: Union[np.ndarray, None],
competitor_has_capacity_current_period_in_current_season: bool,
information_dump=Optional[Any],
) -> Tuple[float, Any]:
- current_selling_season (int): The current selling season (1, 2, 3, …, 100).
- selling_period_in_current_season (int): The period in the current season (1, 2, …, 100).
- prices_historical_in_current_season (Union[np.ndarray, None]): A two-dimensional array of historical prices: rows index the competitors and columns index the historical selling periods. Equal to
Noneifselling_period_in_current_season == 1. - demand_historical_in_current_season (Union[np.ndarray, None]): A one-dimensional array of historical (own) demand. Equal to
Noneifselling_period_in_current_season == 1. - competitor_has_capacity_current_period_in_current_season (bool):
Falseif competitor is out of stock, elseFalse - information_dump (Any, optional, default
None): Custom object to pass yourself any information object you like from one selling_period to the other within the same competition. Equal toNoneifselling_period_in_current_season == 1AND current_selling_season==1, i.e. it is reset at the beginning of each competition (one competition = 100 selling_seasons with each 100 selling periods. To pass information across competitions and also to yourself in the UI, use the ‘duopoly_feedback.data’ file.
Code Testing
Cloud testing environment
In the login area under File Manager, you can upload your duopoly.py file alongside any other supplementary files you need. After the upload, we will start a small test run with your algorithms in the cloud. After approx. 15 minutes you can see the performance results with potential error logs for download in the platform.
Additional getting started information
An example notebook to start analysing the competition detail logs and how to simulate your algorithm locally can be found here.
Usage of duopoly_feedback.data
The DPC environment allows you to store feedback data in a dedicated file. You can use this file to pass your algorithm information across different competitions in the nightly simulation runs, as well as providing yourself information to download in the UI after the competition run. Here is an example to use pickle to store information in this file, but you can use any file format you like.
import pickle
# write any feedback object to file
with open('duopoly_feedback.data', 'wb') as handle:
pickle.dump(FEEDBACK_OBJECT, handle, protocol=pickle.HIGHEST_PROTOCOL)
# load feedback object
with open('duopoly_feedback.data', 'rb') as handle:
feedback = pickle.load(handle)
Note, you don’t need to take care of this folder structure if you just want to import your custom scripts, simply import them. All your uploaded files will be located in the same folder within the competition container.
Also, the ‘duopoly_feedback.data' does not require this extra path handling. The feedback data object has a special setup to pass to yourself information for download in the DPC website, this file will be available in the website under ‘Download Feedback Data' in the results page.
Example how to load additional submitted files
You may want to upload additional files, e.g. pickle files. In order to open these files in the competition container, please use the following code example. Your code location in the container is under /root/partcipant_folder/ and therefore please add this to the file location when loading the file.
import pickle
try:
# for the cloud in container
with open('/root/partcipant_folder/FILENAME.pkl', 'rb') as f:
obj = pickle.load(f)
except:
# for your local testing
with open('FILENAME.pkl', 'rb') as f:
obj = pickle.load(f)
Note, you don’t need to take care of this folder structure if you just want to import your custom scripts, simply import them. All your uploaded files will be located in the same folder within the competition container.
Also, the ‘duopoly_feedback.data' does not require this extra path handling. The feedback data object has a special setup to pass to yourself information for download in the DPC website, this file will be available in the website under ‘Download Feedback Data' in the results page.
During the training phase
- You can upload daily new algorithms.
- We build a new docker container with your code.
- At night all containers are started, the competition matches are randomly drawn among the competitors.
- The simulations are performed, performances are logged and evaluated.
- You will find your ranking and performance statistics in your login area. There you can also download .csv files with simulation data (your prices, competitor prices and your demand realization).
Organizers
Alwin Haensel
Prof. Ger Koole
Ruben van de Geer
Paul Kleinschmidt
Prof. Thomas Winter
How it all started
Curious to know how it all began? Check out the paper below on the very first edition of the competition in 2017.
Leaderboard
2024
Duopoly Challenge
The team from the Computer Systems Group, IIIT Hyderabad, India, comprises Anush Anand (B.Tech Honors), Pranav Agrawal (B.Tech Honors), and Dr. Tejas Bodas (Assistant Professor). The team leveraged their expertise in Gaussian Processes and Bayesian Optimization to optimize pricing strategies for a duopoly, with Gaussian Processes likely playing a key role in their success in the 2024 competion.
2023
Duopoly Challenge
2022
Duopoly Challenge
2021
Dynamic challenge: Two winning teams share the first place
Ernst Oldenhof, Ph.D, is heading the Data Analytics team in Internal Audit at Bank Julius Baer in Zürich. He completed his Ph.D. in Applied Physics at Delft University of Technology and worked as an R&D engineer before moving to the banking industry.
The team from TUM School of Management, Technical University of Munich consists of Larkin Liu (Doctoral Candidate), Yihua Wang (M.Sc. and Research Assistant) and Prof. Dr. Stefan Minner. The team has combined their expertise and background in Operations Research, Supply Chain Management and Data-driven Optimization to win both the Oligopoly and Dynamic challenges.
Oligopoly challenge
The team consisting of Larkin Liu (Doctoral Candidate), Yihua Wang (M.Sc. and Research Assistant) and Prof. Dr. Stefan Minner also won the Oligopoly challenge.
Duopoly challenge
Matt Dickenson is a software engineer in Colorado. He holds a BS degree in political science from the University of Houston and an MS degree in computer science from Duke University. He is also the author of two books and has taught graduate-level programming and data science courses throughout the United States.
2020
Dynamic challenge
Fulin Xie, Ph.D., is a Data Scientist at Microlise in the UK. By the way, his Duopoly submission was also ranked second in that challenge. This was the toughest battle ground in 2020.
Oligopoly challenge
Boris Kuznetsov and Oganes Manasian, Boris is currently finalizing his MSc. in mathematics and finance at the EPFL in Lausanne, and Oganes is currently working as Intern at IBM Research in Ireland.
Duopoly challenge
Kyle Maclean and Fredrik Odegaard, both work at The Ivey Business School in Canada as Assistant and Associate Professors. For Kyle it is already the second year in a row he is winning the Duopoly challenge!
2019
Duopoly & Dynamic challenges
Kyle Maclean, PhD, Assistant Professor at Ivey Business School in Canada. Especially the Duopoly was our most competitive challenge and a very tight competition.
Oligopoly challenge
Ruben van de Geer, PhD, Data Maestro at GoDataDriven in the Netherlands. Ruben actually submitted his first oligopoly algorithm only days before the final deadline and was going straight to the top with an impressive margin.
Note: Ruben was not in the organization committee during 2019, he joined the organizers back in 2020. Of course organizers are not participating in the DPC.
