From 579ed8f8556dfbab20cf9369499c9304bb5badcc Mon Sep 17 00:00:00 2001 From: Joe O'Brien Date: Fri, 6 Feb 2026 11:56:04 -0800 Subject: [PATCH 1/3] upload landscape construction and agent decision procedure scripts in examples folder --- .../AgentDecisionProcedures.py | 421 ++++++++++++++++++ examples/LandscapeConstruction_NK_Modular.py | 414 +++++++++++++++++ 2 files changed, 835 insertions(+) create mode 100644 examples/Fazelpour_etal_HomogenizationAI/AgentDecisionProcedures.py create mode 100644 examples/LandscapeConstruction_NK_Modular.py diff --git a/examples/Fazelpour_etal_HomogenizationAI/AgentDecisionProcedures.py b/examples/Fazelpour_etal_HomogenizationAI/AgentDecisionProcedures.py new file mode 100644 index 0000000..b60c16b --- /dev/null +++ b/examples/Fazelpour_etal_HomogenizationAI/AgentDecisionProcedures.py @@ -0,0 +1,421 @@ +import random +import numpy as np +from random import sample +import multiprocessing as mp +from multiprocessing import Pool, shared_memory +from tqdm import tqdm +import pandas as pd +import csv +from scipy.spatial import distance +import heapq +import networkx as nx +import gc +from typing import List, Tuple +import argparse + +# Import the optimized landscape +from LandscapeConstruction_NK_Modular import OptimizedNKLandscape + +# Argument parser +parser = argparse.ArgumentParser('AISIM Modular Optimized') +parser.add_argument('--n', required=True, type=int, help='n: number of dimensions') +parser.add_argument('--k', required=True, type=int, help='k: ruggedness of landscape') +parser.add_argument('--a', required=True, type=int, help='a: number of agents') +parser.add_argument('--r', required=True, type=int, help='r: number of timesteps') +parser.add_argument('--s', required=True, type=int, help='s: number of simulations') +parser.add_argument('--f', required=True, type=str, help='f: filename') +parser.add_argument('--cache_size', type=int, default=50000, help='Maximum cache size for fitness values') + +args = parser.parse_args() +n = args.n +k = args.k +total_agents = args.a +rounds = args.r +simulation_runs = args.s +filename = args.f +cache_size = args.cache_size + +# Reduced parameter combinations for faster testing +probability_range = [.25, .75] # Reduced from 3 to 2 values +velocity_range = [.25, .75] # Reduced from 2 to 2 values +trigger_AI = [.25, .75] # Reduced from 2 to 2 values +r_range = [.25, .75] # Reduced from 3 to 2 values + +simtuples = [] +for probability in probability_range: + for velocity in velocity_range: + for trigger in trigger_AI: + for r in r_range: + simtuples.append([probability, velocity, trigger, r]) + +print(f"Total parameter combinations: {len(simtuples)}") + +# Optimized helper functions +def csr_matrix_to_lists_optimized(csr_matrix): + """More memory-efficient adjacency list conversion""" + return csr_matrix.toarray().astype(np.uint8) + +def list_duplicates_of(seq, item): + """Optimized duplicate finding""" + return [i for i, x in enumerate(seq) if x == item] + +def avg_ham_optimized(agents: np.ndarray) -> float: + """Vectorized Hamming distance calculation""" + if len(agents) <= 1: + return 0.0 + + # Convert to numpy array if not already + agents_array = np.array(agents, dtype=np.uint8) + + # Vectorized pairwise Hamming distance + total_dist = 0 + pairs = 0 + + for i in range(len(agents_array)): + for j in range(i + 1, len(agents_array)): + hamming_dist = np.mean(agents_array[i] != agents_array[j]) + total_dist += hamming_dist + pairs += 1 + + return total_dist / pairs if pairs > 0 else 0 + +def single_bit_optimization_optimized(agent: np.ndarray, landscape) -> np.ndarray: + """Optimized single bit optimization with numpy""" + current_fitness = landscape.get_fitness(agent) + + best_improvement = 0 + best_bit_to_flip = None + + # Focus on computational module (bits 10-19) + for bit_idx in range(10, 20): + if bit_idx < len(agent): + # Create test agent efficiently + test_agent = agent.copy() + test_agent[bit_idx] = 1 - test_agent[bit_idx] + + new_fitness = landscape.get_fitness(test_agent) + improvement = new_fitness - current_fitness + + if improvement > best_improvement: + best_improvement = improvement + best_bit_to_flip = bit_idx + + if best_bit_to_flip is not None: + agent[best_bit_to_flip] = 1 - agent[best_bit_to_flip] + + return agent + +def top10idx_optimized(inputs: List[float]) -> List[int]: + """Optimized top 10 index finding""" + return heapq.nlargest(10, range(len(inputs)), key=inputs.__getitem__) + +# Optimized simulation functions +def NOAI_optimized(agents: np.ndarray, landscape, t: int, metrics: dict, + network: np.ndarray, velocity: float): + """Memory-optimized NOAI function""" + # Calculate all fitness values at once + fitness_scores = np.array([landscape.get_fitness(agent) for agent in agents]) + + # Update metrics + metrics['average_score_best'][t] += np.mean(fitness_scores) + metrics['noAI_hamming'][t] += avg_ham_optimized(agents) + + # Vectorized learning decisions + learning_probs = np.random.random(total_agents) + + for agent_idx in range(total_agents): + if learning_probs[agent_idx] <= velocity: + # Social learning + products = network[agent_idx] * fitness_scores + max_product = np.max(products) + + if fitness_scores[agent_idx] < max_product: + max_indices = np.where(products == max_product)[0] + chosen_idx = np.random.choice(max_indices) + agents[agent_idx] = agents[chosen_idx].copy() + else: + # Individual exploration + change_bit = random.randint(0, n - 1) + test_agent = agents[agent_idx].copy() + test_agent[change_bit] = 1 - test_agent[change_bit] + + if landscape.get_fitness(test_agent) > fitness_scores[agent_idx]: + agents[agent_idx] = test_agent + +def PERSONALIZED_optimized(agents: np.ndarray, landscape, t: int, metrics: dict, + network: np.ndarray, velocity: float, trigger: float): + """Optimized personalized AI function""" + fitness_scores = np.array([landscape.get_fitness(agent) for agent in agents]) + + metrics['average_score_personalized'][t] += np.mean(fitness_scores) + metrics['personalized_hamming'][t] += avg_ham_optimized(agents) + + num_triggers = 0 + sum_inc_fit = 0 + learning_probs = np.random.random(total_agents) + + for agent_idx in range(total_agents): + if learning_probs[agent_idx] <= velocity: + # Social learning (same as NOAI) + products = network[agent_idx] * fitness_scores + max_product = np.max(products) + + if fitness_scores[agent_idx] < max_product: + max_indices = np.where(products == max_product)[0] + chosen_idx = np.random.choice(max_indices) + agents[agent_idx] = agents[chosen_idx].copy() + else: + trigger_prob = random.random() + if trigger_prob <= trigger: + # AI optimization + num_triggers += 1 + old_fitness = fitness_scores[agent_idx] + agents[agent_idx] = single_bit_optimization_optimized(agents[agent_idx], landscape) + new_fitness = landscape.get_fitness(agents[agent_idx]) + sum_inc_fit += (new_fitness - old_fitness) + else: + # Individual exploration + change_bit = random.randint(0, n - 1) + test_agent = agents[agent_idx].copy() + test_agent[change_bit] = 1 - test_agent[change_bit] + + if landscape.get_fitness(test_agent) > fitness_scores[agent_idx]: + agents[agent_idx] = test_agent + + metrics['personal_counter'][t] += num_triggers + if num_triggers > 0: + metrics['avgScoreInc_personal'][t] += sum_inc_fit / num_triggers + +def NONPERSONALIZED_optimized(agents: np.ndarray, landscape, t: int, metrics: dict, + network: np.ndarray, velocity: float, trigger: float): + """Optimized non-personalized AI function""" + fitness_scores = np.array([landscape.get_fitness(agent) for agent in agents]) + + metrics['average_score_nopersonalized'][t] += np.mean(fitness_scores) + metrics['nonpersonal_hamming'][t] += avg_ham_optimized(agents) + + num_triggers = 0 + sum_fit = 0 + num_adopted = 0 + sum_inc_fit = 0 + learning_probs = np.random.random(total_agents) + + for agent_idx in range(total_agents): + if learning_probs[agent_idx] <= velocity: + # Social learning + products = network[agent_idx] * fitness_scores + max_product = np.max(products) + + if fitness_scores[agent_idx] < max_product: + max_indices = np.where(products == max_product)[0] + chosen_idx = np.random.choice(max_indices) + agents[agent_idx] = agents[chosen_idx].copy() + else: + best_score_idx = np.argmax(fitness_scores) + best_agent = agents[best_score_idx] + + trigger_prob = random.random() + if trigger_prob <= trigger: + num_triggers += 1 + copy_solution = agents[agent_idx].copy() + copy_fit = fitness_scores[agent_idx] + + # Get the last module from the best agent + last_module_idx = landscape.M - 1 + last_module_bits = landscape._get_module_bits(last_module_idx) + + # Apply the best agent's last module to current agent + new_solution = copy_solution.copy() + for bit_idx in last_module_bits: + new_solution[bit_idx] = best_agent[bit_idx] + + new_fit = landscape.get_fitness(new_solution) + change_fitness = new_fit - copy_fit + sum_fit += change_fitness + + if new_fit > copy_fit: + num_adopted += 1 + sum_inc_fit += change_fitness + agents[agent_idx] = new_solution + else: + # Individual exploration + change_bit = random.randint(0, n - 1) + test_agent = agents[agent_idx].copy() + test_agent[change_bit] = 1 - test_agent[change_bit] + + if landscape.get_fitness(test_agent) > fitness_scores[agent_idx]: + agents[agent_idx] = test_agent + + metrics['nopersonal_counter'][t] += num_triggers + metrics['nopersonal_IncCounter'][t] += num_adopted + if num_triggers > 0: + metrics['avgScoreSuggestion_nopersonal'][t] += sum_fit / num_triggers + if num_adopted > 0: + metrics['avgScoreInc_nopersonal'][t] += sum_inc_fit / num_adopted + +def RANDOMIZED_optimized(agents: np.ndarray, landscape, t: int, metrics: dict, + network: np.ndarray, velocity: float, trigger: float): + """Optimized randomized AI function""" + fitness_scores = np.array([landscape.get_fitness(agent) for agent in agents]) + + metrics['average_score_random'][t] += np.mean(fitness_scores) + metrics['random_hamming'][t] += avg_ham_optimized(agents) + + num_triggers = 0 + sum_fit = 0 + num_adopted = 0 + sum_inc_fit = 0 + learning_probs = np.random.random(total_agents) + + for agent_idx in range(total_agents): + if learning_probs[agent_idx] <= velocity: + # Social learning + products = network[agent_idx] * fitness_scores + max_product = np.max(products) + + if fitness_scores[agent_idx] < max_product: + max_indices = np.where(products == max_product)[0] + chosen_idx = np.random.choice(max_indices) + agents[agent_idx] = agents[chosen_idx].copy() + else: + trigger_prob = random.random() + if trigger_prob <= trigger: + num_triggers += 1 + top10_indices = top10idx_optimized(fitness_scores.tolist()) + chum = [agents[i] for i in top10_indices] + + copy_solution = agents[agent_idx].copy() + copy_fit = fitness_scores[agent_idx] + rando = random.randint(0, len(chum) - 1) + temp = chum[rando] + + last_module_idx = landscape.M - 1 + last_module_bits = landscape._get_module_bits(last_module_idx) + + # Create new solution by replacing last module + new_solution = copy_solution.copy() + for bit_idx in last_module_bits: + new_solution[bit_idx] = temp[bit_idx] + + new_fit = landscape.get_fitness(new_solution) + change_fitness = new_fit - copy_fit + sum_fit += change_fitness + + if new_fit > copy_fit: + num_adopted += 1 + sum_inc_fit += change_fitness + agents[agent_idx] = new_solution + else: + # Individual exploration + change_bit = random.randint(0, n - 1) + test_agent = agents[agent_idx].copy() + test_agent[change_bit] = 1 - test_agent[change_bit] + + if landscape.get_fitness(test_agent) > fitness_scores[agent_idx]: + agents[agent_idx] = test_agent + + metrics['random_counter'][t] += num_triggers + metrics['random_IncCounter'][t] += num_adopted + if num_triggers > 0: + metrics['avgScoreSuggestion_random'][t] += sum_fit / num_triggers + if num_adopted > 0: + metrics['avgScoreInc_random'][t] += sum_inc_fit / num_adopted + +def run_modular_optimized(simtuple: List[float]) -> List: + """Optimized main simulation function""" + probability, velocity, trigger, r = simtuple + + # Initialize metrics with more memory-efficient storage + metrics = { + 'average_score_best': np.zeros(rounds, dtype=np.float32), + 'average_score_personalized': np.zeros(rounds, dtype=np.float32), + 'average_score_nopersonalized': np.zeros(rounds, dtype=np.float32), + 'average_score_random': np.zeros(rounds, dtype=np.float32), + 'noAI_hamming': np.zeros(rounds, dtype=np.float32), + 'personalized_hamming': np.zeros(rounds, dtype=np.float32), + 'nonpersonal_hamming': np.zeros(rounds, dtype=np.float32), + 'random_hamming': np.zeros(rounds, dtype=np.float32), + 'avgScoreInc_personal': np.zeros(rounds, dtype=np.float32), + 'personal_counter': np.zeros(rounds, dtype=np.int32), + 'random_counter': np.zeros(rounds, dtype=np.int32), + 'avgScoreSuggestion_random': np.zeros(rounds, dtype=np.float32), + 'random_IncCounter': np.zeros(rounds, dtype=np.int32), + 'avgScoreInc_random': np.zeros(rounds, dtype=np.float32), + 'avgScoreSuggestion_nopersonal': np.zeros(rounds, dtype=np.float32), + 'nopersonal_counter': np.zeros(rounds, dtype=np.int32), + 'nopersonal_IncCounter': np.zeros(rounds, dtype=np.int32), + 'avgScoreInc_nopersonal': np.zeros(rounds, dtype=np.float32) + } + + pbar = tqdm(desc=f"R={r:.2f}, p={probability:.2f}", total=simulation_runs, leave=False) + + for simulation in range(simulation_runs): + # Create optimized landscape with smaller cache + landscape = OptimizedNKLandscape(N=n, K=k, R=r, seed=simulation, + use_cache=True, max_cache_size=cache_size) + + # Initialize agents with efficient data types + initial_agents = np.random.randint(0, 2, (total_agents, n), dtype=np.uint8) + + # Create separate copies for each condition + noai_agents = initial_agents.copy() + personal_agents = initial_agents.copy() + nopersonal_agents = initial_agents.copy() + random_agents = initial_agents.copy() + + # Create network more efficiently + network = nx.gnp_random_graph(total_agents, probability, directed=True) + adj_matrix = nx.adjacency_matrix(network).toarray().astype(np.uint8) + + # Run simulation rounds + for t in range(1, rounds): + NOAI_optimized(noai_agents, landscape, t, metrics, adj_matrix, velocity) + PERSONALIZED_optimized(personal_agents, landscape, t, metrics, adj_matrix, velocity, trigger) + NONPERSONALIZED_optimized(nopersonal_agents, landscape, t, metrics, adj_matrix, velocity, trigger) + RANDOMIZED_optimized(random_agents, landscape, t, metrics, adj_matrix, velocity, trigger) + + # Clear cache periodically to manage memory + if t % 100 == 0: + landscape.clear_cache() + + # Clean up landscape to free memory + del landscape + gc.collect() + + pbar.update(1) + + pbar.close() + + # Convert metrics to lists and normalize by simulation runs + result = [simtuple] + for key in ['average_score_best', 'noAI_hamming', + 'average_score_personalized', 'personal_counter', 'avgScoreInc_personal', 'personalized_hamming', + 'average_score_nopersonalized', 'nonpersonal_hamming', 'nopersonal_counter', 'avgScoreSuggestion_nopersonal', 'nopersonal_IncCounter', 'avgScoreInc_nopersonal', + 'average_score_random', 'random_counter', 'avgScoreSuggestion_random', 'random_IncCounter', 'avgScoreInc_random', 'random_hamming']: + if key in metrics: + normalized_values = (metrics[key] / simulation_runs).tolist() + result.append(normalized_values) + + return result + +if __name__ == '__main__': + print(f"Starting optimized simulation with {mp.cpu_count()} cores") + print(f"Problem size: N={n}, K={k}") + print(f"Landscape size: 2^{n} = {2**n:,} states") + print(f"Cache size per landscape: {cache_size:,} states") + + # Use fewer processes for very large problems to avoid memory issues + max_processes = min(mp.cpu_count(), 8) if n > 16 else mp.cpu_count() + + with Pool(max_processes) as p: + results = p.map(run_modular_optimized, simtuples) + + # Save results + output_filename = f'optimized_modular_results_n{n}_k{k}_a{total_agents}_r{rounds}_s{simulation_runs}_{filename}.csv' + + with open(output_filename, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerows(results) + + print(f"Results saved to: {output_filename}") + print("Simulation complete!") \ No newline at end of file diff --git a/examples/LandscapeConstruction_NK_Modular.py b/examples/LandscapeConstruction_NK_Modular.py new file mode 100644 index 0000000..4ad1a65 --- /dev/null +++ b/examples/LandscapeConstruction_NK_Modular.py @@ -0,0 +1,414 @@ +import numpy as np +from typing import Dict, List, Tuple, Optional +import gc + +class OptimizedNKLandscape: + """ + Optimized NK Landscape with memory-efficient fitness calculation + Key optimizations: + 1. Streaming min/max calculation without storing all fitness values + 2. On-demand fitness calculation using mathematical transformation + 3. Memory-efficient state representation + 4. Optional fitness caching with memory limits + """ + + def __init__(self, N: int, K: int, R: float = 0.0, seed: Optional[int] = None, + use_cache: bool = True, max_cache_size: int = 100000): + # Input validation + if N % 2 != 0: + raise ValueError(f"N must be even (divisible by 2). Got N={N}") + if K >= N: + raise ValueError(f"K must be less than N. Got K={K}, N={N}") + if K < 0: + raise ValueError(f"K must be non-negative. Got K={K}") + if not 0 <= R <= 1: + raise ValueError(f"R must be between 0 and 1. Got R={R}") + + self.N = N + self.K = K + self.M = 2 + self.R = R + self.module_size = N // 2 + self.rng = np.random.RandomState(seed) + self.use_cache = use_cache + self.max_cache_size = max_cache_size + + # Validate intra-module dependencies + max_intra_per_bit = min(K, self.module_size - 1) + max_possible_R = max_intra_per_bit / K if K > 0 else 1.0 + if R > max_possible_R: + raise ValueError(f"R={R} is too high. Maximum possible R is {max_possible_R:.3f}") + + # Generate interaction structure and fitness contributions + self.interactions = self._generate_interactions() + self.fitness_contributions = self._generate_fitness_contributions() + + # Initialize normalization parameters + self.true_min_raw = None + self.true_max_raw = None + self.is_normalized = False + + # Memory-efficient cache with LRU-style eviction + self.fitness_cache = {} + self.cache_access_order = [] + + # Find true min/max with streaming calculation + self._find_normalization_bounds() + + def _find_normalization_bounds(self): + """Find min/max fitness values using streaming calculation - no storage of all values""" + print(f"Finding fitness bounds via streaming calculation (2^{self.N} = {2**self.N} states)...") + + min_fitness = float('inf') + max_fitness = float('-inf') + + # Process states in batches to avoid memory issues + batch_size = min(10000, 2**self.N) + + for batch_start in range(0, 2**self.N, batch_size): + batch_end = min(batch_start + batch_size, 2**self.N) + + for i in range(batch_start, batch_end): + # Convert integer to binary state efficiently + state = np.array([(i >> bit) & 1 for bit in range(self.N)], dtype=np.uint8) + + # Calculate raw fitness + raw_fitness = self._get_raw_fitness(state) + + # Update bounds + min_fitness = min(min_fitness, raw_fitness) + max_fitness = max(max_fitness, raw_fitness) + + # Progress indicator for large landscapes + if batch_end % (2**min(self.N, 15)) == 0: + progress = batch_end / (2**self.N) * 100 + print(f"Progress: {progress:.1f}%") + + self.true_min_raw = min_fitness + self.true_max_raw = max_fitness + self.is_normalized = True + + print(f"Bounds found. Raw range: [{self.true_min_raw:.6f}, {self.true_max_raw:.6f}]") + print(f"Memory usage: No fitness lookup table stored") + + def _get_raw_fitness(self, state: np.ndarray) -> float: + """Calculate raw fitness without caching""" + if len(state) != self.N: + raise ValueError(f"State must have length {self.N}") + + total_fitness = 0.0 + for i in range(self.N): + affecting_bits = self.interactions[i] + # Use numpy indexing for efficiency + affecting_states = state[affecting_bits] + # Convert binary array to index efficiently + index = np.dot(affecting_states, 1 << np.arange(len(affecting_states))) + total_fitness += self.fitness_contributions[i][index] + + return total_fitness / self.N + + def get_fitness(self, state: np.ndarray) -> float: + """Calculate fitness with optional caching and mathematical transformation""" + if len(state) != self.N: + raise ValueError(f"State must have length {self.N}") + + # Use tuple for hashable cache key + state_key = tuple(state) if self.use_cache else None + + # Check cache first + if self.use_cache and state_key in self.fitness_cache: + # Update access order for LRU + self.cache_access_order.remove(state_key) + self.cache_access_order.append(state_key) + return self.fitness_cache[state_key] + + # Calculate raw fitness + raw_fitness = self._get_raw_fitness(state) + + # Apply normalization and transformation + if self.is_normalized and self.true_max_raw is not None: + fitness_range = self.true_max_raw - self.true_min_raw + if fitness_range > 0: + normalized_fitness = (raw_fitness - self.true_min_raw) / fitness_range + transformed_fitness = normalized_fitness ** 4 + else: + transformed_fitness = 1.0 + else: + transformed_fitness = raw_fitness + + # Cache the result if caching is enabled + if self.use_cache: + # Manage cache size + if len(self.fitness_cache) >= self.max_cache_size: + # Remove oldest entries (LRU eviction) + oldest_key = self.cache_access_order.pop(0) + del self.fitness_cache[oldest_key] + + self.fitness_cache[state_key] = transformed_fitness + self.cache_access_order.append(state_key) + + return transformed_fitness + + def clear_cache(self): + """Clear fitness cache to free memory""" + self.fitness_cache.clear() + self.cache_access_order.clear() + gc.collect() + + def get_cache_stats(self) -> Dict: + """Get cache statistics""" + return { + 'cache_size': len(self.fitness_cache), + 'max_cache_size': self.max_cache_size, + 'cache_enabled': self.use_cache + } + + # Keep all the existing methods for compatibility + def _get_module(self, bit_idx: int) -> int: + return bit_idx // self.module_size + + def _get_module_bits(self, module_idx: int) -> List[int]: + start = module_idx * self.module_size + end = start + self.module_size + return list(range(start, end)) + + def _generate_interactions(self) -> Dict[int, np.ndarray]: + """Generate interactions with numpy arrays for efficiency""" + interactions = {} + + for i in range(self.N): + affecting_bits = [i] + if self.K == 0: + interactions[i] = np.array(affecting_bits, dtype=np.int32) + continue + + module_idx = self._get_module(i) + + if module_idx == 0: + # First module: completely random dependencies + available_bits = [b for b in range(self.N) if b != i] + if len(available_bits) >= self.K: + chosen_deps = self.rng.choice(available_bits, self.K, replace=False) + else: + chosen_deps = available_bits + affecting_bits.extend(chosen_deps) + + else: + # Second module: R controls intra-module percentage + module_bits = self._get_module_bits(1) + available_intra = [b for b in module_bits if b != i] + available_inter = self._get_module_bits(0) + + num_intra = int(round(self.K * self.R)) + num_inter = self.K - num_intra + + num_intra = min(num_intra, len(available_intra)) + num_inter = min(num_inter, len(available_inter)) + + if num_intra + num_inter < self.K: + remaining = self.K - num_intra - num_inter + if len(available_intra) > num_intra: + additional_intra = min(remaining, len(available_intra) - num_intra) + num_intra += additional_intra + remaining -= additional_intra + if remaining > 0 and len(available_inter) > num_inter: + additional_inter = min(remaining, len(available_inter) - num_inter) + num_inter += additional_inter + + chosen_deps = [] + + if num_intra > 0 and available_intra: + intra_choices = self.rng.choice(available_intra, num_intra, replace=False) + chosen_deps.extend(intra_choices) + + if num_inter > 0 and available_inter: + inter_choices = self.rng.choice(available_inter, num_inter, replace=False) + chosen_deps.extend(inter_choices) + + affecting_bits.extend(chosen_deps) + + interactions[i] = np.array(sorted(affecting_bits), dtype=np.int32) + + return interactions + + def _generate_fitness_contributions(self) -> Dict[int, np.ndarray]: + """Generate fitness contributions with appropriate data types""" + fitness_contributions = {} + + for i in range(self.N): + num_affecting = len(self.interactions[i]) + table_size = 2 ** num_affecting + # Use float32 to save memory if precision allows + fitness_contributions[i] = self.rng.random(table_size).astype(np.float32) + + return fitness_contributions + + def random_state(self) -> np.ndarray: + """Generate random state with efficient data type""" + return self.rng.randint(0, 2, self.N, dtype=np.uint8) + + def get_neighbors(self, state: np.ndarray) -> List[np.ndarray]: + """Get neighbors with memory-efficient operations""" + neighbors = [] + for i in range(self.N): + neighbor = state.copy() + neighbor[i] = 1 - neighbor[i] + neighbors.append(neighbor) + return neighbors + + # Keep existing analysis methods for compatibility + def get_interaction_matrix(self) -> np.ndarray: + matrix = np.zeros((self.N, self.N), dtype=np.uint8) # Use uint8 for binary matrix + for i, affecting_bits in self.interactions.items(): + matrix[i, affecting_bits] = 1 + return matrix + + def analyze_modularity(self) -> Dict: + """Analyze modularity - kept for compatibility""" + module0_intra = 0 + module1_intra = 0 + inter_dependencies = 0 + + for i, affecting_bits in self.interactions.items(): + module_i = self._get_module(i) + for j in affecting_bits: + if i != j: + module_j = self._get_module(j) + if module_i == module_j: + if module_i == 0: + module0_intra += 1 + else: + module1_intra += 1 + else: + inter_dependencies += 1 + + total_dependencies = module0_intra + module1_intra + inter_dependencies + + module1_total_deps = 0 + for i in range(self.module_size, self.N): + module1_total_deps += len([j for j in self.interactions[i] if j != i]) + + actual_R_module1 = module1_intra / module1_total_deps if module1_total_deps > 0 else 0 + + return { + 'total_dependencies': total_dependencies, + 'module0_intra_dependencies': module0_intra, + 'module1_intra_dependencies': module1_intra, + 'inter_module_dependencies': inter_dependencies, + 'target_R': self.R, + 'actual_R_module1': actual_R_module1, + 'module0_intra_fraction': module0_intra / (module0_intra + inter_dependencies // 2) if (module0_intra + inter_dependencies // 2) > 0 else 0, + 'module1_intra_fraction': module1_intra / module1_total_deps if module1_total_deps > 0 else 0, + 'avg_dependencies_per_bit': total_dependencies / self.N + } + + def visualize_interactions(self, save_path: Optional[str] = None, figsize: Tuple[int, int] = (10, 8)): + """Visualize interaction matrix (helpful for validating params)""" + try: + import matplotlib.pyplot as plt + import matplotlib.patches as patches + except ImportError: + raise ImportError("matplotlib is required for visualization. Install with: pip install matplotlib") + + # Get interaction matrix + matrix = self.get_interaction_matrix() + + # Create figure and axis + fig, ax = plt.subplots(figsize=figsize) + + # Create the heatmap (interactions are always binary) + im = ax.imshow(matrix, cmap='Blues', aspect='equal', origin='upper') + + # Add module boundary lines + module_boundary = self.module_size - 0.5 + ax.axhline(y=module_boundary, color='red', linewidth=2, alpha=0.7) + ax.axvline(x=module_boundary, color='red', linewidth=2, alpha=0.7) + + # Add module labels + ax.text(self.module_size // 2, -0.5, 'Module 0\n(Random Dependencies)', + ha='center', va='top', fontsize=12, fontweight='bold') + ax.text(self.module_size + self.module_size // 2, -0.5, f'Module 1\n(R={self.R:.2f})', + ha='center', va='top', fontsize=12, fontweight='bold') + + # Add module boundary rectangles for clarity + rect1 = patches.Rectangle((0-0.5, 0-0.5), self.module_size, self.module_size, + linewidth=2, edgecolor='green', facecolor='none', alpha=0.7) + rect2 = patches.Rectangle((self.module_size-0.5, self.module_size-0.5), + self.module_size, self.module_size, + linewidth=2, edgecolor='orange', facecolor='none', alpha=0.7) + ax.add_patch(rect1) + ax.add_patch(rect2) + + # Customize plot + ax.set_xlabel('Affecting Bit Index', fontsize=12) + ax.set_ylabel('Affected Bit Index', fontsize=12) + ax.set_title(f'NK Landscape Interaction Matrix\nN={self.N}, K={self.K}, R={self.R:.2f}', + fontsize=14, fontweight='bold') + + # Set ticks + ax.set_xticks(range(0, self.N, max(1, self.N // 10))) + ax.set_yticks(range(0, self.N, max(1, self.N // 10))) + + # Add grid + ax.grid(True, alpha=0.3, linewidth=0.5) + + # Add colorbar + cbar = plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04) + cbar.set_label('Dependency Exists', fontsize=12) + + # Add legend + legend_elements = [ + patches.Patch(color='green', alpha=0.7, label='Module 0 (Random)'), + patches.Patch(color='orange', alpha=0.7, label=f'Module 1 (R={self.R:.2f})'), + patches.Patch(color='red', alpha=0.7, label='Module Boundaries') + ] + ax.legend(handles=legend_elements, loc='center left', bbox_to_anchor=(1.15, 0.5)) + + # Adjust layout + plt.tight_layout() + + # Save if requested + if save_path: + plt.savefig(save_path, dpi=300, bbox_inches='tight') + print(f"Visualization saved to: {save_path}") + + return fig + + def print_interaction_summary(self): + """Summary of interaction structure""" + analysis = self.analyze_modularity() + + print(f"\n{'='*60}") + print(f"NK LANDSCAPE INTERACTION SUMMARY") + print(f"{'='*60}") + print(f"Parameters: N={self.N}, K={self.K}, R={self.R:.3f}") + print(f"Module Structure: 2 modules of {self.module_size} bits each") + print(f"") + + print(f"DEPENDENCY BREAKDOWN:") + print(f" Total dependencies: {analysis['total_dependencies']}") + print(f" Module 0 intra-dependencies: {analysis['module0_intra_dependencies']}") + print(f" Module 1 intra-dependencies: {analysis['module1_intra_dependencies']}") + print(f" Inter-module dependencies: {analysis['inter_module_dependencies']}") + print(f"") + + print(f"MODULARITY METRICS:") + print(f" Target R (Module 1): {analysis['target_R']:.3f}") + print(f" Actual R (Module 1): {analysis['actual_R_module1']:.3f}") + print(f" Module 1 intra fraction: {analysis['module1_intra_fraction']:.3f}") + print(f" Average dependencies per bit: {analysis['avg_dependencies_per_bit']:.2f}") + print(f"") + + # Show few interactions as examples + print(f"EXAMPLE INTERACTIONS:") + for i in [0, 1, self.module_size, self.module_size + 1]: + if i < self.N: + affecting = [j for j in self.interactions[i] if j != i] # Exclude self + module_i = self._get_module(i) + intra = [j for j in affecting if self._get_module(j) == module_i] + inter = [j for j in affecting if self._get_module(j) != module_i] + + print(f" Bit {i:2d} (Module {module_i}): " + f"intra={len(intra):2d} {intra}, inter={len(inter):2d} {inter}") + + print(f"{'='*60}\n") \ No newline at end of file From 1693e259b313d5d36071993eb8665a6edcc3c5d0 Mon Sep 17 00:00:00 2001 From: Joe O'Brien Date: Wed, 25 Mar 2026 09:30:56 -0400 Subject: [PATCH 2/3] Create README.md --- .../Fazelpour_etal_HomogenizationAI/README.md | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 examples/Fazelpour_etal_HomogenizationAI/README.md diff --git a/examples/Fazelpour_etal_HomogenizationAI/README.md b/examples/Fazelpour_etal_HomogenizationAI/README.md new file mode 100644 index 0000000..7a6ba31 --- /dev/null +++ b/examples/Fazelpour_etal_HomogenizationAI/README.md @@ -0,0 +1,42 @@ +# Navigating Epistemic Monocultures in AI-Driven Science: A Simulation Study + +Replication scripts for Fazelpour et al. (ms), which explores the homogenization of research methods resulting from the use of AI to guide hypothesis generation. + +--- + +## Scripts + +### `LandscapeConstruction_NK_Modular.py` + +Constructs an NK landscape with an additional parameter **R**, which defines the proportion of in- and out-module bits when the landscape is divided into 2 modules. + +> **Note:** The code currently performs an exhaustive search of the landscape to identify the maximum point for normalization and likely needs to be streamlined for efficiency. + +--- + +### `Agent_Decision_Procedures.py` + +Defines agent decision procedures for 3 groups of agents: + +- **Personalized agents** — receive updates from the AI tool based on their current location. +- **Non-personalized agents** — receive updates from the AI tool based on the best-performing agent in their community. +- **Randomized agents** — receive a solution from the AI tool randomly drawn from the top 10% of best-performing agents. + +#### Arguments + +| Flag | Description | +|------|-------------| +| `--n` | Number of dimensions on the landscape | +| `--k` | Ruggedness of the landscape (number of interdependencies per bit); must satisfy `0 < K < N` | +| `--a` | Number of agents in the simulation | +| `--r` | Number of rounds (timesteps) per simulation run | +| `--s` | Number of simulations to run | +| `--f` | Output results CSV filename | + +#### Example + +To run 10 simulations, each with 30 rounds and 100 agents, where N=20 and K=5: + +```bash +python Agent_Decision_Procedures.py --n 20 --k 5 --a 100 --r 30 --s 10 --f 'results' +``` From d0d6822e7651e7aaef70f06153db2af868298c71 Mon Sep 17 00:00:00 2001 From: Joe O'Brien Date: Wed, 25 Mar 2026 09:36:43 -0400 Subject: [PATCH 3/3] begin PR for Wu's "Better Than Best" paper --- examples/Wu_BetterThanBest/README.md | 98 +++++++ .../Wu_BetterThanBest/WU_BetterThanBest.pdf | Bin 0 -> 368385 bytes .../Wu_BetterThanBest/Wu_BetterThanBest.py | 274 ++++++++++++++++++ 3 files changed, 372 insertions(+) create mode 100644 examples/Wu_BetterThanBest/README.md create mode 100644 examples/Wu_BetterThanBest/WU_BetterThanBest.pdf create mode 100644 examples/Wu_BetterThanBest/Wu_BetterThanBest.py diff --git a/examples/Wu_BetterThanBest/README.md b/examples/Wu_BetterThanBest/README.md new file mode 100644 index 0000000..3288552 --- /dev/null +++ b/examples/Wu_BetterThanBest/README.md @@ -0,0 +1,98 @@ +# README: BetterThanBest Simulation + +## Overview + +This repository contains Python simulation code for the paper: + +**"Better than Best" by Jingyi Wu (LSE Philosophy)** + +The script implements agent-based simulations on rugged epistemic +landscapes to compare the performance of different social learning +strategies: + +- **Best-response strategy** ("best" agents) +- **Better-than-current strategy** ("better" agents) +- **Mixed populations** of both strategies + +The goal is to analyze how different updating rules, network structures, +and parameters affect collective epistemic performance. + +------------------------------------------------------------------------ + +## Features + +- Simulates **NK fitness landscapes** (rugged search spaces) +- Implements **three behavioral strategies** +- Supports **random directed social networks** +- Runs **multiple simulations in parallel** +- Tracks **average normalized performance over time** + +------------------------------------------------------------------------ + +## Requirements + +Originally written for **Python 2.7** + +### Dependencies + +- numpy +- scipy + +------------------------------------------------------------------------ + +## Parameters + +Key parameters: + +- n = 20 (dimensions) +- k = 5 (ruggedness) +- total_agents = 100 +- rounds = 200 +- simulation_runs = 1000 + +------------------------------------------------------------------------ + +## Model Description + +### Landscape + +- NK model with binary strings +- Payoffs from random valuation structure + +### Network + +- Random directed network +- Ensured to be strongly connected + +### Strategies + +- Best: copy highest-performing neighbor +- Better: copy any better-performing neighbor +- Mixed: combination of both + +------------------------------------------------------------------------ + +## Output + +Returns time-series performance data normalized by global maximum. + +------------------------------------------------------------------------ + +## How to Run + +``` bash +python Wu_BetterThanBest.py +``` + +------------------------------------------------------------------------ + +## License + +Creative Commons Attribution 4.0 International License + +------------------------------------------------------------------------ + +## Contact + +Jingyi Wu\ +Jingyi.Wu@uci.edu diff --git a/examples/Wu_BetterThanBest/WU_BetterThanBest.pdf b/examples/Wu_BetterThanBest/WU_BetterThanBest.pdf new file mode 100644 index 0000000000000000000000000000000000000000..c47cd8feb6ba7701c7b2ebdfcc5813462cd53621 GIT binary patch literal 368385 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