Merge pull request #7 from Klus3kk/dev

Improved README, preparing readthedocs

Author: Klus3kk

.readthedocs.yaml

@@ -0,0 +1,24 @@
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version, and other tools you might need
+build:
+  os: ubuntu-24.04
+  tools:
+    python: "3.13"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+   configuration: docs/conf.py
+
+# Optionally, but recommended,
+# declare the Python requirements required to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+# python:
+#    install:
+#    - requirements: docs/requirements.txt
+        
+

CHANGELOG.md

@@ -1,73 +1,129 @@
-# FIT: Flexible and Interpretable Training Library
+# FIT
 
-[![Tests](https://github.com/Klus3kk/fit/actions/workflows/ci.yml/badge.svg)](https://github.com/Klus3kk/fit/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/Klus3kk/fit/branch/main/graph/badge.svg)](https://codecov.io/gh/Klus3kk/fit)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+A PyTorch-like machine learning library built from scratch with NumPy. Train neural networks with automatic differentiation, no dependencies beyond NumPy.
 
-FIT is a lightweight machine learning library built from scratch in Python with NumPy. It provides a PyTorch-like API with automatic differentiation and neural network components.
+[Documentation](https://fit.readthedocs.io/) | [Examples](examples/)
 
-## Features
+## Why FIT?
 
-- **Automatic Differentiation**: Build and train neural networks with automatic differentiation
-- **Neural Network Components**: Linear layers, activations (ReLU, Softmax), BatchNorm, Dropout
-- **Optimizers**: SGD, SGD with momentum, Adam
-- **Training Utilities**: Training loop, learning rate schedulers, gradient clipping
-- **Monitoring**: Training metrics tracking and visualization
-- **Model I/O**: Save and load your trained models
+- **Lightweight**: Only requires NumPy
+- **Educational**: Understand ML from first principles
+- **Familiar API**: PyTorch-like interface
+- **Production ready**: Type hints, logging, proper error handling
 
 ## Installation
 
-### Using pip (recommended)
-
 ```bash
 pip install git+https://github.com/Klus3kk/fit.git
 ```
 
-### From source
+## Example
 
-```bash
-git clone https://github.com/Klus3kk/fit.git
-cd fit
-pip install -e .
+Solve XOR problem:
+
+```python
+from fit.core.tensor import Tensor
+from fit.nn.modules.container import Sequential
+from fit.nn.modules.linear import Linear
+from fit.nn.modules.activation import ReLU
+from fit.loss.regression import MSELoss
+from fit.optim.adam import Adam
+
+# XOR dataset
+X = Tensor([[0, 0], [0, 1], [1, 0], [1, 1]])
+y = Tensor([[0], [1], [1], [0]])
+
+# Model
+model = Sequential(
+    Linear(2, 8),
+    ReLU(),
+    Linear(8, 1)
+)
+
+# Training
+loss_fn = MSELoss()
+optimizer = Adam(model.parameters(), lr=0.01)
+
+for epoch in range(1000):
+    pred = model(X)
+    loss = loss_fn(pred, y)
+    
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+    
+    if epoch % 200 == 0:
+        print(f"Loss: {loss.data:.4f}")
+
+# Test
+print(f"Predictions: {model(X).data}")
 ```
 
-### Using Docker
+## What's included
 
-```bash
-docker-compose up fit-ml
+**Core**: Tensors with autograd, just like PyTorch
+```python
+x = Tensor([1, 2, 3], requires_grad=True)
+y = x.sum()
+y.backward()  # x.grad is now [1, 1, 1]
 ```
 
-## Quick Start
+**Layers**: Linear, activations, normalization, attention
+```python
+from fit.nn.modules.activation import ReLU, GELU
+from fit.nn.modules.normalization import BatchNorm1d
+```
+
+**Optimizers**: SGD, Adam, and advanced ones like SAM
+```python
+from fit.optim.adam import Adam
+from fit.optim.experimental.sam import SAM
+```
+
+**Simple API**: For quick experiments
+```python
+from fit.simple.models import Classifier
+model = Classifier(input_size=784, num_classes=10)
+```
+
+## MNIST example
 
 ```python
+import numpy as np
 from fit.core.tensor import Tensor
-from fit.nn.sequential import Sequential
-from fit.nn.linear import Linear
-from fit.nn.activations import ReLU, Softmax
-from fit.train.loss import CrossEntropyLoss
-from fit.train.optim import Adam
-from fit.train.trainer import Trainer
-
-# Create a simple model for binary classification
+from fit.nn.modules.container import Sequential
+from fit.nn.modules.linear import Linear
+from fit.nn.modules.activation import ReLU
+from fit.optim.adam import Adam
+from fit.loss.classification import CrossEntropyLoss
+
+# Create MNIST classifier 
 model = Sequential(
-    Linear(2, 4),
+    Linear(784, 128),
+    ReLU(),
+    Linear(128, 64), 
     ReLU(),
-    Linear(4, 2),
-    Softmax()
+    Linear(64, 10)
 )
 
-# Prepare data
-X = Tensor([[0, 0], [0, 1], [1, 0], [1, 1]])  # XOR problem
-y = Tensor([0, 1, 1, 0])
+# Generate some dummy data 
+X_train = Tensor(np.random.randn(100, 784))
+y_train = Tensor(np.random.randint(0, 10, (100,)))
 
-# Define loss function and optimizer
+optimizer = Adam(model.parameters(), lr=0.001)
 loss_fn = CrossEntropyLoss()
-optimizer = Adam(model.parameters(), lr=0.01)
-
-# Create trainer and train
-trainer = Trainer(model, loss_fn, optimizer)
-trainer.fit(X, y, epochs=100)
 
-# Make predictions
-predictions = model(X)
+# Training loop
+for epoch in range(50):
+    pred = model(X_train)
+    loss = loss_fn(pred, y_train)
+    
+    optimizer.zero_grad()
+    loss.backward()
+    optimizer.step()
+    
+    if epoch % 10 == 0:
+        print(f"Epoch {epoch}, Loss: {loss.data:.4f}")
 ```
+
+Perfect for learning how neural networks work under the hood, or when you need a lightweight ML library without the complexity of PyTorch.