AI research lab NeoCognition lands $40M seed to build agents that learn like humans

Introduction

In this tutorial, you'll learn how to create a simple AI agent that can learn and adapt to new tasks - similar to what the startup NeoCognition is working on. This hands-on project will teach you the fundamental concepts of machine learning agents that can become experts in different domains. By the end, you'll understand how to build an agent that improves its performance over time through experience.

Prerequisites

Before starting this tutorial, you'll need:

• Basic understanding of Python programming
• Python 3.7 or higher installed on your computer
• Internet connection to install packages
• Text editor or IDE (like VS Code or PyCharm)

Step-by-Step Instructions

Step 1: Set Up Your Python Environment

Install Required Packages

First, we need to install the necessary Python libraries for our AI agent. Open your terminal or command prompt and run:

pip install numpy scikit-learn

This installs NumPy for numerical operations and scikit-learn for machine learning algorithms. These are essential tools for building our learning agent.

Step 2: Create Your First AI Agent Class

Initialize the Agent Structure

Let's start by creating a basic AI agent class that can learn from experience:

import numpy as np
from sklearn.linear_model import LinearRegression


class LearningAgent:
    def __init__(self):
        # Initialize our agent with a simple learning model
        self.model = LinearRegression()
        self.experience = []
        
    def learn(self, inputs, outputs):
        # Store experience for later learning
        self.experience.append((inputs, outputs))
        
    def predict(self, inputs):
        # Make predictions based on learned patterns
        return self.model.predict([inputs])[0]
        
    def train(self):
        # Train the model with all stored experience
        if len(self.experience) > 0:
            X = np.array([x[0] for x in self.experience])
            y = np.array([x[1] for x in self.experience])
            self.model.fit(X, y)

This code creates a basic agent that can store experiences and learn patterns from them. The LinearRegression model is our learning tool that helps the agent make better predictions over time.

Step 3: Create Sample Learning Data

Generate Training Examples

Now we need to create some sample data for our agent to learn from. This simulates the process of an agent learning in different domains:

# Create sample learning data
agent = LearningAgent()

# Simulate learning in a simple domain (predicting house prices)
# Features: [size, bedrooms, age]
training_data = [
    ([1000, 2, 10], 200000),  # 1000 sq ft, 2 bedrooms, 10 years old = $200k
    ([1500, 3, 5], 300000),   # 1500 sq ft, 3 bedrooms, 5 years old = $300k
    ([2000, 4, 2], 400000),   # 2000 sq ft, 4 bedrooms, 2 years old = $400k
    ([800, 1, 15], 150000),   # 800 sq ft, 1 bedroom, 15 years old = $150k
]

# Train the agent with sample data
for inputs, outputs in training_data:
    agent.learn(inputs, outputs)

# Train the learning model
agent.train()

Here we're simulating how an agent would learn in a real-world domain. Each data point represents an example of what the agent should learn to predict.

Step 4: Test Your Agent's Learning

Verify Agent Performance

Let's test if our agent can make accurate predictions after learning:

# Test the agent with new data
new_house = [1200, 2, 8]  # 1200 sq ft, 2 bedrooms, 8 years old
prediction = agent.predict(new_house)

print(f"Predicted house price for {new_house}: ${prediction:.0f}")

# Test with another example
new_house2 = [1800, 3, 3]
prediction2 = agent.predict(new_house2)

print(f"Predicted house price for {new_house2}: ${prediction2:.0f}")

This demonstrates how our agent applies what it learned to new situations. The agent uses its training to make reasonable predictions about unseen data.

Step 5: Simulate Domain Transfer

Adding New Learning Capabilities

Let's make our agent even more advanced by adding the ability to learn in different domains:

class AdvancedLearningAgent(LearningAgent):
    def __init__(self):
        super().__init__()
        self.domains = {}
        
    def learn_in_domain(self, domain_name, inputs, outputs):
        # Learn in a specific domain
        if domain_name not in self.domains:
            self.domains[domain_name] = LinearRegression()
            
        # Store experience for this domain
        domain_experience = self.domains[domain_name]
        domain_experience.fit(np.array([inputs]), np.array([outputs]))
        
    def predict_in_domain(self, domain_name, inputs):
        # Predict in a specific domain
        if domain_name in self.domains:
            return self.domains[domain_name].predict([inputs])[0]
        else:
            return self.predict(inputs)  # Fall back to general model

This enhanced agent can learn and specialize in different domains - similar to how NeoCognition's agents become experts in various fields. The agent maintains separate learning models for different types of problems.

Step 6: Demonstrate Multi-Domain Learning

Test Cross-Domain Capabilities

Let's see our advanced agent in action with different domains:

# Create advanced agent
advanced_agent = AdvancedLearningAgent()

# Learn in different domains
# Domain 1: House prices
advanced_agent.learn_in_domain('housing', [1000, 2, 10], 200000)
advanced_agent.learn_in_domain('housing', [1500, 3, 5], 300000)

# Domain 2: Car prices
advanced_agent.learn_in_domain('cars', [20000, 5], 25000)
advanced_agent.learn_in_domain('cars', [30000, 3], 35000)

# Test predictions in different domains
house_prediction = advanced_agent.predict_in_domain('housing', [1200, 2, 8])
print(f"Housing prediction: ${house_prediction:.0f}")

car_prediction = advanced_agent.predict_in_domain('cars', [25000, 4])
print(f"Car prediction: ${car_prediction:.0f}")

This shows how our agent can specialize in different areas while maintaining general learning capabilities. Each domain has its own learning model that adapts to that specific type of problem.

Summary

In this tutorial, you've learned how to build a basic AI agent that can learn and adapt to new tasks - a fundamental concept behind what companies like NeoCognition are developing. You created:

• A simple learning agent that stores and applies experience
• A more advanced agent that can specialize in different domains
• Practical examples of how agents learn from examples and make predictions

This hands-on approach demonstrates how AI systems can become experts in various fields through experience and learning. While this is a simplified version, it shows the core principles that make modern AI agents powerful and adaptable tools.

The key takeaway is that learning agents don't need to be trained from scratch for every new task - they can build upon previous knowledge and adapt to new situations, much like human experts who can apply their knowledge across different domains.