app.py

import streamlit as st
import numpy as np
import torch
import torch.nn as nn
import random
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Define a function to generate a dataset
def generate_dataset(task_id):
    X, y = make_classification(n_samples=100, n_features=10, n_informative=5, n_redundant=3, n_repeated=2, random_state=task_id)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=task_id)
    return X_train, X_test, y_train, y_test

# Define a neural network class
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(10, 20)
        self.fc2 = nn.Linear(20, 10)
        self.fc3 = nn.Linear(10, 2)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# Define a genetic algorithm class
class GeneticAlgorithm:
    def __init__(self, population_size):
        self.population_size = population_size
        self.population = [Net() for _ in range(population_size)]

    def selection(self, task_id):
        X_train, X_test, y_train, y_test = generate_dataset(task_id)
        fitness = []
        for net in self.population:
            criterion = nn.CrossEntropyLoss()
            optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
            for epoch in range(10):
                optimizer.zero_grad()
                inputs = torch.tensor(X_train, dtype=torch.float32)
                labels = torch.tensor(y_train, dtype=torch.long)
                outputs = net(inputs)
                loss = criterion(outputs, labels)
                loss.backward()
                optimizer.step()
            inputs = torch.tensor(X_test, dtype=torch.float32)
            labels = torch.tensor(y_test, dtype=torch.long)
            outputs = net(inputs)
            _, predicted = torch.max(outputs, 1)
            accuracy = accuracy_score(labels, predicted)
            fitness.append(accuracy)
        self.population = [self.population[i] for i in np.argsort(fitness)[-self.population_size//2:]]

    def crossover(self):
        offspring = []
        for _ in range(self.population_size//2):
            parent1, parent2 = random.sample(self.population, 2)
            child = Net()
            child.fc1.weight.data = (parent1.fc1.weight.data + parent2.fc1.weight.data) / 2
            child.fc2.weight.data = (parent1.fc2.weight.data + parent2.fc2.weight.data) / 2
            child.fc3.weight.data = (parent1.fc3.weight.data + parent2.fc3.weight.data) / 2
            offspring.append(child)
        self.population += offspring

    def mutation(self):
        for net in self.population:
            if random.random() < 0.1:
                net.fc1.weight.data += torch.randn_like(net.fc1.weight.data) * 0.1
                net.fc2.weight.data += torch.randn_like(net.fc2.weight.data) * 0.1
                net.fc3.weight.data += torch.randn_like(net.fc3.weight.data) * 0.1

# Streamlit app
st.title("Evolution of Sub-Models")

# Parameters
st.sidebar.header("Parameters")
population_size = st.sidebar.slider("Population size", 10, 100, 50)
num_tasks = st.sidebar.slider("Number of tasks", 1, 10, 5)
num_generations = st.sidebar.slider("Number of generations", 1, 100, 10)

# Run the evolution
if st.button("Run evolution"):
    ga = GeneticAlgorithm(population_size)
    for generation in range(num_generations):
        for task_id in range(num_tasks):
            ga.selection(task_id)
            ga.crossover()
            ga.mutation()
        st.write(f"Generation {generation+1} complete")

    # Evaluate the final population
    final_accuracy = []
    for task_id in range(num_tasks):
        X_train, X_test, y_train, y_test = generate_dataset(task_id)
        accuracy = []
        for net in ga.population:
            criterion = nn.CrossEntropyLoss()
            optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
            for epoch in range(10):
                optimizer.zero_grad()
                inputs = torch.tensor(X_train, dtype=torch.float32)
                labels = torch.tensor(y_train, dtype=torch.long)
                outputs = net(inputs)
                loss = criterion(outputs, labels)
                loss.backward()
                optimizer.step()