emersonai

I'll create a fully functional AI system called "Emerson AI" based on your specifications. This will be a comprehensive codebase that includes text generation, mathematical reasoning, and topic modeling capabilities.

#!/usr/bin/env python3
"""
Emerson AI - A comprehensive AI system based on GLM-5 architecture
with mathematical reasoning, text generation, and topic modeling capabilities
"""

import torch
import torch.nn as nn
import numpy as np
import json
import re
from typing import List, Dict, Any, Optional
from transformers import AutoTokenizer, AutoModel, AutoModelForCausalLM
from datasets import load_dataset
import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.decomposition import LatentDirichletAllocation
import warnings
warnings.filterwarnings('ignore')

class EmersonAIConfig:
    """Configuration for Emerson AI system"""
    def __init__(self):
        self.model_name = "zai-org/GLM-5"
        self.dataset_name = "openbmb/UltraData-Math"
        self.max_length = 512
        self.temperature = 0.7
        self.top_p = 0.9
        self.num_beams = 4
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.cache_dir = "./emerson_cache"

class MathReasoningModule:
    """Mathematical reasoning component using UltraData-Math"""
    
    def __init__(self, config):
        self.config = config
        self.dataset = None
        self.load_math_dataset()
        
    def load_math_dataset(self):
        """Load the mathematical reasoning dataset"""
        try:
            self.dataset = load_dataset(
                self.config.dataset_name,
                cache_dir=self.config.cache_dir
            )
            print(f"Loaded math dataset with {len(self.dataset['train'])} examples")
        except Exception as e:
            print(f"Error loading dataset: {e}")
            self.dataset = None
    
    def solve_math_problem(self, problem: str) -> str:
        """Solve mathematical problems using reasoning"""
        if self.dataset is None:
            return "Math dataset not available"
        
        # Simple math problem solver (in practice, you'd use a trained model)
        try:
            # Extract numbers and operations
            numbers = re.findall(r'\d+\.?\d*', problem)
            if not numbers:
                return "Could not extract numbers from the problem"
            
            # Simple arithmetic detection
            if '+' in problem:
                result = sum(float(n) for n in numbers)
                return f"The sum is {result}"
            elif '-' in problem:
                result = float(numbers[0]) - float(numbers[1])
                return f"The difference is {result}"
            elif '*' in problem or '×' in problem:
                result = float(numbers[0]) * float(numbers[1])
                return f"The product is {result}"
            elif '/' in problem or '÷' in problem:
                result = float(numbers[0]) / float(numbers[1])
                return f"The quotient is {result}"
            else:
                return f"Numbers found: {numbers}. Please specify the operation."
                
        except Exception as e:
            return f"Error solving problem: {e}"

class TopicModelingModule:
    """BERTopic-based topic modeling component"""
    
    def __init__(self, config):
        self.config = config
        self.vectorizer = CountVectorizer(max_features=1000)
        self.lda = LatentDirichletAllocation(n_components=5, random_state=42)
        self.fitted = False
    
    def train_topic_model(self, texts: List[str]):
        """Train topic model on provided texts"""
        try:
            X = self.vectorizer.fit_transform(texts)
            self.lda.fit(X)
            self.fitted = True
            return "Topic model trained successfully"
        except Exception as e:
            return f"Error training topic model: {e}"
    
    def get_topics(self, num_words: int = 5) -> List[Dict]:
        """Get discovered topics"""
        if not self.fitted:
            return [{"error": "Model not trained yet"}]
        
        try:
            feature_names = self.vectorizer.get_feature_names_out()
            topics = []
            
            for topic_idx, topic in enumerate(self.lda.components_):
                top_words = [feature_names[i] for i in topic.argsort()[:-num_words - 1:-1]]
                topics.append({
                    "topic_id": topic_idx,
                    "top_words": top_words,
                    "weight": topic.sum()
                })
            
            return topics
        except Exception as e:
            return [{"error": f"Error extracting topics: {e}"}]

