{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Agent-based Land MArket (ALMA)\n",
"\n",
"The Agent-based Land MArket (ALMA) model is a \"bilateral agent-based land market model, which moves beyond previous work by explicitly modeling behavioral drivers of land-market transactions on both the buyer and seller sides; formation of bid prices (of buyers) and ask prices (of sellers); and the relative division of the gains from trade from the market transactions\" ([Filatova, Parker, and van der Veen](http://jasss.soc.surrey.ac.uk/12/1/3.html)). The model aims to understand the micro-economic decision-making that results in the emergent behavior described as the \"rent gradient.\"\n",
"\n",
"\n",
"\n",
"[Image Source: Wikipedia](https://en.wikipedia.org/wiki/Bid_rent_theory)\n",
"\n",
"[Bid-rent theory](https://en.wikipedia.org/wiki/Bid_rent_theory) describes a geographical economy theory that was developed by William Alsono in his book *Location and Land Use.* It asserts that the demand for and price of land in and around cities is a function of distance from the Central Business District (CBD) of the urban center. The relationship between distance from the CBD and land price/rent prices is referred to as the \"rent gradient.\"\n",
"\n",
"In this notebook we will work with a slightly expanded version of the ALMA model that introduces more stochasticity and heterogeniety, to understand how the rent gradient changes under various settings.\n",
"\n",
"* [A conceptual design for a bilateral agent-based land market with heterogeneous economic agents](https://doi.org/10.1016/j.compenvurbsys.2008.09.012)\n",
"* [Agent-Based Urban Land Markets: Agent's Pricing Behavior, Land Prices and Urban Land Use Change](http://jasss.soc.surrey.ac.uk/12/1/3.html)\n",
"* [Location and Land Use](https://www.hup.harvard.edu/catalog.php?isbn=9780674730854)\n",
"\n",
"\n",
""
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import argparse, csv, heapq, json, math, os, random, shutil\n",
"from copy import copy, deepcopy\n",
"import numpy as np\n",
"from numpy import linalg as LA\n",
"from operator import attrgetter\n",
"import pandas as pd\n",
"from time import localtime, strftime\n",
"from tqdm import tqdm\n",
"\n",
"import Viz as viz\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"import ipywidgets as widgets\n",
"from IPython.display import Image, display\n",
"\n",
"\"\"\" Making sure you output folder \"\"\"\n",
"if not os.path.exists(\"./outputs\"):\n",
" os.mkdir(\"./outputs\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Cells\n",
"\n",
"The ALMA model represents land as uniform-size cells. The cells have two main features that derive their worth:\n",
"\n",
"* `Amenity` - some uniformly distributed [amenity](https://en.wikipedia.org/wiki/Amenity).\n",
"* `Proximity` - the relative closeness to the central business district. For cell $i$ with distance from the CBD $D_{i}$, we calculate proximity as:\n",
"\n",
"$$ \\bar{P}_{i}=D_{max}+1-D_{i}$$\n",
"\n",
"$$ P=\\bar{P}_{i}/\\bar{P}_{max}$$\n",
"\n",
"This gives us a relative measure $\\bar{P}\\in[0,1]$ where low values represent far from the CBD and high values represent low distance from the CBD.\n",
"\n",
"The `transact` function allows a sell to transfer owners. Under the ALMA framework, the top bid is chosen and the transaction price is the average between the ask and the bid."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"class Cell:\n",
"\n",
" def __init__(self, args):\n",
" self.amenity = args[\"amenity\"] # vector of floats\n",
" self.cbd = args[\"cbd\"] # vector of floats\n",
" self.id = args[\"id\"] # int\n",
" self.location = args[\"location\"] # tuple\n",
" self.market_price = 0.0 # float\n",
" self.owner = args[\"owner\"] # int\n",
" self.wta = args[\"wta\"]\n",
" self.p_ask = self.wta\n",
" # optional args\n",
" if \"on_market\" in args:\n",
" self.on_market = args[\"on_market\"]\n",
" else:\n",
" self.on_market = False\n",
" # data structures\n",
" self.bids = [] # stack of bids\n",
" # calculate distance and proximity\n",
" self.distance = float(\"inf\")\n",
" self.proximity = float(\"inf\")\n",
"\n",
" def __repr__(self):\n",
" return \"Cell {} at {} owned by {}\\n Amenity: {}\\n CBD: {}\\n Prox: {}\".format(self.id,self.location,self.owner,self.amenity, self.cbd, self.proximity)\n",
"\n",
" def __str__(self):\n",
" return self.__repr__()\n",
"\n",
" def get_location(self):\n",
" return deepcopy(self.location)\n",
"\n",
" def transact(self, bid, owner):\n",
" self.market_price = (self.p_ask+bid[\"bid\"])/2.0\n",
" self.on_market = False\n",
" self.owner = bid[\"bidder\"]\n",
"\n",
" def update_market_status(self, on_market, epsilon):\n",
" self.on_market = on_market\n",
" if on_market:\n",
" self.p_ask = self.wta*(1+epsilon)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"\n",
"## Agents\n",
"\n",
"Agents in the model can either be buyers or sellers. \n",
"\n",
"### Buyers\n",
"\n",
"Buyers want to find the best cell for them and buy it using their budget. They have a set of preferences It is assumed for this model that the housing budget is separable. To determine the best sell for them, they calculate the *utility* (usefullness) of each cell using the following formula:\n",
"\n",
"$$A^{\\alpha}\\times P^{\\beta}$$\n",
"\n",
"where A is the cell's level of amenity, P is the proximity, and $\\alpha,\\beta$ are the buyer's amenity and proximity preferences respectively. Once a cell is selected, the amount that can be spent on the land ($Y$) is calculated by subtracting transportation costs ($T(D)=cost\\times D$) from the housing budget ($Y_{housing}$). This is then used to calculate how much the buyer is willing to pay (WTP) using:\n",
"\n",
"$$WTP=\\frac{Y\\cdot U^{2}}{b^{2}+U^{2}}$$\n",
"\n",
"Where $b$ is a parameter called \"affordability.\" Lastly, the WTP value is used to calculate the buyer's bid which encorporates the market's state (the number of buyers (NB) vs the level of sellers (NS)). The formula becomes:\n",
"\n",
"$$P_{bid}=WTP\\cdot (1+\\epsilon), \\text{ where } \\epsilon=\\frac{NB-NS}{NB+NS}$$\n",
"\n",
"### Sellers\n",
"\n",
"Sellers each own a single piece of land and are willing to accept some value $WTA$ (usually set to 250). Sellers also use the market state (as measured by $\\epsilon$) to determine their asking price:\n",
"\n",
"$$P_{ask}=WTA\\cdot(1+\\epsilon)$$"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"class Person:\n",
"\n",
" def __init__(self, args):\n",
" self.affordability = args[\"affordability\"]\n",
" self.budget = args[\"budget\"]\n",
" self.buying = args[\"buying\"]\n",
" self.distance_cost = args[\"distance_cost\"]\n",
" self.id = args[\"id\"]\n",
" self.selling = args[\"selling\"]\n",
" self.cell = None\n",
" self.utility = -1 # record utility of cell if purchases one\n",
" # preferences\n",
" self.amenity_preference = args[\"amenity\"] # float\n",
" self.proximity_preference = args[\"proximity\"] # float\n",
" # data structures\n",
" self.bids = [] # list of outstanding bids\n",
"\n",
" def calculate_utility(self, cell):\n",
" return np.power(cell.amenity, self.amenity_preference)*np.power(cell.proximity, self.proximity_preference)\n",
"\n",
" def evaluate_cells(self, cells):\n",
" best_cell, best_utility = None, 0\n",
" for cell in cells:\n",
" utility = self.calculate_utility(cell)\n",
" if utility > best_utility:\n",
" best_cell, best_utility = cell, utility\n",
" if best_cell != None:\n",
" self.utility = best_utility\n",
" _u_squared=math.pow(best_utility,2)\n",
" _y=self.budget-(self.distance_cost*best_cell.distance)\n",
" _wtp = (_y*_u_squared)/(math.pow(self.affordability,2)+_u_squared)\n",
" return best_cell.id, _wtp\n",
" else:\n",
" self.utility = -1\n",
" return -1, -1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"\n",
"## Simulation\n",
"\n",
"The simulation is below. The basic steps of the simulation are:\n",
"\n",
"* `init_agents` - setting up the Buyers and Sellers\n",
"* `init_cells` - setting up the Cells\n",
"* `run_simulation` - the loop that allows agents to evaluate cells and allows transactions to happen"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"class Simulation:\n",
"\n",
" def __init__(self, args):\n",
" self.height = args[\"simulation\"][\"height\"]\n",
" self.output_directory = args[\"simulation\"][\"output_directory\"]\n",
" self.sim_length = args[\"simulation\"][\"sim_length\"]\n",
" self.width = args[\"simulation\"][\"width\"]\n",
" # UI arguments:\n",
" self.gif = args[\"ui\"][\"generate_gif\"]\n",
" self.show_ui = args[\"ui\"][\"show\"]\n",
" self.ui_components = args[\"ui\"][\"components\"]\n",
" self.ui_style = args[\"ui\"][\"style\"]\n",
" # calculated fields\n",
" self.num_cells = self.height * self.width\n",
" self.time = np.arange(0,self.sim_length)\n",
" self.time_step = 0\n",
" DATE = '{}'.format(strftime('%Y-%m-%d_%H:%M:%S', localtime()))\n",
" self.output_directory = os.path.join(\"./outputs/\", \"{}ALMA-{}-({}cells)\".format(self.output_directory,DATE, self.num_cells))\n",
" if not os.path.exists(self.output_directory):\n",
" os.makedirs(self.output_directory)\n",
" # create csv writers\n",
" self.csv_output_files = { \"agents\" : None, \"cells\" : None }\n",
" for key in self.csv_output_files.keys():\n",
" self.csv_output_files[key] = open(os.path.join(self.output_directory, \"{}.csv\".format(key)), \"w+\")\n",
" self.csv_output_writer = {}\n",
" for key in self.csv_output_files.keys():\n",
" self.csv_output_writer[key] = csv.writer(self.csv_output_files[key])\n",
" # setup agents\n",
" self.init_agents(args[\"agents\"])\n",
" self.init_cells(args[\"cells\"])\n",
" self.epsilon_over_time = []\n",
" self.num_buyers, self.num_sellers = [], []\n",
" self.num_neither, self.num_on_market = [], []\n",
" self.run_simulation()\n",
" viz.get_ui(self, show=self.show_ui)\n",
" if self.gif:\n",
" viz.generate_gif(self)\n",
" self.write_out_cells()\n",
" self.write_out_agents()\n",
" for key in self.csv_output_files.keys():\n",
" self.csv_output_files[key].close()\n",
"\n",
" def calculate_proximity(self):\n",
" cbd = [cell for cell in self.cells if cell.cbd == 1].pop()\n",
" self.proximity = []\n",
" max_dist = 0\n",
" for cell in self.cells:\n",
" cell.distance = math.sqrt(sum([(a - b) ** 2 for a, b in zip(cbd.get_location(), cell.get_location())]))\n",
" if cell.distance > max_dist:\n",
" max_dist = cell.distance\n",
" for cell in self.cells:\n",
" cell.proximity = (max_dist - cell.distance)/max_dist\n",
" self.proximity.append(cell.proximity)\n",
"\n",
" def get_agents(self):\n",
" return deepcopy(self.agents)\n",
"\n",
" def get_amenities(self):\n",
" amenities = []\n",
" for i in range(self.num_cells):\n",
" if (i%self.width == 0):\n",
" amenities.append([])\n",
" amenities[int(i/self.width)].append(self.cells[int(self.width*int(i/self.width) + i%self.width)].amenity)\n",
" return deepcopy(amenities)\n",
"\n",
" def get_market_prices(self):\n",
" market_prices = []\n",
" for i in range(self.num_cells):\n",
" if (i%self.width == 0):\n",
" market_prices.append([])\n",
" market_prices[int(i/self.width)].append(self.cells[int(self.width*int(i/self.width) + i%self.width)].market_price)\n",
" return deepcopy(market_prices)\n",
"\n",
" def get_proximities(self):\n",
" proximities = []\n",
" for i in range(self.num_cells):\n",
" if (i%self.width == 0):\n",
" proximities.append([])\n",
" proximities[int(i/self.width)].append(self.cells[int(self.width*int(i/self.width) + i%self.width)].proximity)\n",
" return deepcopy(proximities)\n",
"\n",
" def init_agents(self, args):\n",
" self.buyer_level = args[\"buyer_level\"]\n",
" _num_buyers = int(self.num_cells*self.buyer_level)\n",
" _num_sellers = int(self.num_cells)\n",
" self.num_agents = _num_buyers + _num_sellers\n",
" self.agents = []\n",
" for i in range(self.num_agents):\n",
" alpha = random.uniform(0,args[\"alpha_max\"])\n",
" _budget = int(random.uniform(args[\"budget_parameters\"][0], args[\"budget_parameters\"][1]))\n",
" buying = True if i < _num_buyers else False\n",
" self.agents.append(Person({ \"affordability\" : copy(args[\"affordability\"]),\n",
" \"amenity\": alpha,\n",
" \"budget\" : _budget,\n",
" \"buying\" : buying,\n",
" \"distance_cost\" : copy(args[\"distance_cost\"]),\n",
" \"id\" : copy(i),\n",
" \"proximity\" : random.uniform(0,(1-alpha)),\n",
" \"selling\" : not buying\n",
" }))\n",
"\n",
" def init_cells(self, args):\n",
" self.cells = []\n",
" for i in range(self.num_cells):\n",
" cell_args = {\n",
" \"amenity\" : random.uniform(0,1),\n",
" \"cbd\" : 0,\n",
" \"id\" : i,\n",
" \"location\": (i//self.width,i%self.width),\n",
" \"owner\" : 0,\n",
" \"wta\" : float(args[\"wta\"])\n",
" }\n",
" self.cells.append(Cell(deepcopy(cell_args)))\n",
" cbd = int(self.width*int(self.height/2)+(self.width/2))\n",
" self.cells[cbd].cbd = 1\n",
" self.calculate_proximity()\n",
" _buyers = [ agent.id for agent in self.agents if agent.buying ]\n",
" _sellers = [ agent.id for agent in self.agents if agent.selling ]\n",
" for i in range(len(self.cells)):\n",
" choice = random.choice(_sellers)\n",
" self.cells[i].owner = choice\n",
" self.agents[choice].cell = i\n",
" _sellers.remove(choice)\n",
" self.epsilon=(len(_buyers)-len(_sellers))/(len(_buyers)+len(_sellers))\n",
"\n",
" def run_simulation(self):\n",
" viz.plot_cells(self,\"Amenity\", self.ui_components)\n",
" viz.plot_cells(self,\"Proximity\", self.ui_components)\n",
" transaction_counts = []\n",
" for time_step in tqdm(range(self.sim_length), position = 0, desc=\"Simulation:\"):\n",
" self.time_step = time_step\n",
" # reset bids:\n",
" for i in range(len(self.cells)):\n",
" self.cells[i].bids = []\n",
" # sellers form ask\n",
" for i in range(len(self.agents)):\n",
" if self.agents[i].selling:\n",
" self.cells[self.agents[i].cell].update_market_status(True, self.epsilon)\n",
" # get statistics and setup for time step\n",
" self.buyers = [ agent.id for agent in self.agents if agent.buying ]\n",
" self.num_buyers.append(len(self.buyers))\n",
" self.sellers = [ agent.id for agent in self.agents if agent.selling ]\n",
" self.num_sellers.append(len(self.sellers))\n",
" self.num_neither.append(self.num_agents-(self.num_buyers[time_step]+self.num_sellers[time_step]))\n",
" self.num_on_market.append(len([cell for cell in self.cells if cell.on_market ]))\n",
" self.epsilon=(self.num_buyers[time_step]-self.num_sellers[time_step])/(self.num_buyers[time_step]+self.num_sellers[time_step])\n",
" self.epsilon_over_time.append(self.epsilon)\n",
" # buyers form bid\n",
" for i in self.buyers:\n",
" _cell, _wtp = self.agents[i].evaluate_cells(deepcopy([ cell for cell in self.cells if (cell.on_market and cell.owner != i) ]))\n",
" if _cell != -1:\n",
" self.cells[_cell].bids.append({ \"bid\" : _wtp*(1+self.epsilon), \"bidder\" : i, \"cell\" : _cell })\n",
" # negotiate\n",
" transactions = 0\n",
" for i in self.sellers:\n",
" cell = self.agents[i].cell\n",
" if len(self.cells[cell].bids) > 0:\n",
" _max_bid = max(self.cells[cell].bids, key=lambda x: x[\"bid\"])\n",
" if _max_bid[\"bid\"] > self.cells[cell].p_ask:\n",
" self.cells[cell].transact(_max_bid, self.agents[self.cells[cell].owner])\n",
" self.agents[i].cell, self.agents[i].selling = None, False\n",
" self.agents[_max_bid[\"bidder\"]].cell, self.agents[_max_bid[\"bidder\"]].buying = cell, False\n",
" transactions+=1\n",
" for i in range(len(self.agents)):\n",
" if self.agents[i].buying:\n",
" self.agents[i].utility = -1 # reset utility if they haven't bought a cell\n",
" transaction_counts.append(transactions)\n",
" if self.gif:\n",
" viz.get_ui(self,components=self.ui_components, show=False, save=True)\n",
"\n",
" def write_out_agents(self):\n",
" print(\"writing out agents...\")\n",
" header = [ \"Agent_ID\", \"Affordability\", \"Budget\", \"Distance_Cost\", \"Buying\", \"Selling\", \"Amenity_Preference\", \"Proximity_Preference\", \"Utility\" ]\n",
" self.csv_output_writer[\"agents\"].writerow(header)\n",
" for agent in self.agents:\n",
" row = [ agent.id, agent.affordability, agent.budget, agent.distance_cost, agent.buying, agent.selling, agent.amenity_preference, agent.proximity_preference, agent.utility ]\n",
" self.csv_output_writer[\"agents\"].writerow(row)\n",
"\n",
" def write_out_cells(self):\n",
" print(\"writing out cells...\")\n",
" header = [ \"Cell_ID\", \"Location_X\", \"Location_Y\", \"Owner\", \"Market_Price\", \"On_Market\", \"Amenity\", \"Proximity\" ]\n",
" self.csv_output_writer[\"cells\"].writerow(header)\n",
" for cell in self.cells:\n",
" row = [cell.id, cell.location[0], cell.location[1], cell.owner, cell.market_price, cell.on_market, cell.amenity, cell.proximity ]\n",
" self.csv_output_writer[\"cells\"].writerow(row)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Parameters\n",
"\n",
"Below you will find a variety of widgets that allow you to set the parameters for our model. Here is a brief explanation of the parameters:\n",
"\n",
"* `Affordability` - parameter that controls the steepness of the WTP function's tendency to $Y$ as $U\\to 1$. Filatova and Parker describe it as \"as a proxy of the affordability of all other goods to reflect their relative influence on the WTP for housing\" and describe the demand curve in depth [in Appendix A of their paper](http://jasss.soc.surrey.ac.uk/12/1/3.html#appendixa)\n",
"* `Alpha Max` - the maximum value that an agent can have for the environmental preference ($\\alpha$). Because $\\alpha+\\beta=1$ and both $\\alpha,\\beta$ are drawn from uniform distributions, we also have that $\\bar{\\alpha}=\\alpha_{max}/2$ and $\\bar{\\beta}=1-\\bar{\\alpha}$.\n",
"* `Budget Min` - the minimum value for the uniform budget distribution. Must be less than or equal to `Budget Max`.\n",
"* `Budget Max` - the maximum value for the uniform budget distribution. Must be greater than or equal to `Budget Min`.\n",
"* `City Height` - height in cells of the simulation\n",
"* `City Width` - width in cells of the simulation\n",
"* `Sim Length` - length in time steps of the simulation\n",
"\n",
"**NOTES:**\n",
"\n",
"* The UI is optimized for `City Height`$\\approx$`City Width` so the output may look very odd if this is not true.\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "109fd82f701a487492e2b32edc06a08d",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"FloatSlider(value=0.7, description='Affordability', max=1.0, min=0.01)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "e66c0218332048fca4236da7459f92d4",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"FloatSlider(value=0.2, description='Alpha Max:', max=1.0)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "54c71db3df1444bf9911314cdd5454da",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"FloatSlider(value=800.0, description='Budget Min', max=1200.0, min=400.0)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "3bbf8152f92e4762ae8f0864bd642efe",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"FloatSlider(value=800.0, description='Budget Max', max=1600.0, min=800.0)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "c5daada1514e4bb4adb57a998e7916a3",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"FloatSlider(value=1.0, description='Buyer Level: ', max=4.0, min=0.1)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "e4e4a8768ce64addb3d0fbd59b244fb2",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"IntSlider(value=13, description='City Height: ', max=50, min=1)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "c5c963ac290b4b5bbe26f31ffad1e177",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"IntSlider(value=13, description='City Width: ', max=50, min=1)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "dc417e5b9bcf4758be47600ff99e147d",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"IntSlider(value=50, description='Sim Length:', min=20)"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"affordability_slider = widgets.FloatSlider(value=0.7, min = .01, max=1, description=\"Affordability\")\n",
"alpha_max_slider = widgets.FloatSlider(value = 0.2, min = 0, max = 1, description=\"Alpha Max:\")\n",
"budget_low_slider = widgets.FloatSlider(value=800,min=400,max=1200,description=\"Budget Min\")\n",
"budget_high_slider = widgets.FloatSlider(value=800,min=800,max=1600,description=\"Budget Max\")\n",
"buyer_level_slider = widgets.FloatSlider(value = 1, min = 0.1, max = 4, description = \"Buyer Level: \")\n",
"city_height_slider = widgets.IntSlider(value = 13, min = 1, max = 50, description = \"City Height: \")\n",
"city_width_slider = widgets.IntSlider(value = 13, min = 1, max = 50, description = \"City Width: \")\n",
"sim_len_slider = widgets.IntSlider(value=50, min=20, max=100, description=\"Sim Length:\")\n",
"display(affordability_slider,alpha_max_slider,budget_low_slider,budget_high_slider,buyer_level_slider, city_height_slider, city_width_slider,sim_len_slider)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## User Interface\n",
"\n",
"You can also customize the UI that is shown for the simulation! The configuration is in `args['ui']['components']`.\n",
"\n",
"The first element of the list is the characteristic you'd like to color the cells for. You can use the following:\n",
"* \"Market Price\" for market prices\n",
"* \"Proximity\" for proximity\n",
"\n",
"For the rest of the list, the following graphs/charts are supported:\n",
"* \"Histo: Agent Budget\" for a histogram of agent's budgets\n",
"* \"Histo: Market Price\" for a histogram of market prices\n",
"* \"Line: Epsilon\" for a line graph of epsilon over time\n",
"* \"Scatter: Amenity-Market Price\" for a scatterplot of Market Prices vs. Amenity\n",
"* \"Scatter: Proximity-Market Price\" for a scatterplot of Market Price vs. Proximity\n",
"* \"Stackplot: Agent\" for a stackplot of agents and their role in the market (buyers, sellers or neither) vs. time\n",
"* \"Stackplot: On Market\" for a stackplot of cells on/off the market vs. time\n",
"\n",
"To change the style of the UI (`args['ui']['style']`) you can choose any style [from the Matplotlib style gallery](https://tonysyu.github.io/raw_content/matplotlib-style-gallery/gallery.html)."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{\n",
" \"agents\": {\n",
" \"affordability\": 0.7,\n",
" \"alpha_max\": 0.2,\n",
" \"budget_parameters\": [\n",
" 800.0,\n",
" 800.0\n",
" ],\n",
" \"buyer_level\": 1.0,\n",
" \"distance_cost\": 1\n",
" },\n",
" \"cells\": {\n",
" \"wta\": 250\n",
" },\n",
" \"simulation\": {\n",
" \"height\": 13,\n",
" \"output_directory\": \"\",\n",
" \"sim_length\": 50,\n",
" \"width\": 13\n",
" },\n",
" \"ui\": {\n",
" \"components\": [\n",
" \"Market Price\",\n",
" \"Histo: Market Price\",\n",
" \"Scatter: Proximity-Market Price\",\n",
" \"Stackplot: On Market\",\n",
" \"Stackplot: Agent\"\n",
" ],\n",
" \"generate_gif\": true,\n",
" \"show\": false,\n",
" \"style\": \"dark_background\"\n",
" }\n",
"}\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"Simulation:: 100%|██████████| 50/50 [00:59<00:00, 1.19s/it]\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"writing out cells...\n",
"writing out agents...\n",
"\n",
"\n",
"Results were saved in ./outputs/ALMA-2020-09-16_22:15:27-(169cells)\n"
]
}
],
"source": [
"assert budget_low_slider.value <