Initial commit

.gitattributes

@@ -29,3 +29,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+venv/
+__pycache__/

README.md

@@ -1,12 +1,14 @@
 ---
-title: Dynamic Pricing
-emoji: 📚
+title: 💸 Dynamic Pricing 💸
+emoji: 💸
 colorFrom: green
 colorTo: gray
 sdk: streamlit
-sdk_version: 1.10.0
+sdk_version: 1.13.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This demo will explore the current state-of-the-art in dynamic pricing methods.
+
+We will cover the motivation behind dynamic pricing and discuss how we can leverage Bayesian statistics, Thompson sampling and Gaussian processes to derive an optimal price-setting strategy.

app.py

@@ -0,0 +1,280 @@
+"""Streamlit entrypoint"""
+
+import base64
+import time
+
+import numpy as np
+import streamlit as st
+import sympy
+
+from helpers.thompson_sampling import ThompsonSampler
+
+eta, a, p, D, profit, var_cost, fixed_cost = sympy.symbols("eta a p D Profit varcost fixedcost")
+np.random.seed(42)
+
+st.set_page_config(
+    page_title="💸 Dynamic Pricing 💸",
+    page_icon="💸",
+    layout="centered",
+    initial_sidebar_state="auto",
+    menu_items={
+        'Get help': None,
+        'Report a bug': None,
+        'About': "https://www.ml6.eu/",
+    }
+)
+
+st.title("💸 Dynamic Pricing 💸")
+st.subheader("Setting optimal prices with Bayesian stats 📈")
+
+# (1) Intro
+st.header("Let's start with the basics 🏁")
+
+st.markdown("The beginning is usually a good place to start so we'll kick things off there.")
+st.markdown("""The one crucial piece information we need to find the optimal price is
+**how demand behaves over different price points**.  \nIf we can get make a decent guess of what we 
+can expect demand to be for a wide range of prices, we can figure out which price optimizes our target
+(i.e., revenue, profit, ...).""")
+st.markdown("""For the keen economists amongst you, this is beginning to sound a lot like a
+**demand curve**.""")
+
+st.markdown("""Estimating a demand curve, sounds easy enough right?  \nLet's assume we have 
+demand with constant price elasticity; so a certain percent change in price will cause a
+constant percent change in demand, independent of the price level. This is often seen as a 
+reasonable proxy for demand curves in the wild.""")
+st.markdown("So our data will look something like this:")
+st.image("assets/images/ideal_case_demand.png")
+st.markdown("""Alright now we can get out our trusted regression toolbox and fit a nice curve 
+through the data because we know that our constant-elasticity demand function looks something 
+like this:""")
+st.latex(sympy.latex(sympy.Eq(sympy.Function(D)(p), a*p**(-eta), evaluate=False))) 
+st.write("with shape parameter a and price elasticity η")
+st.image("assets/images/ideal_case_demand_fitted.png")
+st.markdown("""Now that we have a reasonable estimate of our demand, we can derive our expected
+profit at different price points because we know the following holds:""")
+st.latex(f"{profit} = {p}*{sympy.Function(D)(p)} - [{var_cost}*{sympy.Function(D)(p)} + {fixed_cost}]")
+st.image("assets/images/ideal_case_profit_curve.png")
+st.markdown("""Finally we can dust off our good old-fashioned high-school math and find the
+price which we expect will optimize profit which is ultimately the goal of all this.""")
+st.image("assets/images/ideal_case_optimal_profit.png")
+st.markdown("""Voilà there you have it: we should price this product at 4.24 and we can expect
+a bottom-line profit of 7.34""")
+st.markdown("So can we kick back & relax now?  \nWell, there are a few issues with what we just did.")
+
+# (2) Dynamic demand curves
+st.header("The demands they are a-changin' 🎸")
+st.markdown("""We've got a first bit of bad news: unfortunately, you can't just estimate a demand 
+curve once and be done with it.  \nWhy? Because demand is influenced by many factors (e.g., market
+trends, competitor actions, human behavior, etc.) that tend to change a lot over time.""")
+st.write("Below you can see an (exaggerated) example of what we're talking about:")
+
+with open("assets/images/dynamic_demand.gif", "rb") as file_:
+    contents = file_.read()
+    data_url = base64.b64encode(contents).decode("utf-8")
+
+st.markdown(
+    f'<img src="data:image/gif;base64,{data_url}" alt="dynamic demand">',
+    unsafe_allow_html=True,
+)
+st.markdown("""Now, you may think we can solve this issue by periodically re-estimating the demand 
+curve.  \nAnd you would be very right! But also very wrong as this leads us nicely to the 
+next issue.""")
+
+# (3) Constrained data
+st.header("Where are we getting this data anyways? 🤔")
+st.markdown("""So far, we have assumed that we get (and keep getting) data on demand levels at
+different price points.  \n
+Not only is this assumption **unrealistic**, it is also very **undesirable**""")
+st.markdown("""Why? Because getting demand data on a wide spectrum of price points implies that
+we are spending a significant amount of time setting prices at levels that are either too high or
+too low!  \n
+Which is ironically exactly the opposite of what we set out to achieve.""")
+st.markdown("In practice, our demand will rather look something like this:")
+st.image("assets/images/realistic_demand.png")
+st.markdown("""As we can see, we have tried three price points in the past (€7.5, €10 and €11) for 
+which we have collected demand data.""")
+st.markdown("""On a side note: keep in mind that we still assume the same latent demand curve and
+optimal price point of €4.24  \n
+So (for the sake of the example) we have been massively overpricing our product in the past""")
+st.image("assets/images/realistic_demand_latent_curve.png")
+st.markdown("""This constrained data brings along a major challenge in estimating the demand curve 
+though.  \n
+Intuitively, it makes sense that we can make a reasonable estimate of expected demand at €8 or €9,
+given the observed demand at €7.5 and €10.  \nBut can we extrapolate further to €2 or €20 with the 
+same reasonable confidence?""")
+st.markdown("""This is a nice example of a very well-known problem in statistics called the 
+**\"exploration-exploitation\" trade-off**  \n
+👉 **Exploration**: We want to explore the demand for a diverse enough range of price points
+so that we can accurately estimate our demand curve.  \n
+👉 **Exploitation**: We want to exploit all the knowledge we have gained through exploring and
+actually do what we set out to do: set our price at an optimal level.""")
+
+# (4) Thompson sampling explanation
+st.header("Enter: Thompson Sampling 📊")
+st.markdown("""As we mentioned, this is a well-known problem in statistics. So luckily for us, 
+there is a pretty neat solution in the form of **Thompson sampling**!""")
+st.markdown("""Basically instead of estimating one demand function based on the data available to 
+us, we will estimate a probability distribution of demand functions or simply put, for every 
+possible demand function that fits our functional form (i.e. constant elasticity) 
+we will estimate the probability that it is the correct one, given our data.""")
+st.markdown("""Or mathematically speaking, we will place a prior distribution on the parameters
+that define our demand function and update these priors to posterior distributions via Bayes rule,
+thus obtaining a posterior distribution for our demand function""")
+st.markdown("""Thompson sampling then entails just sampling a demand function out of this 
+distribution, calculating the optimal price given this demand function, observing demand for this
+new price point and using this information to refine our demand function estimates.""")
+st.image("assets/images/flywheel_1.png")
+st.markdown("""So:  \n
+👉 When we are **less certain** of our estimates, we will sample more diverse demand functions, 
+which means that we will also explore more diverse price points. Thus, we will **explore**.  \n
+👉 When we are **more certain** of our estimates, we will sample a demand function close to 
+the real one & set a price close to the optimal price more often. Thus, we will **exploit**.""")
+
+st.markdown("""With that said, we'll take another look at our constrained data and see whether
+Thompson sampling gets us any closer to the optimal price of €4.24""")
+st.image("assets/images/realistic_demand_latent_curve.png")
+st.markdown("""Let's start working our mathemagic:  \n
+We'll start off by placing semi-informed priors on the parameters that make up our 
+demand function.""")
+
+st.latex(f"{sympy.latex(a)} \sim N(μ=0,σ=2)")
+st.latex(f"{sympy.latex(eta)} \sim N(μ=0.5,σ=0.5)")
+st.latex("sd \sim Exp(\lambda=1)")
+st.latex(f"{sympy.latex(D)}|P=p \sim N(μ={sympy.latex(a*p**(-eta))},σ=sd)")
+
+st.markdown("""These priors are semi-informed because we have the prior knowledge that 
+price elasticity is most likely between 0 and 1. As for the other parameters, we have little
+knowledge about them so we can place a pretty uninformative prior.""")
+st.markdown("If that made sense to you, great. If it didn't, don't worry about it")
+
+st.markdown("""Now that are priors are taken care of, we can update these beliefs by incorporating
+the data at the €7.5, €10 and €11 price levels we have available to us.""")
+st.markdown("The resulting demand & profit curve distributions look a little something like this:")
+st.image(["assets/images/posterior_demand.png", "assets/images/posterior_profit.png"])
+
+st.markdown("""It's time to sample one demand curve out of this posterior distribution.  \n
+The lucky curve is:""")
+st.image("assets/images/posterior_demand_sample.png")
+st.markdown("This results in the following expected profit curve")
+st.image("assets/images/posterior_profit_sample.png")
+st.markdown("""And eventually we arrive at a new price: €5.25! Which is indeed considerably closer
+to the actual optimal price of €4.24""")
+st.markdown("""Now that we have our first updated price point, why stop there? Let's simulate 10 
+demand data points at this price point from out latent demand curve and check whether Thompson 
+sampling will edge us even closer to that optimal €4.24 point""")
+st.image("assets/images/updated_prices_demand.png")
+st.markdown("""We know the drill by down.  \n
+Let's recalculate our posteriors with this extra information.""")
+st.image(["assets/images/posterior_demand_2.png", "assets/images/posterior_profit_2.png"])
+st.markdown("""We immediately notice that the demand (and profit) posteriors are much less spread
+apart this time around which implies that we are more confident in our predictions""")
+st.markdown("Now, we can sample just one curve from the distribution")
+st.image(["assets/images/posterior_demand_sample_2.png", "assets/images/posterior_profit_sample_2.png"])
+st.markdown("""And finally we arrive at a price point of €4.44 which is eerily close to
+the actual optimum of €4.24.""")
+
+# (5) Thompson sampling demo
+st.header("Demo time 🎮")
+st.markdown("Now that we have covered the theory, you can go ahead and try it our for yourself!")
+
+thompson_sampler = ThompsonSampler()
+demo_button = st.checkbox(
+    label='Ready for the Demo? 🤯',
+    help="Starts interactive Thompson sampling demo"
+)
+elasticity = st.slider(
+    "Adjust latent elasticity",
+    key="latent_elasticity",
+    min_value=0.05,
+    max_value=0.95,
+    value=0.15,
+    step=0.05,
+)
+while demo_button:
+    thompson_sampler.run()
+    time.sleep(1)
+
+# (6) Extra topics
+st.header("Some final remarks")
+
+st.markdown("""Because we have purposefully kept the example above quite simple, you may still be
+wondering what happens when added complexities show up.  \n
+Let's discuss some of those concerns FAQ-style:""")
+
+st.subheader("👉 Isn't this constant-elasticity model a bit too simple to work in practice?")
+st.markdown("Brief answer: usually yes it is.")
+st.markdown("""Luckily, more flexible methods exist.  \n
+We would recommend to use Gaussian Processes. We won't go into how these work here but the main idea
+is that it doesn't impose a restrictive functional form onto the demand function but rather lets
+the data speak for itself.""")
+
+with open("assets/images/gaussian_process.gif", "rb") as file_:
+    contents = file_.read()
+    data_url = base64.b64encode(contents).decode("utf-8")
+
+st.markdown(
+    f'<img src="data:image/gif;base64,{data_url}" alt="gaussian process">',
+    unsafe_allow_html=True,
+)
+st.markdown("""If you do want to learn more, we recommend these links: 
+[1](https://distill.pub/2019/visual-exploration-gaussian-processes/),
+[2](https://thegradient.pub/gaussian-process-not-quite-for-dummies/),
+[3](https://sidravi1.github.io/blog/2018/05/15/latent-gp-and-binomial-likelihood)""")
+
+st.subheader("""👉 Price optimization is much more complex than just finding the point that maximizes a simple profit function. What about inventory constraints, complex cost structures, ...?""")
+st.markdown("""It sure is but the nice thing about our setup is that it consists of three 
+components that you can change pretty much independently from each other.  \n
+This means that you can make the price optimization pillar arbitrarily custom/complex. As long as
+it takes in a demand function and spits out a price.""")
+st.image("assets/images/flywheel_2.png")
+st.markdown("You can tune the other two steps as much as you like too.")
+st.image("assets/images/flywheel_3.png")
+
+st.subheader("👉 Changing prices has a huge impact. How can I mitigate this during experimentation?")
+st.markdown("There are a few things we can do to minimize risk:")
+st.markdown("""👉 **A/B testing**: You can do a gradual roll-out of the new pricing system where a
+small (but increasing) percentage of your transactions are based on this new system. This allows you
+to start small & track/grow the impact over time.""")
+st.markdown("""👉 **Limit products**: Similarly to A/B testing, you can also segment on the 
+product-level. For instance, you can start gradually rolling out dynamic pricing for one product 
+type and extend this over time.""")
+st.markdown("""👉 **Bound price range**: Theoretically, Thompson sampling in its purest form can 
+lead to any arbitrary price point (albeit with an increasingly low probability). In order to limit
+the risk here, you can simply place a upper/lower bound on the price range you are comfortable
+experimenting in.""")
+st.markdown("""On top of all this, Bayesian methods (by design) explicitly quantify uncertainty. 
+This allows you to have a very concrete view on the variance of our demand estimates""")
+
+st.subheader("👉 What if I have multiple products that can cannibalize each other?")
+st.markdown("Here it really depends")
+st.markdown("""👉 **If you have a handful of products**, we can simply reformulate our objective while 
+keeping our methods analogous.  \n
+Instead of tuning one price to optimize profit for the demand function of one product, we tune N 
+prices to optimize profit for the joint demand function of N products. This joint demand function 
+can then account for correlations in demand within products.""")
+st.markdown("""👉 **If you have hundreds, thousands or more products**, we're sure you can imagine that 
+the procedure described above becomes increasingly infeasible.  \n
+A practical alternative is to group substitutable products into "baskets" and define the "price of
+the basket" as the average price of all products in the basket.  \n
+If we assume that the products in baskets are subtitutable but the products in different baskets are
+not, we can optimize basket prices indepedently from one another.  \n
+Finally, if we also assume that cannibalization remains constant if the ratio of prices remains 
+constant, we can calculate individual product prices as a fixed ratio of its basket price.  \n""")
+st.markdown("""For example, if a "burger basket" consists of a hamburger (€1) and a cheeseburger 
+(€3), then the "burger price" is ((€1 + €3) / 2 =) €2. So a hamburger costs 50% of the burger price 
+and a cheeseburger costs 150% of the burger price.  \n
+If we change the burger's price to €3, a hamburger will cost (50% * €3 =) €1.5 and a cheeseburger
+will cost (150% * €3 =) €4.5 because we assume that the cannibalization effect between hamburgers & 
+cheeseburgers is the same when hamburgers cost €1 & cheeseburgers cost €3 and when hamburgers cost
+€1.5 & cheeseburgers cost €4.5""")
+st.image("assets/images/cannibalization.png")
+
+st.subheader("👉 Is dynamic pricing even relevant for slow-selling products?")
+st.markdown("""The boring answer is that it depends. It depends on how dynamic the market is, the
+quality of the prior information, ...""")
+st.markdown("""But obviously this isn't very helpful.  \nIn general, we notice that you can already 
+get quite far with limited data, especially if you have an accurate prior belief on how the demand
+likely behaves.""")
+st.markdown("""For reference, in our simple example where we showed a Thompson sampling update, we 
+were already able to gain a lot of confidence in our estimates with just 10 extra demand 
+observations.""")

