Create app.py

app.py

@@ -0,0 +1,195 @@
+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()