Unveiling Auction Strategies with Python Simulations
This Python script serves as a robust tool for simulating multi-agent dynamics in repeated auctions, offering a diverse range of bidding strategies. Utilizing prominent Python libraries like NumPy, Gurobi, and scikit-learn, it empowers bidders with sophisticated tactics such as Hedge, Random, EXP3, and GPMW. Beyond the exploration of auction dynamics, the script employs CVXPY for mathematical optimization, demonstrating its versatility in tackling complex optimization problems. Whether you are a student seeking help with your Python assignment or a researcher delving into multi-agent systems, this script provides a valuable resource for understanding the nuanced interplay of diverse bidding strategies in repeated auctions within the Python programming paradigm.
Block 1: Importing Libraries
import numpy as np
import cvxpy as cp
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF
from sklearn.metrics import r2_score
from matplotlib import pyplot as plt
from tqdm import tqdm
import pickle
import re
import gurobipy as gp
from gurobipy import GRB
This block imports necessary libraries for numerical computation, optimization, machine learning, visualization, and simulation.
Block 2: Normalization Function
def normalize_util(payoffs, min_payoff, max_payoff):
# Function to normalize payoffs in [0, 1]
# ...
return payoffs_scaled
normalize = np.vectorize(normalize_util)
This block defines a function for normalizing payoffs within the range [0, 1]. The normalize function is vectorized to operate on arrays.
Block 3: Auction Data Class
class auction_data:
# A class to store auction data
# ...
This class is designed to store data related to auctions, including bids, allocations, payments, marginal prices, payoffs, and regrets.
Block 4: Bidder Class
class Bidder:
# A class representing a bidder
# ...
This class represents a generic bidder with methods for initialization, restarting, choosing actions based on weights, and other properties.
Block 5: Hedge Bidder Class
class Hedge_bidder(Bidder):
# A class representing a bidder using the Hedge algorithm
# ...
This class extends the Bidder class for bidders using the Hedge algorithm. It includes methods for updating weights based on payoffs.
Block 6: Random Bidder Class
class random_bidder(Bidder):
# A class representing a random bidder
# ...
This class extends the Bidder class for bidders making random choices.
Block 7: EXP3 Bidder Class
class EXP3_bidder(Bidder):
# A class representing a bidder using the EXP3 algorithm
# ...
This class extends the Bidder class for bidders using the EXP3 algorithm. It includes methods for updating weights based on actions and payoffs.
Block 8: GPMW Bidder Class
class GPMW_bidder(Hedge_bidder):
# A class representing a bidder using the GPMW algorithm
# ...
This class extends the Hedge_bidder class for bidders using the GPMW algorithm. It includes methods for updating weights based on Gaussian Process predictions.
Block 9: Allocation Optimization Function
def optimize_alloc(bids, Q):
# Function to optimize allocations based on bids
# ...
return allocs, marginal_price, [payments]
This function performs allocation optimization using a quadratic optimization model, considering bid constraints and capacity. It returns allocations, marginal prices, and payments.
Block 10: Auction Simulation Function
def run_auction(T, bidders, Q, regret_calc):
# Function to simulate a repeated auction
# ...
return game_data
This function runs a repeated auction simulation for a specified number of rounds (T). It involves bidders choosing actions, optimizing allocations, calculating payoffs, and updating bidder strategies. The results are stored in the game_data object.
Block 11: GPMW Fitness Test Function
def func_test(T_train, T_test):
# Function to train and test the fitness of GPMW prediction
# ...
This function trains a Gaussian Process model on auction data and tests its performance on a separate set. It includes a fitness score calculation and a plot comparing real and predicted payoffs.
Block 12: Simulation Function
def simulate(num_games, num_runs, T, N, K, file_name):
# Function to simulate repeated auctions with different bidder types
# ...
This function performs a simulation of repeated auctions with different bidder types, including Hedge, EXP3, Random, and GPMW. It stores the simulation results in a file.
Block 13: Regret Plotting Function
def plot_regret(file_name):
# Function to plot regrets from simulation results
# ...
This function reads simulation results from a file and plots the regrets over time for different bidder types.
Block 14: Simulation Execution
'''simulation'''
#func_test(30, 200)
# np.random.seed(12)
simulate(num_games=20, num_runs=10, T=200, N=6, K=5, file_name='res4')
plot_regret('result')
# plot_payoff_upper_bound()
This block executes the simulation, tests GPMW fitness, and plots regrets based on the simulation results.
Conclusion
In conclusion, the code exhibits a well-organized structure with modular blocks for diverse components of the auction simulation, such as bidder classes, optimization functions, and simulation processes. It accommodates various bidder types and systematically analyzes and plots results, including regrets. The code's modular design enhances readability and facilitates the testing of different bidder strategies in repeated auctions. This structured approach enhances flexibility, making it adaptable for further experimentation and refinement in the dynamic context of auction scenarios.