# Cognitive Network

A PyTorch implementation of a differentiable cognitive network with dynamic structure learning, memory consolidation, and neurotransmitter-modulated plasticity.

## Features

- 🧠 Dynamic network structure that evolves based on performance
- 💭 Differentiable memory system with importance-based consolidation
- 🔄 Hebbian plasticity with neurotransmitter modulation
- 🎯 Self-organizing architecture with adaptive connections
- 💡 Emotional context integration for learning modulation

## Installation

```bash
pip install cognitive-net
```

Or install from source:

```bash
git clone https://github.com/yourusername/cognitive-net.git
cd cognitive-net
pip install -e .
```

## Quick Start

```python
import torch
from cognitive_net import DynamicCognitiveNet

# Initialize network
net = DynamicCognitiveNet(input_size=10, output_size=2)

# Sample data
x = torch.randn(10)
y = torch.randn(2)

# Training step
loss = net.train_step(x, y)
print(f"Training loss: {loss:.4f}")
```

## Components

### CognitiveMemory

The memory system implements:
- Importance-based memory storage
- Adaptive consolidation
- Attention-based retrieval

### CognitiveNode

Individual nodes feature:
- Dynamic weight plasticity
- Neurotransmitter modulation
- Local memory systems

### DynamicCognitiveNet

The network provides:
- Self-organizing structure
- Performance-based connection updates
- Emotional context integration
- Adaptive learning mechanisms

## Usage Examples

### Basic Training Loop

```python
# Initialize network
net = DynamicCognitiveNet(input_size=5, output_size=1)

# Training data
X = torch.randn(100, 5)
y = torch.randn(100, 1)

# Training loop
for epoch in range(10):
    total_loss = 0
    for i in range(len(X)):
        loss = net.train_step(X[i], y[i])
        total_loss += loss
    print(f"Epoch {epoch+1}, Average Loss: {total_loss/len(X):.4f}")
```

### Memory Usage

```python
from cognitive_net import CognitiveMemory

# Initialize memory system
memory = CognitiveMemory(context_size=64)

# Store new memory
context = torch.randn(64)
memory.add_memory(context, activation=0.8)

# Retrieve similar contexts
query = torch.randn(64)
retrieved = memory.retrieve(query)
```

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Citation

If you use this code in your research, please cite:

```bibtex
@software{cognitive_net2024,
  title = {Cognitive Network: Dynamic Structure Learning with Memory},
  author = {Your Name},
  year = {2024},
  publisher = {GitHub},
  url = {https://github.com/yourusername/cognitive-net}
}
```

## Acknowledgments

- PyTorch team for the excellent deep learning framework
- Research community for inspiration and feedback