Types of AI: From Narrow AI to Superintelligence

graph TD
    A[Artificial Intelligence] --> B[By Capability]
    A --> C[By Functionality]
    B --> D[Narrow AI<br/>Weak AI]
    B --> E[General AI<br/>Strong AI]
    B --> F[Super AI<br/>ASI]
    C --> G[Reactive Machines]
    C --> H[Limited Memory]
    C --> I[Theory of Mind]
    C --> J[Self-Aware]

# Example: Image Classification AI
import numpy as np
 
class ImageClassifierAI:
    """A narrow AI for classifying images"""
    def __init__(self):
        self.categories = ['cat', 'dog', 'bird', 'car', 'plane']
        
    def classify_image(self, image_features):
        # Simulated classification logic
        # In reality, this would use a trained neural network
        confidence_scores = np.random.rand(len(self.categories))
        best_match_idx = np.argmax(confidence_scores)
        
        return {
            'category': self.categories[best_match_idx],
            'confidence': confidence_scores[best_match_idx]
        }
 
# Usage
classifier = ImageClassifierAI()
result = classifier.classify_image("image_data_here")
print(f"Classification: {result['category']} (Confidence: {result['confidence']:.2%})")

# Conceptual representation of AGI capabilities
class TheoreticalAGI:
    """Hypothetical AGI system"""
    def __init__(self):
        self.knowledge_base = {}
        self.reasoning_engine = None
        self.learning_system = None
        
    def learn_new_domain(self, domain, data):
        """Learn any new domain from data"""
        # Would understand context and relationships
        # Transfer knowledge from other domains
        pass
        
    def solve_problem(self, problem, context=None):
        """Solve any problem using general reasoning"""
        # Would apply cross-domain knowledge
        # Generate creative solutions
        # Understand nuance and context
        pass
        
    def communicate(self, message, language='any'):
        """Natural communication in any form"""
        # Would understand intent, emotion, context
        # Generate appropriate responses
        pass

graph LR
    A[Human Intelligence] -->|Current AI| B[Narrow AI]
    A -->|Research Goal| C[AGI]
    C -->|Theoretical Future| D[ASI]
    D -->|Recursive Improvement| E[Exponential Growth]

# Example: Chess AI (Reactive Machine)
class ChessAI:
    def __init__(self):
        self.evaluation_function = self.piece_value_evaluation
        
    def piece_value_evaluation(self, board_state):
        """Evaluate board position based on piece values"""
        piece_values = {
            'pawn': 1, 'knight': 3, 'bishop': 3,
            'rook': 5, 'queen': 9, 'king': 1000
        }
        # Evaluate current position only
        return sum(piece_values.get(piece, 0) for piece in board_state)
    
    def make_move(self, board_state):
        """Make decision based only on current board state"""
        # No memory of previous games or moves
        possible_moves = self.get_legal_moves(board_state)
        best_move = max(possible_moves, 
                       key=lambda m: self.evaluation_function(m))
        return best_move

# Example: Self-Driving Car AI (Limited Memory)
class SelfDrivingAI:
    def __init__(self, memory_duration=30):  # seconds
        self.memory_duration = memory_duration
        self.short_term_memory = []
        
    def observe_environment(self, sensor_data):
        """Store recent observations"""
        current_time = time.time()
        self.short_term_memory.append({
            'time': current_time,
            'data': sensor_data
        })
        # Remove old memories
        self.short_term_memory = [
            m for m in self.short_term_memory 
            if current_time - m['time'] < self.memory_duration
        ]
        
    def make_driving_decision(self):
        """Use recent observations to make decisions"""
        # Analyze patterns in recent memory
        recent_obstacles = self.analyze_recent_obstacles()
        traffic_patterns = self.analyze_traffic_flow()
        
        return self.plan_route(recent_obstacles, traffic_patterns)

# Conceptual Theory of Mind AI
class TheoryOfMindAI:
    def __init__(self):
        self.entity_models = {}
        
    def model_entity(self, entity_id, observations):
        """Build a model of another entity's mental state"""
        self.entity_models[entity_id] = {
            'beliefs': self.infer_beliefs(observations),
            'desires': self.infer_desires(observations),
            'emotions': self.infer_emotions(observations),
            'intentions': self.infer_intentions(observations)
        }
        
    def predict_behavior(self, entity_id, situation):
        """Predict how an entity will behave based on their mental model"""
        if entity_id in self.entity_models:
            model = self.entity_models[entity_id]
            # Consider beliefs, desires, emotions to predict behavior
            return self.behavior_prediction_engine(model, situation)

timeline
    title AI Development Timeline
    
    1950s : AI Concept Born
    1997  : Deep Blue beats Chess Champion
    2011  : Watson wins Jeopardy
    2016  : AlphaGo beats Go Champion
    2022  : ChatGPT Launch
    2025  : Current State - Advanced Narrow AI
    2030? : Potential AGI Breakthroughs
    2045? : Singularity Predictions
    Future : ASI Speculation