import pandas as pd import numpy as np import tensorflow as tf import random import gradio as gr from transformers import pipeline # Embedded data gdp_data = { 'Year': [2020, 2020, 2020, 2020, 2021, 2021, 2021, 2021, 2022, 2022, 2022, 2022], 'Quarter': ['Q1', 'Q2', 'Q3', 'Q4', 'Q1', 'Q2', 'Q3', 'Q4', 'Q1', 'Q2', 'Q3', 'Q4'], 'GDP': [21433.2, 19477.6, 21042.5, 21428.5, 22038.2, 22696.3, 22994.6, 23400.0, 24025.7, 24483.7, 24988.5, 25387.7] } population_data = { 'Year': [2020, 2021, 2022], 'Population': [331, 332, 333] # In millions } # Load data def load_gdp_data(): gdp_df = pd.DataFrame(gdp_data) gdp_df['TimePeriod'] = gdp_df['Year'].astype(str) + '-' + gdp_df['Quarter'] gdp_df.set_index('TimePeriod', inplace=True) return gdp_df def load_population_data(): population_df = pd.DataFrame(population_data) total_population = population_df['Population'].sum() * 1e6 # Convert to individual count return total_population # Neural Network for Predictive Analytics def train_neural_network(X, y): model = tf.keras.Sequential([ tf.keras.layers.Dense(64, activation='relu', input_shape=(X.shape[1],)), tf.keras.layers.Dense(1) ]) model.compile(optimizer='adam', loss='mean_squared_error') model.fit(X, y, epochs=100) return model # Agent class class Agent: def __init__(self, income, wealth, consumption_rate): self.income = income self.wealth = wealth self.consumption_rate = consumption_rate def fitness(self): return self.wealth + self.income def reproduce(self, other): income = (self.income + other.income) / 2 wealth = (self.wealth + other.wealth) / 2 consumption_rate = (self.consumption_rate + other.consumption_rate) / 2 if random.random() < 0.1: income += random.uniform(-10, 10) if random.random() < 0.1: wealth += random.uniform(-1000, 1000) if random.random() < 0.1: consumption_rate += random.uniform(-0.1, 0.1) return Agent(income, wealth, consumption_rate) def interact(self, other): trade_amount = min(self.wealth, other.wealth) * 0.1 self.wealth -= trade_amount other.wealth += trade_amount def initialize_population(size): return [Agent(random.uniform(1000, 5000), random.uniform(10000, 50000), random.uniform(0.1, 0.5)) for _ in range(size)] # Genetic Algorithm def genetic_algorithm(population, generations, mutation_rate): for generation in range(generations): population.sort(key=lambda agent: agent.fitness(), reverse=True) top_agents = population[:len(population) // 2] new_population = [] while len(new_population) < len(population): parent1, parent2 = random.sample(top_agents, 2) child = parent1.reproduce(parent2) new_population.append(child) population = new_population return population # Agent-Based Modeling def simulate_abm(population, steps): for step in range(steps): for agent in population: other = random.choice(population) agent.interact(other) return population # Simulation class with AI integration class Simulation: def __init__(self, gdp_df, total_population, ml_model, generator): self.gdp_df = gdp_df self.total_population = total_population self.ml_model = ml_model self.generator = generator def simulate_ubi(self, ubi_amount): total_ubi = self.total_population * ubi_amount new_gdp_df = self.gdp_df.copy() new_gdp_df['GDP'] += total_ubi / 1e9 return new_gdp_df def predict_future_gdp(self, year): prediction = self.ml_model.predict(np.array([year]).reshape(-1, 1)) return prediction[0] def generate_insight(self, prompt): return self.generator(prompt, max_length=100, num_return_sequences=1)[0]['generated_text'] def generative_loop(self, initial_prompt, max_iterations=10, threshold=0.01): prompt = initial_prompt previous_evaluation = None for _ in range(max_iterations): generated_text = self.generate_insight(prompt) evaluation = self.evaluate(generated_text) if previous_evaluation and abs(evaluation - previous_evaluation) < threshold: break previous_evaluation = evaluation prompt = generated_text return generated_text def evaluate(self, text): # Simplified evaluation function return len(text) def run_simulation(ubi_amount, steps, generations, mutation_rate): # Load data gdp_df = load_gdp_data() total_population = load_population_data() # Initialize population population_size = 100 population = initialize_population(population_size) # Train machine learning model X = np.array(gdp_df.index.str.extract('(\d+)', expand=False).astype(int)).reshape(-1, 1) y = np.array(gdp_df['GDP']) ml_model = train_neural_network(X, y) # Initialize GPT-2 generator generator = pipeline('text-generation', model='gpt2') # Run genetic algorithm evolved_population = genetic_algorithm(population, generations, mutation_rate) # Simulate agent-based interactions final_population = simulate_abm(evolved_population, steps) # Create simulation object simulation = Simulation(gdp_df, total_population, ml_model, generator) new_gdp_df = simulation.simulate_ubi(ubi_amount) # Generate insights using GPT-2 with generative loop insight_prompt = f"Given an annual UBI of {ubi_amount} dollars, the expected impact on GDP is" final_insight = simulation.generative_loop(insight_prompt) # Prepare data for visualization original_gdp = gdp_df['GDP'] new_gdp = new_gdp_df['GDP'] return original_gdp.values.tolist(), new_gdp.values.tolist(), final_insight # Gradio interface def create_gradio_interface(): interface = gr.Interface( fn=run_simulation, inputs=[ gr.Slider(0, 50000, step=1000, label="Annual UBI Amount"), gr.Slider(1, 1000, step=1, label="Simulation Steps"), gr.Slider(1, 100, step=1, label="Generations"), gr.Slider(0.0, 1.0, step=0.01, label="Mutation Rate") ], outputs=[ gr.Plot(label="Original GDP"), gr.Plot(label="GDP with UBI"), gr.Textbox(label="Generated Insight") ], title="UBI Impact Simulation with Generative Loop", description="Simulate the impact of Universal Basic Income (UBI) on GDP using genetic algorithms, agent-based modeling, machine learning, and GPT-2 for generating insights with a generative loop.", live=True ) interface.launch() if __name__ == "__MAIN__": create_gradio_interface()