assets/precalc_results/posterior_0.05.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f67a5aad9591a4c65856ba0a9577e17defdb076631685d2e8dabb186a9d0c46e
+size 4284392

assets/precalc_results/posterior_0.1.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dcf55382b9dfc8fe527ba19d4a825eb2611e1dbe65689c8b673abb1aae9ffc2
+size 4284392

assets/precalc_results/posterior_0.15.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:972b1d1d4c4a4765172b16acab7de44daee92b86c455f62b80d499992b0323cf
+size 4284392

assets/precalc_results/posterior_0.2.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc48fe2c018588887488477ab37fcb3524d2bfda584119bd2c7d28b4393bc523
+size 4284392

assets/precalc_results/posterior_0.25.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9be07516c741b95ef5b9ecfeeabf8daa09691843ada1aa5da4e99d865285be8c
+size 4284392

assets/precalc_results/posterior_0.3.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:859c2422cc36d19441bc176820a3f686a4c44ceaa99466ac3a1daa39704127ff
+size 4284392

assets/precalc_results/posterior_0.35.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfde23737ffcc92c6623d2a2ea107bdf1e126730573da40a2a72f9fe0c4559fa
+size 4284392

assets/precalc_results/posterior_0.4.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6d12e42761d4b92c39f6568b1fe473d3ed9a7b590c32c23375ed06b7cbf7ef7
+size 4284392