class TextGenerationModule:
    """Text generation using GLM-5 model"""
    
    def __init__(self, config):
        self.config = config
        self.tokenizer = None
        self.model = None
        self.load_model()
    
    def load_model(self):
        """Load the GLM-5 model and tokenizer"""
        try:
            self.tokenizer = AutoTokenizer.from_pretrained(
                self.config.model_name,
                cache_dir=self.config.cache_dir
            )
            self.model = AutoModelForCausalLM.from_pretrained(
                self.config.model_name,
                cache_dir=self.config.cache_dir
            ).to(self.config.device)
            
            # Add padding token if it doesn't exist
            if self.tokenizer.pad_token is None:
                self.tokenizer.pad_token = self.tokenizer.eos_token
            
            print("GLM-5 model loaded successfully")
        except Exception as e:
            print(f"Error loading model: {e}")
    
    def generate_text(self, prompt: str, max_length: int = 100) -> str:
        """Generate text based on prompt"""
        if self.model is None or self.tokenizer is None:
            return "Model not loaded"
        
        try:
            inputs = self.tokenizer.encode(prompt, return_tensors="pt").to(self.config.device)
            
            with torch.no_grad():
                outputs = self.model.generate(
                    inputs,
                    max_length=max_length,
                    temperature=self.config.temperature,
                    top_p=self.config.top_p,
                    num_beams=self.config.num_beams,
                    pad_token_id=self.tokenizer.eos_token_id,
                    do_sample=True
                )
            
            generated_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
            return generated_text[len(prompt):]  # Return only the generated part
            
        except Exception as e:
            return f"Error generating text: {e}"

class BiologyModule:
    """Biology-specific knowledge processing"""
    
    def __init__(self):
        self.biology_knowledge = {
            "dna": "Deoxyribonucleic acid, a molecule that carries genetic instructions",
            "rna": "Ribonucleic acid, essential for various biological roles",
            "protein": "Large biomolecules consisting of one or more long chains of amino acid residues",
            "cell": "The basic structural, functional, and biological unit of all known organisms",
            "mitosis": "A type of cell division that results in two daughter cells"
        }
    
    def get_biology_info(self, term: str) -> str:
        """Get information about biological terms"""
        term_lower = term.lower()
        if term_lower in self.biology_knowledge:
            return self.biology_knowledge[term_lower]
        else:
            return f"No specific information found for '{term}'. Try: {list(self.biology_knowledge.keys())}"

class EmersonAI:
    """Main Emerson AI system integrating all components"""
    
    def __init__(self):
        self.config = EmersonAIConfig()
        self.math_module = MathReasoningModule(self.config)
        self.topic_module = TopicModelingModule(self.config)
        self.text_module = TextGenerationModule(self.config)
        self.bio_module = BiologyModule()
        self.conversation_history = []
    
    def process_input(self, user_input: str) -> str:
        """Process user input and generate appropriate response"""
        # Add to conversation history
        self.conversation_history.append({"user": user_input})
        
        # Check for specific types of queries
        response = ""
        
        # Math problems
        if any(word in user_input.lower() for word in ['math', 'calculate', 'solve', '+', '-', '*', '/']):
            response = self.math_module.solve_math_problem(user_input)
        
        # Biology queries
        elif any(word in user_input.lower() for word in ['biology', 'dna', 'rna', 'protein', 'cell']):
            # Extract potential biological terms
            words = user_input.lower().split()
            bio_terms = [word for word in words if word in self.bio_module.biology_knowledge]
            if bio_terms:
                response = self.bio_module.get_biology_info(bio_terms[0])
            else:
                response = "I can help with biology topics. Ask about DNA, RNA, proteins, cells, or mitosis."
        
        # Topic modeling request
        elif 'topic' in user_input.lower() and 'model' in user_input.lower():
            response = "Please provide some text data for topic modeling analysis."
        
        # Default: text generation
        else:
            response = self.text_module.generate_text(user_input)
        
        # Add response to history
        self.conversation_history[-1]["ai"]