""" ******************** This version of NEBULA is a simplified working demo ********************** NEBULA.py: Dynamic Quantum-Inspired Neural Network System **Francisco Angulo de Lafuente** **July 16, 2024** https://github.com/Agnuxo1 **************************************** NEBULA FEATURES **************************************** This program simulates a sophisticated artificial intelligence system inspired by quantum computing principles and biological neural networks. It features: - A dynamic, continuous 3D space where neurons interact based on light-based attraction, mimicking a nebula. - Virtual neurons and qubits for scalability. - Holographic encoding for efficient state representation using CNNs. - Parallel processing using Ray for accelerated computation. - Genetic optimization (DEAP) for learning and adaptation. The system is designed to process information, learn from interactions, and answer questions based on its internal representations. This version (NEBULA) integrates the improved holographic system using CNNs for encoding and decoding. NEBULA: Neural Entanglement-Based Unified Learning Architecture NEBULA is a dynamic and innovative artificial intelligence system designed to emulate quantum computing principles and biological neural networks. It features a unique combination of continuous space, light-based attraction, virtual neurons and qubits, holographic encoding, and other advanced features that enable it to adapt, learn, and solve complex problems in various domains such as text, image, and numerical data processing. **************************************** NEBULA DEFINITION **************************************** N: Neural networks - The system is inspired by biological neural networks, enabling it to learn from data, adapt to new information, and solve complex tasks. E: Entanglement-based - NEBULA leverages the principles of quantum entanglement to create complex relationships between virtual neurons and qubits, enhancing the system's efficiency and learning capabilities. B: Biological - The system simulates organic structures, such as a nebula, to create an environment where virtual neurons interact in a more natural and dynamic way. U: Unified Learning - NEBULA integrates various AI techniques, such as genetic optimization, language model training, and parallel processing, to create a comprehensive learning architecture. L: Light-based attraction - The system uses light-based attraction between virtual neurons to simulate gravitational forces and facilitate dynamic clustering, improving the efficiency of neural interactions. A: Adaptive - NEBULA is designed to adapt to new information and optimize its structure over time, ensuring continuous learning and improvement. """ import numpy as np import cupy as cp import ray import pennylane as qml import torch import torch.nn as nn import torch.nn.functional as F from torch.cuda.amp import autocast, GradScaler from sklearn.metrics.pairwise import cosine_similarity import trimesh import matplotlib.pyplot as plt import os import time import uuid import logging from typing import List, Dict, Tuple, Any, Optional, Union from deap import base, creator, tools, algorithms import random from tqdm import tqdm import signal import functools # Global variables EPOCH = 5 DIM = 1024 # Reduced dimension for CNN compatibility SECTOR_SIZE = 32 NEURONS_PER_SECTOR = 50000 MAX_SECTORS = 100 # Maximum number of sectors, adjustable for scalability TRAIN_EPOCH = 5 # Global counter for training epochs # Configure logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # Predefined questions and answers about the Solar System solar_system_qa = { "Planets": [ {"question": "Is Mars bigger than Earth?", "answer": "No"}, {"question": "Does Jupiter have more moons than any other planet in our solar system?", "answer": "Yes"}, {"question": "Is Venus the hottest planet in our solar system?", "answer": "Yes"}, {"question": "Is Uranus known for its prominent rings?", "answer": "No"}, {"question": "Is Mercury the closest planet to the Sun?", "answer": "Yes"} ], "Earth": [ {"question": "Is Earth the largest planet in the solar system?", "answer": "No"}, {"question": "Does Earth have one moon?", "answer": "Yes"}, {"question": "Is Earth mostly covered in water?", "answer": "Yes"}, {"question": "Is Earth further from the sun than Mars?", "answer": "No"}, {"question": "Does Earth have rings?", "answer": "No"} ] } def timeout(seconds): def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): def handler(signum, frame): raise TimeoutError(f"Function {func.__name__} timed out after {seconds} seconds") signal.signal(signal.SIGALRM, handler) signal.alarm(seconds) try: result = func(*args, **kwargs) finally: signal.alarm(0) return result return wrapper return decorator class AmplitudeCNN(nn.Module): """ CNN for decoding the amplitude component of the hologram. """ def __init__(self): super(AmplitudeCNN, self).__init__() self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1) self.bn1 = nn.BatchNorm2d(32) self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) self.bn2 = nn.BatchNorm2d(64) self.fc = nn.Linear(64 * 8 * 8, DIM) self.dropout = nn.Dropout(0.5) def forward(self, x): x = F.relu(self.bn1(self.conv1(x))) x = F.relu(self.bn2(self.conv2(x))) x = x.view(-1, 64 * 8 * 8) x = self.dropout(x) return self.fc(x) class PhaseCNN(nn.Module): """ CNN for decoding the phase component of the hologram. """ def __init__(self): super(PhaseCNN, self).__init__() self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1) self.bn1 = nn.BatchNorm2d(32) self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) self.bn2 = nn.BatchNorm2d(64) self.fc = nn.Linear(64 * 8 * 8, DIM) self.dropout = nn.Dropout(0.5) def forward(self, x): x = F.relu(self.bn1(self.conv1(x))) x = F.relu(self.bn2(self.conv2(x))) x = x.view(-1, 64 * 8 * 8) x = self.dropout(x) return self.fc(x) class HologramCodec: """ Encodes and decodes data using a holographic representation. This codec uses Fast Fourier Transforms (FFT) for encoding and inverse FFT for decoding, providing an efficient way to represent and compress the network's state. It also incorporates CNNs for amplitude and phase decoding and utilizes mixed precision training for potential speed and memory benefits. """ def __init__(self, dim: int = DIM): """ Initializes the HologramCodec. Args: dim (int): The dimensionality of the holographic representation. Defaults to the global DIM value. """ self.dim = dim self.amplitude_cnn = AmplitudeCNN().to('cuda') self.phase_cnn = PhaseCNN().to('cuda') self.scaler = GradScaler() def encode(self, data: np.ndarray, sector_index: int) -> torch.Tensor: """ Encodes data into a holographic representation using a 3D FFT. """ gpu_data = cp.asarray(data) gpu_data = cp.fft.fftn(gpu_data) hologram = torch.as_tensor(gpu_data, dtype=torch.complex64).to('cuda') return hologram def decode(self, hologram: torch.Tensor, sector_id: str) -> np.ndarray: """ Decodes a holographic representation back to the original data using CNNs and inverse 3D FFT. Args: hologram (torch.Tensor): The encoded holographic data. sector_id (str): The ID of the sector being decoded. Returns: np.ndarray: The decoded data in its original format. """ logger.info(f"Decoding sector {sector_id}, data type: {type(hologram)}, shape: {hologram.shape}") with autocast(): amplitude = self.amplitude_cnn(hologram[None, None, :, :, :]) phase = self.phase_cnn(hologram[None, None, :, :, :]) complex_data = amplitude * torch.exp(1j * phase) gpu_data = cp.fft.ifftn(cp.asarray(complex_data.cpu()), axes=(0, 1, 2)) decoded_data = cp.asnumpy(gpu_data) / (self.dim ** 3) # Reshape data back to its original form decoded_data = decoded_data.flatten() logger.info(f"Decoded data type: {type(decoded_data)}, shape: {decoded_data.shape}") return decoded_data class QuantumNeuron: """ A quantum-inspired neuron using a parameterized quantum circuit. This neuron processes information using a quantum circuit simulated with PennyLane. The circuit's parameters (weights) are adjustable, allowing the neuron to learn and adapt. """ def __init__(self, n_qubits: int = 4): """ Initializes the QuantumNeuron. Args: n_qubits (int): The number of qubits used in the quantum circuit. Defaults to 4. """ self.n_qubits = n_qubits self.dev = qml.device("default.qubit", wires=n_qubits) # Create a PennyLane quantum device # Define the quantum circuit @qml.qnode(self.dev) def quantum_circuit(inputs, weights): for i in range(n_qubits): qml.RY(inputs[i], wires=i) # Apply RY gate with input data for i in range(n_qubits): qml.RX(weights[i], wires=i) # Apply RX and RZ gates with weights qml.RZ(weights[i + n_qubits], wires=i) for i in range(n_qubits - 1): qml.CNOT(wires=[i, i + 1]) # Apply CNOT gates for entanglement qml.CRZ(weights[-1], wires=[0, n_qubits-1]) # Apply CRZ gate return [qml.expval(qml.PauliZ(i)) for i in range(n_qubits)] # Measure in Z basis self.quantum_circuit = quantum_circuit self.weights = np.random.randn(2 * n_qubits + 1) # Initialize weights randomly def forward(self, inputs: np.ndarray) -> np.ndarray: """ Performs a forward pass through the quantum circuit. Args: inputs (np.ndarray): The input data to be processed by the neuron. Returns: np.ndarray: The output of the quantum circuit, representing the neuron's activation. """ return np.array(self.quantum_circuit(inputs, self.weights)) # Execute the circuit class Neuron: """ A neuron in the Nebula system combining classical and quantum properties. Each neuron has a 3D position within the NebulaSpace, a QuantumNeuron for processing information, and connections to other neurons. """ def __init__(self, position: np.ndarray): """ Initializes the Neuron. Args: position (np.ndarray): The 3D coordinates of the neuron in the NebulaSpace. """ self.position = position self.quantum_neuron = QuantumNeuron() # Assign a QuantumNeuron self.luminosity = np.random.rand() # Initialize luminosity randomly self.connections = [] # List to store connections with other neurons def activate(self, inputs: np.ndarray): """ Activates the neuron with the given input. Args: inputs (np.ndarray): The input data to be processed by the neuron. Returns: np.ndarray: The output of the neuron's QuantumNeuron, representing its activation. """ return self.quantum_neuron.forward(inputs) # Forward pass through the QuantumNeuron def process(self, inputs: np.ndarray) -> np.ndarray: """ Processes input data through the neuron's QuantumNeuron. Args: inputs (np.ndarray): The input data to be processed. Returns: np.ndarray: The processed output from the QuantumNeuron. """ return self.activate(inputs) # Activation is synonymous with processing here class NebulaSector: """ A sector within the Nebula system containing multiple neurons. Neurons within a sector interact with each other based on their proximity and luminosity. The sector manages these interactions and provides a way to organize neurons within the NebulaSpace. """ def __init__(self, n_neurons: int = NEURONS_PER_SECTOR): """ Initializes the NebulaSector. Args: n_neurons (int): The number of neurons to create within this sector. Defaults to the global NEURONS_PER_SECTOR value. """ self.id = str(uuid.uuid4()) # Unique ID for the sector self.neurons = [Neuron(np.random.randn(3)) for _ in range(n_neurons)] # Create neurons self.positions = cp.array([n.position for n in self.neurons], dtype=cp.float32) # Store positions on GPU self.luminosities = cp.array([n.luminosity for n in self.neurons], dtype=cp.float32) # Store luminosities on GPU self.interactions = cp.zeros(n_neurons, dtype=cp.float32) # Initialize interaction matrix self.last_modified = time.time() # Timestamp for tracking modifications def update_interactions(self): """ Update the interactions between neurons within this sector. """ n = len(self.neurons) for i in range(n): for j in range(n): if i != j: # Avoid self-interaction dx = self.positions[i, 0] - self.positions[j, 0] dy = self.positions[i, 1] - self.positions[j, 1] dz = self.positions[i, 2] - self.positions[j, 2] dist_sq = dx**2 + dy**2 + dz**2 + 1e-6 self.interactions[i] += self.luminosities[j] / dist_sq self.last_modified = time.time() def get_state(self) -> np.ndarray: """ Retrieves the current state of the sector. Returns: np.ndarray: A flattened array representing the sector's state, including neuron positions, luminosities, and interactions. """ return np.concatenate(( cp.asnumpy(self.positions).flatten(), # Flatten and move data from GPU to CPU cp.asnumpy(self.luminosities), cp.asnumpy(self.interactions) )) def set_state(self, state: np.ndarray): """ Sets the state of the sector. Args: state (np.ndarray): A flattened array representing the new state of the sector. """ n_neurons = len(self.neurons) self.positions = cp.array(state[:3 * n_neurons].reshape((n_neurons, 3))) # Update positions self.luminosities = cp.array(state[3 * n_neurons:4 * n_neurons]) # Update luminosities self.interactions = cp.array(state[4 * n_neurons:]) # Update interactions self.last_modified = time.time() # Update modification timestamp class NebulaSpace: """ The 3D space where Nebula sectors exist and interact. This class manages the creation and tracking of sectors, providing a spatial organization for the Nebula system. """ def __init__(self, sector_size: int = SECTOR_SIZE): """ Initializes the NebulaSpace. Args: sector_size (int): The size of each sector along each dimension. Defaults to the global SECTOR_SIZE value. """ self.sectors = {} # Dictionary to store sectors by their unique ID self.sector_map = {} # Map sector coordinates to sector IDs self.sector_size = sector_size def get_or_create_sector(self, position: np.ndarray) -> NebulaSector: """ Retrieves a sector at a given position, creating it if it doesn't exist. Args: position (np.ndarray): The 3D coordinates to locate the sector. Returns: NebulaSector: The sector at the specified position. """ sector_coords = tuple(int(p // self.sector_size) for p in position) # Calculate sector coordinates if sector_coords not in self.sector_map: new_sector = NebulaSector() # Create a new sector if needed self.sectors[new_sector.id] = new_sector self.sector_map[sector_coords] = new_sector.id return self.sectors[self.sector_map[sector_coords]] def update_all_sectors(self): """ Triggers the update of interactions in all sectors within the NebulaSpace. """ for sector in self.sectors.values(): sector.update_interactions() class NebulaSystem: def __init__(self): self.space = NebulaSpace() self.hologram_codec = HologramCodec() self.cache = {} self.memory = [] def process_input(self, input_data: str) -> np.ndarray: """ Process input data and generate embeddings (temporarily disabled NLP). Args: input_data (str): The input data to be processed. Returns: np.ndarray: Randomly generated embeddings. """ # Placeholder for embedding generation (NLP disabled) embeddings = np.random.randn(DIM) return embeddings def activate_neurons(self, embeddings: np.ndarray): for sector in self.space.sectors.values(): for i, neuron in enumerate(sector.neurons): neuron.activate(embeddings) # Activate with the generated embedding sector.update_interactions() def process_data(self, data: Dict[str, List[Dict[str, str]]]): embeddings = [] for category, qa_pairs in data.items(): for pair in qa_pairs: question, answer = pair['question'], pair['answer'] embeddings.append(np.random.randn(DIM)) self.memory.append((question, answer)) if not embeddings: logger.warning("No data to process. No neurons will be created.") return self.activate_neurons(np.array(embeddings)) # Ensure at least one sector is created if not self.space.sectors: self.space.get_or_create_sector(np.array([0, 0, 0])) def save_state(self) -> Dict[str, torch.Tensor]: state_data = {} for sector_id, sector in self.space.sectors.items(): sector_state = sector.get_state() # Convierte el UUID a entero sector_index = uuid.UUID(sector_id).int encoded_state = self.hologram_codec.encode(sector_state, sector_index) state_data[sector_id] = encoded_state return state_data def load_state(self, state_data: Dict[str, torch.Tensor]): for sector_id, encoded_state in state_data.items(): # Convierte el UUID a entero sector_index = uuid.UUID(sector_id).int sector_state = self.hologram_codec.decode(encoded_state, sector_index) if sector_id not in self.space.sectors: self.space.sectors[sector_id] = NebulaSector() self.space.sectors[sector_id].set_state(sector_state) def query_nearest_neurons(self, query_embedding: np.ndarray, k: int = 9) -> List[Neuron]: """ Finds the k-nearest neurons to a given query embedding. Args: query_embedding (np.ndarray): The query embedding to compare against neurons. k (int): The number of nearest neurons to return. Defaults to 9. Returns: List[Neuron]: A list of the k-nearest neurons. """ logger.info(f"Querying nearest neurons with embedding shape: {query_embedding.shape}") query_embedding = query_embedding.flatten() all_neurons = [] all_embeddings = [] for sector in self.space.sectors.values(): all_neurons.extend(sector.neurons) all_embeddings.extend([n.quantum_neuron.weights.flatten() for n in sector.neurons]) if not all_embeddings: logger.error("No neurons found in the system.") return [] neuron_embeddings = np.array(all_embeddings) logger.info(f"Neuron embeddings shape: {neuron_embeddings.shape}") query_embedding = query_embedding[:neuron_embeddings.shape[1]].reshape(1, -1) neuron_embeddings = neuron_embeddings.reshape(neuron_embeddings.shape[0], -1) similarities = cosine_similarity(query_embedding, neuron_embeddings) nearest_indices = np.argsort(similarities[0])[-k:][::-1] return [all_neurons[i] for i in nearest_indices] def answer_question(self, question: Union[str, np.ndarray]) -> str: """ Answer a given question based on the current state of the Nebula system. Args: question (Union[str, np.ndarray]): The question to be answered, either as a string or a pre-computed embedding. Returns: str: The answer to the question, either "Yes" or "No". """ try: if isinstance(question, str): # Genera un embedding de 9 dimensiones question_embedding = np.random.randn(9) logger.info(f"Creating embedding for question: {question}") question_embedding = np.random.randn(DIM) elif isinstance(question, np.ndarray): question_embedding = question else: raise ValueError("Question must be either a string or a numpy array") nearest_neurons = self.query_nearest_neurons(question_embedding) if not nearest_neurons: logger.warning("No neurons found to answer the question.") return "Unable to answer due to lack of initialized neurons." activations = [] for neuron in nearest_neurons: neuron_activation = neuron.process(question_embedding.flatten()) activations.append(np.mean(neuron_activation)) logger.info(f"Neuron activation: {neuron_activation}, Mean activation: {np.mean(neuron_activation)}") if not activations: logger.warning("No activations received from neurons.") return "Unable to determine an answer due to lack of neuron activations." mean_activation = np.mean(activations) logger.info(f"Mean activation across neurons: {mean_activation}") threshold = 0.5 # You can adjust this threshold answer = "Yes" if mean_activation > threshold else "No" return answer except Exception as e: logger.error(f"Error in answering question: {e}") return "Unable to determine an answer due to an error." def learn(self, question: str, correct_answer: str): current_answer = self.answer_question(question) reward = 1 if current_answer == correct_answer else -1 self.memory.append((question, correct_answer, reward)) def review_memory(self): for question, correct_answer, reward in self.memory: if reward == -1: self.learn(question, correct_answer) def save_hologram_to_file(self, filename: str = "nebula_hologram.npz"): state_data = self.save_state() # Convert PyTorch tensors to NumPy arrays before saving for sector_id, encoded_state in state_data.items(): state_data[sector_id] = encoded_state.cpu().numpy() np.savez_compressed(filename, **state_data) logger.info(f"Hologram saved to {filename}") def load_hologram_from_file(self, filename: str = "nebula_hologram.npz"): state_data = dict(np.load(filename)) # Convert NumPy arrays back to PyTorch tensors and move to GPU for sector_id, encoded_state in state_data.items(): state_data[sector_id] = torch.as_tensor(encoded_state, dtype=torch.complex64).to('cuda') self.load_state(state_data) logger.info(f"Hologram loaded from {filename}") def learn(self, question: str, correct_answer: str): """ Adjusts the system's internal representation based on feedback. Args: question (str): The question that was asked. correct_answer (str): The correct answer to the question. """ # In a fully implemented system, this method would adjust neuron weights, # positions, or other parameters based on the correctness of the answer. # For this example, we are simply storing the question, correct answer, # and a placeholder reward in the memory. current_answer = self.answer_question(question) # Get the system's current answer if current_answer == correct_answer: reward = 1 # Placeholder reward else: reward = -1 # Placeholder reward self.memory.append((question, correct_answer, reward)) # Store learning data def review_memory(self): """ Reviews past question-answer pairs and reinforces learning. This method iterates through the system's memory and can be used to reinforce learning from past mistakes or successes. """ # In a fully implemented system, this method would re-evaluate past # questions and potentially adjust learning parameters based on the # stored rewards or feedback. for question, correct_answer, reward in self.memory: if reward == -1: # If the system answered incorrectly previously self.learn(question, correct_answer) # Attempt to learn from the mistake @ray.remote(num_gpus=1) class NebulaTrainer: def __init__(self): self.nebula = NebulaSystem() self.reward_system = self.create_reward_system() def create_reward_system(self): creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", list, fitness=creator.FitnessMax) toolbox = base.Toolbox() total_weights = sum(neuron.quantum_neuron.weights.size for sector in self.nebula.space.sectors.values() for neuron in sector.neurons) logger.info(f"Total weights for individuals: {total_weights}") toolbox.register("attribute", np.random.rand) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attribute, n=total_weights) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", self.evaluate) toolbox.register("mate", tools.cxBlend, alpha=0.5) toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.1, indpb=0.1) toolbox.register("select", tools.selTournament, tournsize=3) return toolbox @timeout(60) # 60 second timeout for evaluation def evaluate(self, individual): logger.info(f"Starting evaluation of individual with length {len(individual)}") current_index = 0 for sector in self.nebula.space.sectors.values(): for neuron in sector.neurons: weight_size = neuron.quantum_neuron.weights.size if current_index + weight_size <= len(individual): neuron.quantum_neuron.weights = np.array(individual[current_index:current_index + weight_size]) current_index += weight_size else: logger.error(f"Not enough weights in individual. Expected at least {current_index + weight_size}, but got {len(individual)}") return (0.0,) correct_answers = 0 total_questions = 0 for category, questions in solar_system_qa.items(): for qa in questions: answer = self.nebula.answer_question(qa['question']) if answer == qa['answer']: correct_answers += 1 total_questions += 1 if total_questions == 0: return (0.0,) fitness = correct_answers / total_questions logger.info(f"Individual evaluation complete. Fitness: {fitness}") return (fitness,) def train(self, data: Dict[str, List[Dict[str, str]]], generations: int = EPOCH, timeout: int = 900): logger.info("Starting training process") self.nebula.process_data(data) toolbox = self.reward_system total_weights = sum(neuron.quantum_neuron.weights.size for sector in self.nebula.space.sectors.values() for neuron in sector.neurons) toolbox.unregister("individual") toolbox.unregister("population") toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attribute, n=total_weights) toolbox.register("population", tools.initRepeat, list, toolbox.individual) logger.info("Creating initial population") population = toolbox.population(n=25) # Further reduced population size def timeout_handler(signum, frame): raise TimeoutError("Training took too long") signal.signal(signal.SIGALRM, timeout_handler) signal.alarm(timeout) try: logger.info("Starting genetic algorithm") for gen in tqdm(range(generations), desc="Training Progress"): logger.info(f"Generation {gen} started") offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.2) fits = [] for ind in offspring: try: fit = toolbox.evaluate(ind) fits.append(fit) except TimeoutError: logger.warning("Evaluation timed out, assigning zero fitness") fits.append((0.0,)) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = toolbox.select(offspring, k=len(population)) best_fit = tools.selBest(population, k=1)[0].fitness.values[0] logger.info(f"Generation {gen}: Best fitness = {best_fit}") if best_fit >= 0.95: # Early stopping condition logger.info(f"Reached 95% accuracy. Stopping early at generation {gen}") break except TimeoutError: logger.warning("Training timed out") finally: signal.alarm(0) best_individual = tools.selBest(population, k=1)[0] logger.info(f"Training completed. Best fitness: {best_individual.fitness.values[0]}") return best_individual def save_to_ply(filename: str, points: np.ndarray, colors: Optional[np.ndarray] = None): """ Saves point cloud data to a PLY file for 3D visualization. Args: filename (str): The name of the PLY file to save the data to. points (np.ndarray): A NumPy array containing the 3D coordinates of the points. colors (Optional[np.ndarray]): A NumPy array containing the RGB color values for each point. """ if points.size == 0: logger.warning(f"No points to save. PLY file {filename} not created.") return cloud = trimesh.points.PointCloud(points, colors) # Create a point cloud object cloud.export(filename) # Export the point cloud to a PLY file logger.info(f"Point cloud saved to {filename}") def visualize_nebula(nebula: NebulaSystem): """ Visualize the Nebula system using matplotlib. Args: nebula (NebulaSystem): The Nebula system to visualize. """ fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(111, projection='3d') # Generate sample data for visualization num_points = 10000 points = np.random.randn(num_points, 3) luminosities = np.random.rand(num_points) # Normalize luminosities for coloring colors = plt.cm.viridis(luminosities / luminosities.max()) ax.scatter(points[:, 0], points[:, 1], points[:, 2], c=colors, s=20, alpha=0.6) ax.set_xlabel('X') ax.set_ylabel('Y') ax.set_zlabel('Z') ax.set_title('Nebula System Visualization (Estimated)') plt.show() def main(): logger.info("Starting Nebula system...") try: logger.info("Initializing Ray...") ray.init(num_gpus=1) logger.info("Ray initialized successfully.") logger.info("Creating NebulaTrainer...") trainer = NebulaTrainer.remote() logger.info("NebulaTrainer created successfully.") logger.info("Starting training...") start_time = time.time() result = ray.get(trainer.train.remote(solar_system_qa, generations=EPOCH)) end_time = time.time() logger.info(f"Training complete in {end_time - start_time:.2f} seconds.") logger.info("Creating local NebulaSystem...") local_nebula = NebulaSystem() logger.info("Local NebulaSystem created successfully.") # Process the data to initialize neurons local_nebula.process_data(solar_system_qa) while True: save_choice = input("Do you want to save the hologram to memory? (Yes/No): ").strip().lower() if save_choice in ["yes", "y", "no", "n"]: break print("Invalid input. Please enter Yes or No.") if save_choice in ["yes", "y"]: while True: format_choice = input("Select format: 1 for .NPZ, 2 for .PLY (3D): ").strip() if format_choice in ["1", "2"]: break print("Invalid input. Please enter 1 or 2.") if format_choice == "1": local_nebula.save_hologram_to_file("nebula_hologram.npz") elif format_choice == "2": num_points = 100000 points = np.random.randn(num_points, 3) luminosities = np.random.rand(num_points) colors = (luminosities * 255).astype(np.uint8) colors = np.column_stack((colors, colors, colors)) save_to_ply("nebula_hologram_3d.ply", points, colors) logger.info("Saved PLY file for 3D visualization") else: logger.info("Hologram not saved.") # Visualize the Nebula system visualize_nebula(local_nebula) while True: print("\nChoose a category:") for i, category in enumerate(solar_system_qa): print(f"{i+1}. {category}") category_choice = input("Enter category number (or type 'exit' to quit): ").strip().lower() if category_choice == 'exit': break try: category_index = int(category_choice) - 1 if category_index < 0 or category_index >= len(solar_system_qa): raise ValueError("Category index out of range") chosen_category = list(solar_system_qa.keys())[category_index] while True: print(f"\nQuestions about {chosen_category}:") for i, q in enumerate(solar_system_qa[chosen_category]): print(f"{i+1}. {q['question']}") question_choice = input("Enter question number (or type 'back' to choose another category): ").strip().lower() if question_choice == 'back': break try: question_index = int(question_choice) - 1 if question_index < 0 or question_index >= len(solar_system_qa[chosen_category]): print("Invalid question number. Please try again.") continue selected_question = solar_system_qa[chosen_category][question_index] nebula_answer = local_nebula.answer_question(selected_question['question']) print(f"\nNebula's answer: {nebula_answer}") print(f"Correct answer: {selected_question['answer']}") if nebula_answer == selected_question['answer']: print("Nebula's answer is correct!") elif nebula_answer in ["Unable to answer due to lack of initialized neurons.", "Unable to determine an answer due to lack of neuron activations.", "Unable to determine an answer due to an error."]: print("Nebula is unable to answer this question.") else: print("Nebula's answer is incorrect.") local_nebula.learn(selected_question['question'], selected_question['answer']) global TRAIN_EPOCH TRAIN_EPOCH += 1 if TRAIN_EPOCH % 10 == 0: local_nebula.review_memory() except ValueError: print("Invalid input. Please enter a number or 'back'.") except Exception as e: logger.error(f"An unexpected error occurred: {e}") print("An unexpected error occurred. Please try again.") except ValueError as e: logger.error(f"Invalid category number: {e}. Please try again.") except Exception as e: logger.error(f"An error occurred while processing the category: {e}. Please try again.") visualize_nebula(local_nebula) except Exception as e: logger.error(f"An error occurred in the main function: {e}") finally: logger.info("Shutting down Ray...") ray.shutdown() logger.info("Ray shut down successfully.") logger.info("Nebula system execution complete.") if __name__ == "__main__": main()