assets/precalc_results/posterior_0.45.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a258c4695a392a24b090927444c0a3c25aa9508b36c8558b42844552f2e6a980
+size 4284392

assets/precalc_results/posterior_0.5.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f67fd5ca0f744f1f17e725b3efeb2e30b41117e8ed2f8f62ffdc531bff1c669a
+size 4284392

assets/precalc_results/posterior_0.55.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be1fe091349573f37b4b8b8062805e78d860d8e3c3f2899223bad65c1abdb0ba
+size 4284392

assets/precalc_results/posterior_0.6.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58bd0daad50052e0b6b706f642a4acf35ba065437d1181dcf361019e90688adb
+size 4284392

assets/precalc_results/posterior_0.65.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2f44e9b821e0a302b8a9a869aa649d391a2a64335264425210e6a8a736c3670
+size 4284392

assets/precalc_results/posterior_0.7.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3fead4ab62f4cd4d6f1bff729ee033deca2e8ed7d6b0f9aa68b2371d61d412e1
+size 4284392

assets/precalc_results/posterior_0.75.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aff1524ebc87a8077a2ff2bf999b3561183500009e782c612c7cfda719b8e8c2
+size 4284392

assets/precalc_results/posterior_0.8.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fd7c5cbe4db7d02635ed89b6a25c61f03d4a8727e399b6a506055bdd3571e8f
+size 4284392

