Metadata-Version: 2.4
Name: tota
Version: 1.0.0
Summary: Prosta biblioteka do tworzenia i uczenia sieci neuronowych
Author: Tomasz Tota
License: MIT
Keywords: machine-learning,neural-networks,pytorch,education
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: torch>=2.0
Dynamic: license-file

# tota

Prosta, edukacyjna biblioteka Python do tworzenia i uczenia małych sieci neuronowych.

Biblioteka korzysta z PyTorch do obliczeń tensorowych na CPU.

## Instalacja

```bash
python -m pip install tota
```

Wersja z lokalnego repozytorium:

```bash
python -m pip install .
```

## Szybki start

```python
from tota import Layer, Network

training_data = [
    ([1], 0),
    ([2], 0),
    ([6], 1),
    ([8], 1),
]

network = Network([
    Layer(5, 1),
    Layer(1, 5),
])

print(network.learn(
    training_data,
    learning_rate=0.01,
    epochs=5000,
))

print(network.predict([7]))
```

## Główne klasy

Wersja `1.0.0` zachowuje dotychczasowe API i dodaje mały Transformer językowy
do nauki na własnym pliku tekstowym:

```python
from tota import Tokenizer, TransformerLM

tokenizer = Tokenizer(open("data.txt", encoding="utf-8").read())
model = TransformerLM(tokenizer, dlugosc_sekwencji=32, rozmiar_embeddingu=64)
model.train_text("Ala ma kota. Kot siedzi na fotelu.", epochs=5)
print(model.generate("Ala ma", max_tokens=20, top_k=5))
```

Dostępne są: tokenizer znakowy, embeddingi, positional encoding, LayerNorm,
self-attention, multi-head attention, residual blocks, `CrossEntropyLoss`,
`AdamW`, warmup, clipping gradientów i checkpointy.

### `Neuron`

Pojedynczy neuron z wagami, biasem i funkcją aktywacji.

```python
from tota import Neuron

neuron = Neuron([0.5, -0.2], 0.0, activation="sigmoid")
wynik = neuron.forward([1.0, 2.0])
```

### `Layer`

Warstwa wielu neuronów:

```python
from tota import Layer

warstwa = Layer(5, 2, activation="relu")
wynik = warstwa.forward([1.0, 2.0])
```

### `Network`

Łączy warstwy i udostępnia uczenie oraz predykcję:

```python
from tota import Layer, Network

network = Network([
    Layer(5, 2),
    Layer(1, 5),
])

network.learn(dane, learning_rate=0.01, epochs=5000)
klasa = network.predict([1, 2])
```

## Funkcje aktywacji

Dostępne są:

- `sigmoid` — domyślna funkcja,
- `relu`,
- `tanh`,
- `linear`,
- `leaky_relu`,
- `step`.

Aktywację ustawia się osobno dla każdej warstwy:

```python
network = Network([
    Layer(8, 2, activation="relu"),
    Layer(1, 8, activation="sigmoid"),
])
```

## Parametry `Network.learn`

```python
network.learn(
    training_data,
    learning_rate=0.01,
    epochs=50000,
    show_progress=True,
    progress_interval=1000,
)
```

Metoda używa optymalizatora SGD i zwraca tekst z liczbą wykonanych epok oraz końcowym błędem.

## Rozwój lokalny

```bash
python -m pip install -e .
python -m pip install pytest
pytest
```

## Licencja

MIT — zobacz plik `LICENSE`.
