dynpricepy package¶
Submodules¶
dynpricepy.agent module¶
-
class
dynpricepy.agent.
AgentBehaviour
(probability_model, **kwargs)¶ Bases:
object
object which contains the modelisation of the market we want to price Future : maybe the modelisation of the behaviour of each individual composing the market
>>> def probability_model(t, price, date): ... return np.exp(-price) >>> agent_behaviour = AgentBehaviour(probability_model=probability_model) >>> agent_behaviour.compute_selling_probability(t=2, price=np.array(1,2), date=None)
Parameters: - probability_model (python callable object) – a python callable object with at least t, price and date as argument, which should always return results between 0 and 1
- kwargs (function parameters) – additional parameters directly passed to the probability_model:
-
compute_selling_probability
(t, price, date=None)¶ Compute the probability to sell an item at time t, price price, date date, and other parameters if specified during class init Not used by user
Parameters: - t (int, > 0) – the step from the begining of the price path
- price (float or numpy array) – the price we want to estimate the probability to book
- date (datetime or date) – the date of the price step
Returns: probability to sell one good at price price, computed from the model probability_model passed in init
Return type: float or numpy array, with element between 0 and 1
dynpricepy.price_path module¶
-
class
dynpricepy.price_path.
PricePath
(agent_behavior, min_price_start=0, max_price_start=1, max_price_search=0.3, min_price_search=0.3, price_step=0.01)¶ Bases:
object
A pricing path is a sequence of prices to apply at each time step. The optimal pricing path is optimal in the following sense: We have n days to sell an item, we know the demand price elasticity \(\mathbb{P}[\text{sell}; t,p_t]\), so \(p_0, ..., p_n\) are defined such that
\[{p_0, ..., p_n} = argmax_{p_0, ..., p_n} \sum_{t=0}^{n} p_t \mathbb{P}[\text{sell}; t,p_t] \prod_{i>t} (1-\mathbb{P}[\text{sell}; i, p_i])\]for an inventory of size 1, or more generally,
…
The order of the prices step are always ordered descending along the date : t=0 correspond the perish date of the items we are selling.
Example : we want to sell an item which perish on 2018-01-20, starting on 2018-01-01. Thus we have to price for 2018-01-01, 2018-01-02, …, 2018-01-20. The price path is therefore a list where for each date, t is the time remaining : 20, 19, …, 0, and the price is the optimal price to apply. The index 0 correspond to the last day available to sell
Dev information : - the list is ordered is reverse order : (t=0, t=1, t=2, …, t=20)
Parameters: - min_price_start (float) – the lower bound for the price for t=0
- max_price_start (float) – the upper bound for price for t=0
- min_price_search (float) – the maximum difference between the previous optimal price and the new searched
- max_price_search (float) – the maximum difference between the previous optimal price and the new searched
- price_step (float) – the discretisation step for price grid search
- agent_behavior (AgentBehaviour) – AgentBehaviour instance, which provide demand and offer or directly probability
-
compute_price_path
(t, start_date=datetime.date(2017, 12, 28), date_step=datetime.timedelta(1), n=1)¶ Compute and store the optimal price path as defined before. This method handles multiple items, whereas the price is independant of the remaining items. Can be deprecated later if not useful.
\[V(i,j) = P(i,j) =\]Parameters: - t (int) – number of step to compute
- start_date (date or datetime) – the starting date (default today)
- date_step (timedelta) – the timedelta between two step (default one day)
- n (int) – number of items we have to sell (default 1)
Raises: ValueError – if the number of step provided is < 0
-
compute_price_path_one
(t, start_date=datetime.date(2017, 12, 28), date_step=datetime.timedelta(1))¶ Compute and store the optimal price path as defined before. This method handles only 1 item to sell. The price path is computed as followed :
\[ \begin{align}\begin{aligned}p_0 = argmax_{p} p \mathbb{P}[\text{sell};p,0] + \text{future income} (1 - \mathbb{P}[\text{sell};p,0])\\\text{future income} = p_0 \mathbb{P}[\text{sell};p_0,0] + \text{future income} (1 - \mathbb{P}[\text{sell};p_0,0])\\\forall i > 0, p_i = argmax_{p} p \mathbb{P}[\text{sell};p,0] + \text{future income} (1 - \mathbb{P}[\text{sell};p,0])\\\forall i > 0, \text{future income} = p_i \mathbb{P}[\text{sell};p_i,i] + \text{future income} (1 - \mathbb{P}[\text{sell};p_i,i])\end{aligned}\end{align} \]Parameters: - t (int) – number of step to compute
- start_date (date or datetime) – the starting date (default today)
- date_step (timedelta) – the timedelta between two step (default one day)
Raises: ValueError – if the number of step provided is < 0
>>> price_path.compute_price_path_one(t=4) >>> print(price_path) Time 0, date 2017-12-27, price 0.990, selling probability 0.372, sold rate 0.696, sell today probability 0.180 Time 1, date 2017-12-28, price 1.290, selling probability 0.275, sold rate 0.517, sell today probability 0.184 Time 2, date 2017-12-29, price 1.590, selling probability 0.204, sold rate 0.333, sell today probability 0.171 Time 3, date 2017-12-30, price 1.820, selling probability 0.162, sold rate 0.162, sell today probability 0.162
-
compute_sell_today_probability
()¶ Compute and store the probability to effectively selling the item exactly at time t for each time t in each price step instance
\[\mathbb{P}[\text{sell at t}; \text{not sell before t}]\]
-
compute_sold_rate
()¶ Compute and store the probability to have sold the item at time t in each price step instance
\[\mathbb{P}[\text{sell at t or t+1 or ... or n}]\]
-
expected_revenue
()¶ The expected revenue of selling one item when following the optimal price price computed:
\[\mathbb{E}[\text{revenue}] = \sum_{t=0}^n p_t \mathbb{P}[\text{sell};p_t,t]\]Returns: the expected revenue Return type: float Raises: ValueError – when the price path has not been computed yet
-
to_dataframe
()¶ The dataframe representation of the price path.
Returns: the dataframe representation of the price path Return type: pandas dataframe Raises: ValueError – if the price path has not been computed yet
dynpricepy.pricing_step module¶
-
class
dynpricepy.pricing_step.
PricingStep
(t, price, selling_probability, date=None)¶ Bases:
object
Object representing at a specific time the price to apply, and some related information about the probability to sell an item
>>> step = PricingStep(t=0, price=0.4, selling_probability=0.1, date=datetime.date.today())
Parameters: - t (int, > 0) – represents the place of the pricing step in the whole price path, where t=0 represents the perish date of the item
- price (float) – the optimal price to set in order to satifsy the dynamic pricing problem
- selling_probability (float, between 0 and 1) – the probability to sell an item at price price, provided by the agent model
- date (datetime or date) – the associated date to the price step (None if not provided)
Returns: PricingStep instance
Return type: Raises: - ValueError – if the provided probability is not between 0 and 1
- ValueError – if t < 0
-
expected_revenue
()¶ The expected income from the date associated to the pricing step. Computed by:
\[p_t P[\text{sell at t}; \text{not sold at }t'>t]\]>>> step.expected_revenue()
Returns: the expected income Return type: float