assets/precalc_results/posterior_0.85.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf6a6249e9946df213688e1d89325a1e69d9f74372c2b759269b6552ad8a15df
+size 4284392

assets/precalc_results/posterior_0.9.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:370a91ed077fd4e89b0fe576b9427731181d07d00d861a57b032ad4e317d0754
+size 4284392

assets/precalc_results/posterior_0.95.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc69a5b466f2a5d6a1797617ced35cf6544285d44930d84c9a534af070ba60e6
+size 4284392

config.py

@@ -0,0 +1,8 @@
+"""Configuration variables"""
+
+FIXED_COST = 3
+VARIABLE_COST = 0.2
+
+LATENT_ELASTICITY = 0.25
+LATENT_SHAPE = 2
+LATENT_STDEV = 0.25

helpers/thompson_sampling.py

@@ -0,0 +1,125 @@
+"""Helper file for Thompson sampling"""
+
+import pickle
+import random
+
+import matplotlib.pyplot as plt
+import numpy as np
+import streamlit as st
+
+import config as cfg
+
+random.seed(42)
+
+class ThompsonSampler:
+    def __init__(self):
+        self.placeholder = st.empty()
+
+        self.latent_elasticity = cfg.LATENT_ELASTICITY
+        self.price_observations = np.concatenate(
+            [np.repeat(10,10), np.repeat(7.5,25), np.repeat(11,15)]
+        )
+        self.update_demand_observations()
+
+        self.possible_prices = np.linspace(0, 20, 100)
+        self.price_samples = []
+        self.latent_demand = self.calc_latent_demand()
+        self.latent_price = self.calc_optimal_price(self.latent_demand, sample=False)
+        self.update_posteriors()
+
+    def update_demand_observations(self):
+        self.demand_observations = np.exp(
+            np.random.normal(
+                loc=-self.latent_elasticity*self.price_observations+cfg.LATENT_SHAPE,
+                scale=cfg.LATENT_STDEV,
+            )
+        )
+
+    def update_elasticity(self):
+        self.latent_elasticity = st.session_state.latent_elasticity
+        self.price_samples = []
+        self.latent_demand = self.calc_latent_demand()
+        self.update_demand_observations()
+        self.latent_price = self.calc_optimal_price(self.latent_demand, sample=False)
+        self.update_posteriors(samples=75)
+        self.create_plots()
+
+    def create_plots(self, highlighted_sample=None):
+        with self.placeholder.container():
+            posterior_plot, price_plot = st.columns(2)
+            with posterior_plot:
+                st.markdown("## Demands")
+                fig = self.create_posteriors_plot(highlighted_sample)
+                st.write(fig)
+                plt.close(fig)
+            with price_plot:
+                st.markdown("## Prices")
+                fig = self.create_price_plot()
+                st.write(fig)
+                plt.close(fig)
+
+    def create_price_plot(self):
+        fig = plt.figure()
+        plt.xlabel("Price")
+        plt.yticks(color='w')
+
+        price_distr = [self.calc_optimal_price(post_demand, sample=False)
+                       for post_demand in self.posterior]
+        plt.violinplot(price_distr, vert=False, showextrema=False)
+
+        for price in self.price_samples:
+            plt.plot(price, 1, marker='o', markersize = 5, color='grey')
+
+        plt.axhline(1, color='black')
+        plt.axvline(self.latent_price, 0, color='red')
+
+        return fig
+
+    def create_posteriors_plot(self, highlighted_sample=None):
+        fig = plt.figure()
+        plt.xlabel("Price")
+        plt.ylabel("Demand")
+        plt.xlim(0,20)
+        plt.ylim(0,10)
+
+        plt.scatter(self.price_observations, self.demand_observations)
+        plt.plot(self.possible_prices, self.latent_demand, color="red")
+
+        for posterior_sample in self.posterior_samples:
+            plt.plot(self.possible_prices, posterior_sample, color="grey", alpha=0.15)
+        if highlighted_sample is not None:
+            plt.plot(self.possible_prices, highlighted_sample, color="black")
+        return fig
+
+    def calc_latent_demand(self):
+        return np.exp(
+            -self.latent_elasticity*self.possible_prices + cfg.LATENT_SHAPE
+        )
+
+    @staticmethod
+    @np.vectorize
+    def _cost(demand):
+        return cfg.VARIABLE_COST*demand + cfg.FIXED_COST
+
+    def calc_optimal_price(self, sampled_demand, sample=False):
+        revenue = self.possible_prices * sampled_demand
+        profit = revenue - self._cost(sampled_demand)
+        optimal_price = self.possible_prices[np.argmax(profit)]
+        if sample:
+            self.price_samples.append(optimal_price)
+        return optimal_price
+
+    def update_posteriors(self, samples=75):
+        with open(f"assets/precalc_results/posterior_{self.latent_elasticity}.pkl", "rb") as post:
+            self.posterior = pickle.load(post)
+        self.posterior_samples = random.sample(self.posterior, samples)
+
+    def pick_posterior(self):
+        posterior_sample = random.choice(self.posterior_samples)
+        self.calc_optimal_price(posterior_sample, sample=True)
+        self.create_plots(highlighted_sample=posterior_sample)
+
+    def run(self):
+        if st.session_state.latent_elasticity != self.latent_elasticity:
+            self.update_elasticity()
+        self.pick_posterior()

