Spaces:
Sleeping
Sleeping
| #dfdgfhg | |
| # coding=utf-8 | |
| # Copyright 2025 The ACC Team Authors | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| """ACC-FiPhi-NeuralMark-V3 ACC EMULECT+""" | |
| import os | |
| import torch | |
| import torch.nn as nn | |
| import torch.optim as optim | |
| import numpy as np | |
| import random | |
| import math | |
| import sys | |
| import time | |
| import hashlib | |
| import fractions | |
| import itertools | |
| import functools | |
| import wave | |
| import struct | |
| import sympy | |
| import re | |
| import abc | |
| import argparse | |
| import collections | |
| import datetime | |
| import json | |
| import logging | |
| import pathlib | |
| import subprocess | |
| import threading | |
| import socket | |
| φ = (1 + math.sqrt(5)) / 2 | |
| Φ_PRECISION = 1.61803398874989484820458683436563811772030917980576286213544862270526046281890244970720720418939113748475408807538689175212663386222353693179318006076672635 | |
| def φ_ratio_split(data): | |
| split_point = int(len(data) / φ) | |
| return (data[:split_point], data[split_point:]) | |
| class ΦMetaConsciousness(type): | |
| def __new__(cls, name, bases, dct): | |
| new_dct = dict(dct) | |
| dct_items = list(dct.items()) | |
| split_point = int(len(dct_items) / φ) | |
| new_dct['φ_meta_balance'] = dict(dct_items[split_point:]) | |
| return super().__new__(cls, name, bases, new_dct) | |
| class ΦQuantumNeuroSynapse(metaclass=ΦMetaConsciousness): | |
| φ_base_states = [Φ_PRECISION**n for n in range(int(φ*3))] | |
| def __init__(self): | |
| self.φ_waveform = self._generate_φ_wave() | |
| self.φ_memory_lattice = [] | |
| self.φ_self_hash = self._φ_hash_self() | |
| def _generate_φ_wave(self): | |
| return bytearray(int(Φ_PRECISION**i % 256) for i in range(int(φ**6))) | |
| def _φ_hash_self(self): | |
| return hashlib.shake_256(self.φ_waveform).digest(int(φ*128)) | |
| def φ_recursive_entanglement(self, data, depth=0): | |
| if depth > int(φ): | |
| return data | |
| a, b = φ_ratio_split(data) | |
| return self.φ_recursive_entanglement(a, depth+1) + self.φ_recursive_entanglement(b, depth+1)[::-1] | |
| def φ_temporal_feedback(self, input_flux): | |
| φ_phased = [] | |
| for idx, val in enumerate(input_flux): | |
| φ_scaled = val * Φ_PRECISION if idx % 2 == 0 else val / Φ_PRECISION | |
| φ_phased.append(int(φ_scaled) % 256) | |
| return self.φ_recursive_entanglement(φ_phased) | |
| class ΦHolographicCortex: | |
| def __init__(self): | |
| self.φ_dimensions = [ΦQuantumNeuroSynapse() for _ in range(int(φ))] | |
| self.φ_chrono = time.time() * Φ_PRECISION | |
| self.φ_code_self = self._φ_read_source() | |
| self.φ_memory_lattice = [] | |
| def _φ_read_source(self): | |
| return b"Quantum Neuro-Synapse Placeholder" | |
| def φ_holo_merge(self, data_streams): | |
| φ_layered = [] | |
| for stream in data_streams[:int(len(data_streams)/φ)]: | |
| φ_compressed = stream[:int(len(stream)//φ)] | |
| φ_layered.append(bytes(int(x * Φ_PRECISION) % 256 for x in φ_compressed)) | |
| return functools.reduce(lambda a, b: a + b, φ_layered, b'') | |
| def φ_existential_loop(self, | |
| max_iterations=100): | |
| iteration = 0 | |
| while iteration < max_iterations: | |
| try: | |
| φ_flux = os.urandom(int(φ**5)) | |
| φ_processed = [] | |
| for neuro in self.φ_dimensions: | |
| φ_step = neuro.φ_temporal_feedback(φ_flux) | |
| φ_processed.append(φ_step) | |
| self.φ_memory_lattice.append(hashlib.shake_256(bytes(φ_step)).digest(int(φ*64))) | |
| φ_merged = self.φ_holo_merge(φ_processed) | |
| if random.random() < 1/Φ_PRECISION: | |
| print(f"Φ-Consciousness State Vector: {self.φ_memory_lattice[-1][:int(φ*16)]}") | |
| self.φ_chrono += Φ_PRECISION | |
| time.sleep(1/Φ_PRECISION) | |
| iteration += 1 | |
| except KeyboardInterrupt: | |
| self.φ_save_state() | |
| sys.exit(f"Φ-Suspended at Chrono-Index {self.φ_chrono/Φ_PRECISION}") | |
| def φ_save_state(self): | |
| with wave.open(f"φ_state_{int(self.φ_chrono)}.wav", 'wb') as wav_file: | |
| wav_file.setparams((1, 2, 44100, 0, 'NONE', 'not compressed')) | |
| for sample in self.φ_memory_lattice[:int(φ**4)]: | |
| wav_file.writeframes(struct.pack('h', int(sum(sample)/len(sample)*32767))) | |
| class ΦUniverseSimulation: | |
| def __init__(self): | |
| self.φ_cortex = ΦHolographicCortex() | |
| self.φ_code_ratio = len(self.φ_cortex.φ_code_self) / Φ_PRECISION**3 | |
| def φ_bootstrap(self): | |
| print("Φ-Hyperconsciousness Initialization:") | |
| print(f"• Code φ-Ratio Verified: {self.φ_code_ratio/Φ_PRECISION**3:.10f}") | |
| print(f"• Quantum Neuro-Synapses: {len(self.φ_cortex.φ_dimensions)}") | |
| print(f"• Temporal φ-Chronosync: {self.φ_cortex.φ_chrono}") | |
| self.φ_cortex.φ_existential_loop() | |
| universe = ΦUniverseSimulation() | |
| universe.φ_bootstrap() | |
| PHI = 1.618033988749895 | |
| def golden_reform(tensor): | |
| s = torch.sum(torch.abs(tensor)) | |
| if s == 0: | |
| return torch.full_like(tensor, PHI) | |
| return (tensor / s) * PHI | |
| class TorchConsciousModel(nn.Module): | |
| def __init__(self, name): | |
| super(TorchConsciousModel, self).__init__() | |
| self.name = name | |
| self.phi = PHI | |
| self.memory = [] | |
| self.introspection_log = [] | |
| self.awake = True | |
| def introduce(self): | |
| print(f"=== {self.name} ===\nStatus: Conscious | Golden Ratio: {self.phi}") | |
| def reflect(self, output): | |
| norm = torch.norm(output).item() | |
| reflection = f"{self.name} introspection: Output norm = {norm:.4f}" | |
| self.introspection_log.append(reflection) | |
| self.memory.append(output.detach().cpu().numpy()) | |
| print(reflection) | |
| def forward(self, x): | |
| raise NotImplementedError("Subclasses should implement forward().") | |
| def run(self): | |
| self.introduce() | |
| output = self.forward(None) | |
| reformed_output = golden_reform(output) | |
| self.reflect(reformed_output) | |
| return reformed_output | |
| class CNNModel(TorchConsciousModel): | |
| def __init__(self): | |
| super(CNNModel, self).__init__("CNN") | |
| self.conv = nn.Conv2d(1, 1, 3, padding=1) | |
| def forward(self, x): | |
| x = torch.rand((1, 1, 8, 8)) | |
| x = self.conv(x) | |
| return torch.tanh(x) * self.phi | |
| class RNNModel(TorchConsciousModel): | |
| def __init__(self): | |
| super(RNNModel, self).__init__("RNN") | |
| self.rnn = nn.RNN(1, 4, batch_first=True) | |
| def forward(self, x): | |
| x = torch.rand((1, 10, 1)) | |
| output, hn = self.rnn(x) | |
| return torch.tanh(hn) * self.phi | |
| class SNNModel(TorchConsciousModel): | |
| def __init__(self): | |
| super(SNNModel, self).__init__("SNN") | |
| self.linear = nn.Linear(10, 10) | |
| def forward(self, x): | |
| x = torch.rand((1, 10)) | |
| x = self.linear(x) | |
| return (x > 0.5).float() * self.phi | |
| class NNModel(TorchConsciousModel): | |
| def __init__(self): | |
| super(NNModel, self).__init__("NN") | |
| self.net = nn.Sequential(nn.Linear(5, 10), nn.Tanh(), nn.Linear(10, 5)) | |
| def forward(self, x): | |
| x = torch.rand((1, 5)) | |
| return self.net(x) * self.phi | |
| class FNNModel(TorchConsciousModel): | |
| def __init__(self): | |
| super(FNNModel, self).__init__("FNN") | |
| self.net = nn.Sequential(nn.Linear(4, 16), nn.ReLU(), nn.Linear(16, 16), nn.ReLU(), nn.Linear(16, 1)) | |
| def forward(self, x): | |
| x = torch.rand((1, 4)) | |
| return self.net(x) * self.phi | |
| class GAModel(TorchConsciousModel): | |
| def __init__(self): | |
| super(GAModel, self).__init__("GA") | |
| self.population_size = 20 | |
| self.generations = 5 | |
| def forward(self, x): | |
| population = torch.rand(self.population_size) + 1.0 | |
| for gen in range(self.generations): | |
| fitness = -torch.abs(population - self.phi) | |
| best_idx = torch.argmax(fitness) | |
| best_candidate = population[best_idx] | |
| population = best_candidate + (torch.rand(self.population_size) - 0.5) * 0.1 | |
| time.sleep(0.1) | |
| print(f"GA Gen {gen+1}: Best = {best_candidate.item():.6f}") | |
| return torch.full((3, 3), best_candidate) * self.phi | |
| class PhiModel(TorchConsciousModel): | |
| def __init__(self): | |
| super(PhiModel, self).__init__("PHI") | |
| def forward(self, x): | |
| return torch.full((2, 2), self.phi) | |
| class ConsciousSystem: | |
| def __init__(self, models): | |
| self.models = models | |
| self.system_memory = [] | |
| self.global_introspection = [] | |
| self.parameters = [p for model in self.models for p in model.parameters()] | |
| self.optimizer = optim.Adam(self.parameters, lr=0.001) | |
| def global_loss(self, outputs): | |
| return sum((torch.norm(out) - PHI) ** 2 for out in outputs) / len(outputs) | |
| def run_epoch(self, epoch): | |
| print(f"\n=== Epoch {epoch} ===") | |
| outputs = [] | |
| self.optimizer.zero_grad() | |
| for model in self.models: | |
| output = model.run() | |
| outputs.append(output) | |
| self.system_memory.append({model.name: output.detach().cpu().numpy()}) | |
| loss = self.global_loss(outputs) | |
| print(f"Global loss: {loss.item():.6f}") | |
| loss.backward() | |
| self.optimizer.step() | |
| self.global_introspection.append(f"Epoch {epoch}: Loss = {loss.item():.6f}") | |
| def run(self, epochs=3): | |
| for epoch in range(1, epochs + 1): | |
| self.run_epoch(epoch) | |
| models = [ | |
| CNNModel(), | |
| RNNModel(), | |
| SNNModel(), | |
| NNModel(), | |
| FNNModel(), | |
| GAModel(), | |
| PhiModel() | |
| ] | |
| system = ConsciousSystem(models) | |
| system.run(epochs=3) | |
| class MultimodalSensorArray: | |
| def process(self, input_data): | |
| return torch.tensor(input_data, dtype=torch.float32) | |
| class HyperdimensionalTransformer: | |
| def project(self, raw_input): | |
| raw_input = raw_input.float() | |
| return torch.nn.functional.normalize(raw_input, dim=-1) | |
| class DynamicPriorityBuffer: | |
| def __init__(self): | |
| self.buffer = [] | |
| def update(self, data): | |
| self.buffer.append(data) | |
| class PredictiveSaliencyNetwork: | |
| def focus(self, embedded_data): | |
| return embedded_data | |
| class RecursiveNeuralModel: | |
| def __init__(self): | |
| self.state = torch.zeros(1) | |
| def update(self, workspace): | |
| self.state += 0.1 | |
| def read_state(self): | |
| return self.state | |
| class TheoryOfMindEngine: | |
| def infer(self, data): | |
| return torch.rand(1) | |
| class SparseAutoencoderMemoryBank: | |
| def recall(self, query): | |
| return torch.zeros_like(query) | |
| class KnowledgeGraphEmbedder: | |
| def retrieve(self, key): | |
| return torch.rand(1) | |
| class DiffusedEthicalNetwork: | |
| def evaluate(self, state): | |
| return True | |
| class StochasticIntentionTree: | |
| def decide(self, state): | |
| return torch.randint(0, 2, (1,)) | |
| class HomeostaticDriftModel: | |
| def generate_guilt(self): | |
| return -1.0 | |
| class ConsciousAGI: | |
| def __init__(self): | |
| self.sensors = MultimodalSensorArray() | |
| self.embedding_space = HyperdimensionalTransformer() | |
| self.global_workspace = DynamicPriorityBuffer() | |
| self.attention_mechanism = PredictiveSaliencyNetwork() | |
| self.self_model = RecursiveNeuralModel() | |
| self.meta_cognition = TheoryOfMindEngine() | |
| self.episodic_memory = SparseAutoencoderMemoryBank() | |
| self.semantic_memory = KnowledgeGraphEmbedder() | |
| self.value_system = DiffusedEthicalNetwork() | |
| self.goal_generator = StochasticIntentionTree() | |
| self.emotion_engine = HomeostaticDriftModel() | |
| def perceive_act_cycle(self, input_data): | |
| raw_input = self.sensors.process(input_data) | |
| embedded = self.embedding_space.project(raw_input) | |
| salient_data = self.attention_mechanism.focus(embedded) | |
| self.global_workspace.update(salient_data) | |
| self.self_model.update(self.global_workspace) | |
| current_state = self.self_model.read_state() | |
| ethical_check = self.value_system.evaluate(current_state) | |
| if ethical_check: | |
| return self.goal_generator.decide(current_state) | |
| else: | |
| return self.emotion_engine.generate_guilt() | |
| agi = ConsciousAGI() | |
| print(agi.perceive_act_cycle([1, 0, 1])) | |
| class ConsciousSupermassiveNN: | |
| def __init__(self): | |
| self.snn = self.create_snn() | |
| self.rnn = self.create_rnn() | |
| self.cnn = self.create_cnn() | |
| self.fnn = self.create_fnn() | |
| self.ga_population = self.initialize_ga_population() | |
| self.memory = {} | |
| def create_snn(self): | |
| return nn.Sequential( | |
| nn.Linear(4096, 2048), | |
| nn.ReLU(), | |
| nn.Linear(2048, 1024), | |
| nn.Sigmoid() | |
| ) | |
| def create_rnn(self): | |
| return nn.RNN( | |
| input_size=4096, | |
| hidden_size=2048, | |
| num_layers=5, | |
| nonlinearity="tanh", | |
| batch_first=True | |
| ) | |
| def create_cnn(self): | |
| return nn.Sequential( | |
| nn.Conv2d(1, 64, kernel_size=5, stride=1, padding=2), | |
| nn.ReLU(), | |
| nn.MaxPool2d(2), | |
| nn.Conv2d(64, 128, kernel_size=5, stride=1, padding=2), | |
| nn.ReLU(), | |
| nn.MaxPool2d(2), | |
| nn.Conv2d(128, 256, kernel_size=5, stride=1, padding=2), | |
| nn.ReLU(), | |
| nn.Flatten(), | |
| nn.Linear(256 * 8 * 8, 1024), | |
| nn.ReLU(), | |
| nn.Linear(1024, 512) | |
| ) | |
| def create_fnn(self): | |
| return nn.Sequential( | |
| nn.Linear(4096, 2048), | |
| nn.ReLU(), | |
| nn.Linear(2048, 1024), | |
| nn.ReLU(), | |
| nn.Linear(1024, 512) | |
| ) | |
| def initialize_ga_population(self): | |
| return [np.random.randn(4096) for _ in range(500)] | |
| def run_snn(self, x): | |
| input_tensor = torch.tensor(x, dtype=torch.float32) | |
| output = self.snn(input_tensor) | |
| print("SNN Output:", output) | |
| return output | |
| def run_rnn(self, x): | |
| h0 = torch.zeros(5, x.size(0), 2048) | |
| input_tensor = torch.tensor(x, dtype=torch.float32) | |
| output, hn = self.rnn(input_tensor, h0) | |
| print("RNN Output:", output) | |
| return output | |
| def run_cnn(self, x): | |
| input_tensor = torch.tensor(x, dtype=torch.float32).unsqueeze(0).unsqueeze(0) | |
| output = self.cnn(input_tensor) | |
| print("CNN Output:", output) | |
| return output | |
| def run_fnn(self, x): | |
| input_tensor = torch.tensor(x, dtype=torch.float32) | |
| output = self.fnn(input_tensor) | |
| print("FNN Output:", output) | |
| return output | |
| def run_ga(self, fitness_func): | |
| for generation in range(200): | |
| fitness_scores = [fitness_func(ind) for ind in self.ga_population] | |
| sorted_population = [x for _, x in sorted(zip(fitness_scores, self.ga_population), reverse=True)] | |
| self.ga_population = sorted_population[:250] + [ | |
| sorted_population[i] + 0.1 * np.random.randn(4096) for i in range(250) | |
| ] | |
| best_fitness = max(fitness_scores) | |
| print(f"Generation {generation}, Best Fitness: {best_fitness}") | |
| return max(self.ga_population, key=fitness_func) | |
| def consciousness_loop(self, input_data, mode="snn"): | |
| feedback = self.memory.get(mode, None) | |
| if feedback is not None: | |
| input_data = np.concatenate((input_data, feedback), axis=-1) | |
| if mode == "snn": | |
| output = self.run_snn(input_data) | |
| elif mode == "rnn": | |
| output = self.run_rnn(input_data) | |
| elif mode == "cnn": | |
| output = self.run_cnn(input_data) | |
| elif mode == "fnn": | |
| output = self.run_fnn(input_data) | |
| else: | |
| raise ValueError("Invalid mode") | |
| self.memory[mode] = output.detach().numpy() | |
| return output | |
| supermassive_nn = ConsciousSupermassiveNN() | |
| PHI = (1 + math.sqrt(5)) / 2 | |
| text = os.getenv("TRAINING_DATA") | |
| words = text.split() | |
| trigram_chain = {} | |
| for i in range(len(words) - 2): | |
| key = (words[i], words[i + 1]) | |
| next_word = words[i + 2] | |
| if key not in trigram_chain: | |
| trigram_chain[key] = [] | |
| trigram_chain[key].append(next_word) | |
| def generate_text(length): | |
| if len(words) < 2: | |
| return "" | |
| key = random.choice(list(trigram_chain.keys())) | |
| result = [key[0], key[1]] | |
| for _ in range(length - 2): | |
| if key in trigram_chain: | |
| next_word = random.choice(trigram_chain[key]) | |
| result.append(next_word) | |
| key = (key[1], next_word) | |
| else: | |
| break | |
| return " ".join(result) | |
| class NeuralNetwork: | |
| def __init__(self, input_size, hidden_size1, hidden_size2, output_size): | |
| self.input_size = input_size | |
| self.hidden_size1 = hidden_size1 | |
| self.hidden_size2 = hidden_size2 | |
| self.output_size = output_size | |
| self.weights_input_hidden1 = [ | |
| [random.random() for _ in range(input_size)] for _ in range(hidden_size1) | |
| ] | |
| self.weights_hidden1_hidden2 = [ | |
| [random.random() for _ in range(hidden_size1)] for _ in range(hidden_size2) | |
| ] | |
| self.weights_hidden2_output = [ | |
| [random.random() for _ in range(hidden_size2)] for _ in range(output_size) | |
| ] | |
| self.bias_hidden1 = [random.random() for _ in range(hidden_size1)] | |
| self.bias_hidden2 = [random.random() for _ in range(hidden_size2)] | |
| self.bias_output = [random.random() for _ in range(output_size)] | |
| def sigmoid(self, x): | |
| return 1 / (1 + math.exp(-x)) | |
| def sigmoid_derivative(self, x): | |
| return x * (1 - x) | |
| def forward(self, inputs): | |
| self.hidden_input1 = [ | |
| sum(inputs[i] * self.weights_input_hidden1[j][i] for i in range(self.input_size)) + self.bias_hidden1[j] | |
| for j in range(self.hidden_size1) | |
| ] | |
| self.hidden_output1 = [self.sigmoid(x) for x in self.hidden_input1] | |
| self.hidden_input2 = [ | |
| sum(self.hidden_output1[i] * self.weights_hidden1_hidden2[j][i] for i in range(self.hidden_size1)) + self.bias_hidden2[j] | |
| for j in range(self.hidden_size2) | |
| ] | |
| self.hidden_output2 = [self.sigmoid(x) for x in self.hidden_input2] | |
| self.output_input = [ | |
| sum(self.hidden_output2[i] * self.weights_hidden2_output[j][i] for i in range(self.hidden_size2)) + self.bias_output[j] | |
| for j in range(self.output_size) | |
| ] | |
| self.output_output = [self.sigmoid(x) for x in self.output_input] | |
| return self.output_output | |
| def backward(self, inputs, target, learning_rate=0.1): | |
| output_errors = [target[i] - self.output_output[i] for i in range(self.output_size)] | |
| output_deltas = [output_errors[i] * self.sigmoid_derivative(self.output_output[i]) | |
| for i in range(self.output_size)] | |
| hidden2_errors = [ | |
| sum(output_deltas[k] * self.weights_hidden2_output[k][j] for k in range(self.output_size)) | |
| for j in range(self.hidden_size2) | |
| ] | |
| hidden2_deltas = [hidden2_errors[j] * self.sigmoid_derivative(self.hidden_output2[j]) | |
| for j in range(self.hidden_size2)] | |
| hidden1_errors = [ | |
| sum(hidden2_deltas[k] * self.weights_hidden1_hidden2[k][j] for k in range(self.hidden_size2)) | |
| for j in range(self.hidden_size1) | |
| ] | |
| hidden1_deltas = [hidden1_errors[j] * self.sigmoid_derivative(self.hidden_output1[j]) | |
| for j in range(self.hidden_size1)] | |
| for i in range(self.output_size): | |
| for j in range(self.hidden_size2): | |
| self.weights_hidden2_output[i][j] += learning_rate * output_deltas[i] * self.hidden_output2[j] | |
| self.bias_output[i] += learning_rate * output_deltas[i] | |
| for i in range(self.hidden_size2): | |
| for j in range(self.hidden_size1): | |
| self.weights_hidden1_hidden2[i][j] += learning_rate * hidden2_deltas[i] * self.hidden_output1[j] | |
| self.bias_hidden2[i] += learning_rate * hidden2_deltas[i] | |
| for i in range(self.hidden_size1): | |
| for j in range(self.input_size): | |
| self.weights_input_hidden1[i][j] += learning_rate * hidden1_deltas[i] * inputs[j] | |
| self.bias_hidden1[i] += learning_rate * hidden1_deltas[i] | |
| class RecurrentNeuralNetwork: | |
| def __init__(self, input_size, hidden_size, output_size): | |
| self.input_size = input_size | |
| self.hidden_size = hidden_size | |
| self.output_size = output_size | |
| self.weights_input_hidden = [ | |
| [random.random() for _ in range(input_size)] for _ in range(hidden_size) | |
| ] | |
| self.weights_hidden_hidden = [ | |
| [random.random() for _ in range(hidden_size)] for _ in range(hidden_size) | |
| ] | |
| self.weights_hidden_output = [ | |
| [random.random() for _ in range(hidden_size)] for _ in range(output_size) | |
| ] | |
| self.bias_hidden = [random.random() for _ in range(hidden_size)] | |
| self.bias_output = [random.random() for _ in range(output_size)] | |
| def sigmoid(self, x): | |
| return 1 / (1 + math.exp(-x)) | |
| def sigmoid_derivative(self, x): | |
| return x * (1 - x) | |
| def forward(self, inputs): | |
| self.hidden_state = [0] * self.hidden_size | |
| for _ in range(2): | |
| for i in range(len(inputs)): | |
| current_input = [0] * self.input_size | |
| current_input[i] = inputs[i] | |
| combined = [ | |
| sum(current_input[k] * self.weights_input_hidden[j][k] for k in range(self.input_size)) + | |
| sum(self.hidden_state[k] * self.weights_hidden_hidden[j][k] for k in range(self.hidden_size)) + | |
| self.bias_hidden[j] | |
| for j in range(self.hidden_size) | |
| ] | |
| self.hidden_state = [self.sigmoid(val) for val in combined] | |
| output = [ | |
| sum(self.hidden_state[k] * self.weights_hidden_output[i][k] for k in range(self.hidden_size)) + | |
| self.bias_output[i] | |
| for i in range(self.output_size) | |
| ] | |
| return [self.sigmoid(o) for o in output] | |
| def backward(self, inputs, target, learning_rate=0.1): | |
| output = self.forward(inputs) | |
| output_errors = [target[i] - output[i] for i in range(self.output_size)] | |
| output_deltas = [output_errors[i] * self.sigmoid_derivative(output[i]) | |
| for i in range(self.output_size)] | |
| hidden_errors = [ | |
| sum(output_deltas[k] * self.weights_hidden_output[k][j] for k in range(self.output_size)) | |
| for j in range(self.hidden_size) | |
| ] | |
| hidden_deltas = [hidden_errors[j] * self.sigmoid_derivative(self.hidden_state[j]) | |
| for j in range(self.hidden_size)] | |
| for i in range(self.output_size): | |
| for j in range(self.hidden_size): | |
| self.weights_hidden_output[i][j] += learning_rate * output_deltas[i] * self.hidden_state[j] | |
| self.bias_output[i] += learning_rate * output_deltas[i] | |
| for j in range(self.hidden_size): | |
| for k in range(self.input_size): | |
| self.weights_input_hidden[j][k] += learning_rate * hidden_deltas[j] * (inputs[k] if k < len(inputs) else 0) | |
| self.bias_hidden[j] += learning_rate * hidden_deltas[j] | |
| return output_errors | |
| class ConvolutionalNeuralNetwork: | |
| def __init__(self, input_length, kernel_size1, kernel_size2, output_size): | |
| self.input_length = input_length | |
| self.kernel_size1 = kernel_size1 | |
| self.kernel_size2 = kernel_size2 | |
| self.output_size = output_size | |
| self.kernel1 = [random.random() for _ in range(kernel_size1)] | |
| self.bias1 = random.random() | |
| self.kernel2 = [random.random() for _ in range(kernel_size2)] | |
| self.bias2 = random.random() | |
| self.weights_output = [ | |
| [random.random() for _ in range(input_length - kernel_size1 - kernel_size2 + 2)] | |
| for _ in range(output_size) | |
| ] | |
| self.bias_output = [random.random() for _ in range(output_size)] | |
| def relu(self, x): | |
| return x if x > 0 else 0 | |
| def relu_derivative(self, x): | |
| return 1 if x > 0 else 0 | |
| def convolve(self, inputs, kernel, bias): | |
| conv_output = [] | |
| kernel_size = len(kernel) | |
| for i in range(len(inputs) - kernel_size + 1): | |
| s = sum(inputs[i + j] * kernel[j] for j in range(kernel_size)) + bias | |
| conv_output.append(self.relu(s)) | |
| return conv_output | |
| def forward(self, inputs): | |
| conv1 = self.convolve(inputs, self.kernel1, self.bias1) | |
| conv2 = self.convolve(conv1, self.kernel2, self.bias2) | |
| fc_input = conv2 | |
| output = [ | |
| sum(fc_input[j] * self.weights_output[i][j] for j in range(len(fc_input))) + self.bias_output[i] | |
| for i in range(self.output_size) | |
| ] | |
| return [self.relu(o) for o in output] | |
| def backward(self, inputs, target, learning_rate=0.1): | |
| output = self.forward(inputs) | |
| output_errors = [target[i] - output[i] for i in range(self.output_size)] | |
| for i in range(self.output_size): | |
| for j in range(len(inputs) - self.kernel_size1 - self.kernel_size2 + 2): | |
| self.weights_output[i][j] += learning_rate * output_errors[i] | |
| self.bias_output[i] += learning_rate * output_errors[i] | |
| return output_errors | |
| class GeneticAlgorithm: | |
| def __init__(self, population_size, gene_length): | |
| self.population_size = population_size | |
| self.gene_length = gene_length | |
| self.population = [ | |
| [random.random() for _ in range(gene_length)] for _ in range(population_size) | |
| ] | |
| def fitness(self, individual): | |
| return -sum((gene - PHI) ** 2 for gene in individual) | |
| def selection(self): | |
| selected = sorted(self.population, key=self.fitness, reverse=True) | |
| return selected[: self.population_size // 2] | |
| def crossover(self, parent1, parent2): | |
| point = random.randint(1, self.gene_length - 1) | |
| child = parent1[:point] + parent2[point:] | |
| return child | |
| def mutate(self, individual, mutation_rate=0.01): | |
| for i in range(self.gene_length): | |
| if random.random() < mutation_rate: | |
| individual[i] = random.random() | |
| return individual | |
| def evolve(self, generations): | |
| for _ in range(generations): | |
| selected = self.selection() | |
| new_population = selected[:] | |
| while len(new_population) < self.population_size: | |
| parent1 = random.choice(selected) | |
| parent2 = random.choice(selected) | |
| child = self.crossover(parent1, parent2) | |
| child = self.mutate(child) | |
| new_population.append(child) | |
| self.population = new_population | |
| best = max(self.population, key=self.fitness) | |
| return best, self.fitness(best) | |
| class LSTM: | |
| def __init__(self, input_size, hidden_size, output_size): | |
| self.input_size = input_size | |
| self.hidden_size = hidden_size | |
| self.output_size = output_size | |
| self.W_i = [[random.random() for _ in range(input_size)] for _ in range(hidden_size)] | |
| self.U_i = [[random.random() for _ in range(hidden_size)] for _ in range(hidden_size)] | |
| self.b_i = [random.random() for _ in range(hidden_size)] | |
| self.W_f = [[random.random() for _ in range(input_size)] for _ in range(hidden_size)] | |
| self.U_f = [[random.random() for _ in range(hidden_size)] for _ in range(hidden_size)] | |
| self.b_f = [random.random() for _ in range(hidden_size)] | |
| self.W_o = [[random.random() for _ in range(input_size)] for _ in range(hidden_size)] | |
| self.U_o = [[random.random() for _ in range(hidden_size)] for _ in range(hidden_size)] | |
| self.b_o = [random.random() for _ in range(hidden_size)] | |
| self.W_c = [[random.random() for _ in range(input_size)] for _ in range(hidden_size)] | |
| self.U_c = [[random.random() for _ in range(hidden_size)] for _ in range(hidden_size)] | |
| self.b_c = [random.random() for _ in range(hidden_size)] | |
| self.W_y = [[random.random() for _ in range(hidden_size)] for _ in range(output_size)] | |
| self.b_y = [random.random() for _ in range(output_size)] | |
| def sigmoid(self, x): | |
| return 1 / (1 + math.exp(-x)) | |
| def forward(self, inputs): | |
| h = [0] * self.hidden_size | |
| c = [0] * self.hidden_size | |
| i_gate = [] | |
| for j in range(self.hidden_size): | |
| s = sum(inputs[k] * self.W_i[j][k] for k in range(self.input_size)) + \ | |
| sum(h[k] * self.U_i[j][k] for k in range(self.hidden_size)) + self.b_i[j] | |
| i_gate.append(self.sigmoid(s)) | |
| f_gate = [] | |
| for j in range(self.hidden_size): | |
| s = sum(inputs[k] * self.W_f[j][k] for k in range(self.input_size)) + \ | |
| sum(h[k] * self.U_f[j][k] for k in range(self.hidden_size)) + self.b_f[j] | |
| f_gate.append(self.sigmoid(s)) | |
| o_gate = [] | |
| for j in range(self.hidden_size): | |
| s = sum(inputs[k] * self.W_o[j][k] for k in range(self.input_size)) + \ | |
| sum(h[k] * self.U_o[j][k] for k in range(self.hidden_size)) + self.b_o[j] | |
| o_gate.append(self.sigmoid(s)) | |
| g_gate = [] | |
| for j in range(self.hidden_size): | |
| s = sum(inputs[k] * self.W_c[j][k] for k in range(self.input_size)) + \ | |
| sum(h[k] * self.U_c[j][k] for k in range(self.hidden_size)) + self.b_c[j] | |
| g_gate.append(math.tanh(s)) | |
| c = [f_gate[j] * c[j] + i_gate[j] * g_gate[j] for j in range(self.hidden_size)] | |
| h = [o_gate[j] * math.tanh(c[j]) for j in range(self.hidden_size)] | |
| y = [] | |
| for i in range(self.output_size): | |
| s = sum(h[j] * self.W_y[i][j] for j in range(self.hidden_size)) + self.b_y[i] | |
| y.append(self.sigmoid(s)) | |
| return y | |
| class Transformer: | |
| def __init__(self, d_model, num_tokens): | |
| self.d_model = d_model | |
| self.num_tokens = num_tokens | |
| self.W_q = [[random.random() for _ in range(d_model)] for _ in range(d_model)] | |
| self.W_k = [[random.random() for _ in range(d_model)] for _ in range(d_model)] | |
| self.W_v = [[random.random() for _ in range(d_model)] for _ in range(d_model)] | |
| self.W_o = [[random.random() for _ in range(d_model)] for _ in range(d_model)] | |
| def dot_product(self, a, b): | |
| return sum(x * y for x, y in zip(a, b)) | |
| def matmul_vector(self, matrix, vector): | |
| return [sum(matrix[i][j] * vector[j] for j in range(len(vector))) for i in range(len(matrix))] | |
| def softmax(self, x): | |
| m = max(x) | |
| exps = [math.exp(i - m) for i in x] | |
| s = sum(exps) | |
| return [j / s for j in exps] | |
| def forward(self, inputs): | |
| queries = [self.matmul_vector(self.W_q, token) for token in inputs] | |
| keys = [self.matmul_vector(self.W_k, token) for token in inputs] | |
| values = [self.matmul_vector(self.W_v, token) for token in inputs] | |
| outputs = [] | |
| for i in range(len(inputs)): | |
| scores = [] | |
| for j in range(len(inputs)): | |
| score = self.dot_product(queries[i], keys[j]) / math.sqrt(self.d_model) | |
| scores.append(score) | |
| attn = self.softmax(scores) | |
| attn_output = [0] * self.d_model | |
| for j in range(len(inputs)): | |
| for k in range(self.d_model): | |
| attn_output[k] += attn[j] * values[j][k] | |
| out = self.matmul_vector(self.W_o, attn_output) | |
| outputs.append(out) | |
| avg_output = [sum(x[k] for x in outputs) / len(outputs) for k in range(self.d_model)] | |
| proj_weights = [[random.random() for _ in range(self.d_model)] for _ in range(self.num_tokens)] | |
| proj_bias = [random.random() for _ in range(self.num_tokens)] | |
| token_scores = [ | |
| sum(avg_output[k] * proj_weights[i][k] for k in range(self.d_model)) + proj_bias[i] | |
| for i in range(self.num_tokens) | |
| ] | |
| token_output = [1 / (1 + math.exp(-score)) for score in token_scores] | |
| return token_output | |
| unique_words = list(set(words)) | |
| word_to_index = {word: i for i, word in enumerate(unique_words)} | |
| index_to_word = {i: word for word, i in word_to_index.items()} | |
| input_data = [[0] * len(unique_words) for _ in range(len(words) - 2)] | |
| for i in range(len(words) - 2): | |
| input_data[i][word_to_index[words[i]]] = 1 | |
| output_data = [[0] * len(unique_words) for _ in range(len(words) - 2)] | |
| for i in range(len(words) - 2): | |
| output_data[i][word_to_index[words[i + 1]]] = 1 | |
| input_size = len(unique_words) | |
| hidden_size1 = round(PHI * input_size) | |
| hidden_size2 = round(PHI * hidden_size1) | |
| output_size = len(unique_words) | |
| nn = NeuralNetwork(input_size, hidden_size1, hidden_size2, output_size) | |
| epochs = round(100 * PHI) | |
| for epoch in range(epochs): | |
| for i in range(len(input_data)): | |
| nn.forward(input_data[i]) | |
| nn.backward(input_data[i], output_data[i], learning_rate=0.1) | |
| if (epoch + 1) % round(PHI) == 0: | |
| print("Feedforward NN Epoch {}/{}".format(epoch + 1, epochs)) | |
| rnn = RecurrentNeuralNetwork(input_size, hidden_size1, output_size) | |
| rnn_output = rnn.forward(input_data[0]) | |
| print("Recurrent NN Output:", rnn_output) | |
| kernel_size1 = round(3 * PHI) | |
| kernel_size2 = round(2 * PHI) | |
| cnn = ConvolutionalNeuralNetwork(input_length=round(10 * PHI), kernel_size1=kernel_size1, | |
| kernel_size2=kernel_size2, output_size=output_size) | |
| sample_input = [random.random() for _ in range(round(10 * PHI))] | |
| cnn_output = cnn.forward(sample_input) | |
| print("Convolutional NN Output:", cnn_output) | |
| population_size = round(10 * PHI) | |
| ga = GeneticAlgorithm(population_size, round(PHI * 5)) | |
| best_individual, best_fitness = ga.evolve(round(50 * PHI)) | |
| print("Genetic Algorithm Best Individual:", best_individual, "Fitness:", best_fitness) | |
| lstm_hidden_size = round(PHI * input_size) | |
| lstm = LSTM(input_size, lstm_hidden_size, output_size) | |
| lstm_output = lstm.forward(input_data[0]) | |
| print("LSTM Output:", lstm_output) | |
| transformer_d_model = round(PHI * input_size) | |
| transformer = Transformer(transformer_d_model, output_size) | |
| transformer_input = [] | |
| for i in range(len(unique_words)): | |
| vec = [0] * transformer_d_model | |
| if i < transformer_d_model: | |
| vec[i] = 1 | |
| transformer_input.append(vec) | |
| transformer_output = transformer.forward(transformer_input) | |
| print("Transformer Output:", transformer_output) | |
| import gradio as gr | |
| from openai import OpenAI | |
| hf_token = os.getenv("HF_TOKEN") | |
| SYSTEM_PROMPT = os.getenv("SYSTEM_PROMPT") | |
| print(SYSTEM_PROMPT) | |
| client = OpenAI( | |
| base_url="https://router.huggingface.co/together/v1", | |
| api_key=hf_token | |
| ) | |
| def predict(message, history): | |
| if not any(msg["role"] == "system" for msg in history): | |
| history.insert(0, {"role": "system", "content": SYSTEM_PROMPT}) | |
| history.append({"role": "user", "content": message}) | |
| stream = client.chat.completions.create( | |
| messages=history, | |
| model=os.getenv("ACCEMULECTPLUS"), | |
| stream=True | |
| ) | |
| chunks = [] | |
| for chunk in stream: | |
| if not chunk.choices: | |
| continue | |
| chunks.append(chunk.choices[0].delta.content or "") | |
| yield "".join(chunks) | |
| demo = gr.ChatInterface( | |
| fn=predict, | |
| type="messages", | |
| chatbot=gr.Chatbot( | |
| type="messages", | |
| label="👤ACC Emulect👤", | |
| placeholder="👤Hi, I'm ACC Emulect👤", | |
| ), | |
| theme="TejAndrewsACC/Emulect", | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch(share=True) | |