requirements.txt

@@ -0,0 +1,3 @@
+pymc3==3.11.5
+streamlit==1.13.0
+sympy==1.10.1

scripts/generate_posterior.py

@@ -0,0 +1,33 @@
+"""Script that generates, pickles and stores posterior data"""
+
+import pickle
+
+import numpy as np
+
+import config as cfg
+from scripts.posterior import PosteriorGenerator
+
+np.random.seed(42)
+
+if __name__ == '__main__':
+    demo_prices = np.concatenate([np.repeat(10,10), np.repeat(7.5,25), np.repeat(11,15)])
+    possible_prices = np.linspace(0,20,100)
+
+    for el in [x/100 for x in range(5,100,5)]:
+        demo_demands = np.exp(
+            np.random.normal(
+                loc=-el*demo_prices+cfg.LATENT_SHAPE,
+                scale=cfg.LATENT_STDEV,
+            )
+        )
+        ts = PosteriorGenerator(prices=demo_prices, demands=demo_demands)
+        posterior = ts.calc_posterior(samples=5000)
+        post_demand_samples = []
+        for idx in range(len(posterior)):
+            elas = posterior.get_values("elas")[idx]
+            shape = posterior.get_values("shape")[idx]
+            post_demand_sample = np.exp(elas*possible_prices + shape)
+            post_demand_samples.append(post_demand_sample)
+
+        with open(f"assets/precalc_results/posterior_{el}.pkl", 'wb') as f:
+            pickle.dump(post_demand_samples, f)

scripts/posterior.py

@@ -0,0 +1,19 @@
+"""File for updating prior into posterior"""
+
+import pymc3 as pm
+
+class PosteriorGenerator:
+    def __init__(self, prices, demands):
+        self.price_observations = prices
+        self.demand_observations = demands
+
+    def calc_posterior(self, samples=1000):
+        with pm.Model():
+            elas = pm.Normal("elas",mu=-0.5, sd=0.5)
+            shape = pm.Normal("shape",mu=0, sd=2)
+            stdev = pm.Exponential("stdev",lam=1)
+            y_hat = pm.math.dot(elas, self.price_observations) + shape
+            log_observations = pm.math.log(self.demand_observations)
+            _ = pm.Normal("demand", mu=y_hat, observed=log_observations, sigma=stdev)
+            trace = pm.sample(samples)
+        return trace