Slay micro-models: eksperci (jig/bach/waltz/reel) + kompozycja (E0/fuse/duet)

.gitignore

@@ -0,0 +1,13 @@
+# cache
+__pycache__/
+*.pyc
+
+# Surowe dane i generacje NIE idą do repo (licencja thesession / rozmiar).
+# Idą za to wytrenowane MODELE (wagi) — to nasze artefakty.
+data/*
+!data/gpt_ckpt.pt
+!data/loss_log.csv
+!data/models
+data/models/*
+!data/models/*.pt
+data/models/gpt_ckpt_v1_dirty.pt

LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 Arkadiusz Słota / Slayer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Note: training data originates from thesession.org contributors and is not
+redistributed in this repository.

README.md

@@ -0,0 +1,65 @@
+---
+license: mit
+tags:
+  - music-generation
+  - abc-notation
+  - symbolic-music
+  - gpt
+  - char-level
+  - from-scratch
+  - model-composition
+  - stitching
+library_name: pytorch
+pipeline_tag: text-generation
+---
+
+# Slay Micro-Models — tiny from-scratch music experts + composition research
+
+A family of **~0.8M-parameter char-level GPTs**, each trained **from scratch** on monophonic music in
+[ABC notation](https://abcnotation.com/), plus experiments in **composing small experts** (stitching,
+ensembling, duets). Built as research for the **Slayer** collective (toward a "small models, composed"
+paper). Music is the sandbox; the methods generalize.
+
+Every expert shares one architecture: decoder-only Transformer — 4 layers, 4 heads, `d_model=128`,
+context 128 chars, character-level. Trained on CPU in minutes.
+
+## The experts
+| Expert (`data/models/`) | Style / render | Training data | Val perplexity |
+|---|---|---|---|
+| `gpt_ckpt.pt` (jig) | Irish jig, 6/8 | 12.1k tunes (thesession.org) | **3.80** |
+| `bach_ckpt.pt` | Baroque chorale soprano | 350 soprano lines (music21) | 2.09\* |
+| `waltz_ckpt.pt` | Lyrical waltz, 3/4 → piano | 3.0k tunes | ~4.4 |
+| `reel_ckpt.pt` | Driving fiddle, 4/4 → violin | 17.2k tunes | ~4.9 |
+| `reel_sv_ckpt.pt` | reel on shared vocab (for composition) | 17.2k tunes | ~4.9 |
+
+\* Bach ppl is **not** directly comparable (smaller vocab + very repetitive data).
+
+## Composition experiments
+- **E0 (self-stitch) ✅** — a trained linear mapper at an intermediate seam is lossless (Δppl ≈ 0): the stitching **mechanism** is sound (validates plumbing, not the thesis).
+- **Ensemble fusion** (`src/fuse.py`) — blend two experts' next-token distributions (shared vocab) → audible hybrid. This is the **flat-weighting baseline**.
+- **Duet** (`src/duet.py`) — two experts layered (piano + violin, simultaneous): multi-track, not model-level fusion.
+- **Next — E1:** representation-level stitch (the actual hypothesis, meant to beat these baselines).
+
+## Pipeline (`src/`)
+`prepare_data.py` / `prepare_bach.py` (build ABC corpus) → `gpt.py` (architecture) → `train_gpt.py`
+(train; optional shared vocab) → `make_midi.py` / `gen_samples.py` (generate + render) →
+`e0_stitch.py` / `fuse.py` / `duet.py` (composition) · `ngram_model.py` (baseline) · `abc_to_midi.py` (render).
+
+## Usage
+```bash
+pip install torch music21
+python src/gen_samples.py --ckpt data/models/waltz_ckpt.pt --meter 3/4 --keys D,G,Emin --inst piano --out out
+```
+
+## Honest scope
+**Shown:** a small char-LM learns real musical structure (meter, key signatures, cadences) from
+next-token prediction *alone*; data cleaning measurably helps (ppl 3.88→3.80); the stitch mechanism is
+lossless; experts can be combined (baseline). **Not yet shown:** that representation-level composition of
+small experts beats a single model — the open hypothesis (E1+).
+
+## Data & license
+Code & weights: **MIT**. Training data **not redistributed** — folk tunes from
+[thesession.org](https://thesession.org/) (rebuild via `prepare_data.py`); Bach chorale sopranos via
+`music21`. Please respect source terms.
+
+Built by Arkadiusz Słota for the **Slayer** collective. Educational / research project.

data/gpt_ckpt.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:886989d488609c2a69cbce40426c490bacb4054b3ade4ffa8efc7c1573d32c0c
+size 3548345

data/loss_log.csv

@@ -0,0 +1,12 @@
+iter,train_loss,val_loss
+0,3.9971,3.997
+200,2.2354,2.2299
+400,1.8646,1.8573
+600,1.6185,1.6163
+800,1.5349,1.5443
+1000,1.4724,1.4663
+1200,1.4319,1.4304
+1400,1.3977,1.3966
+1600,1.3595,1.3655
+1800,1.3591,1.3523
+2000,1.3314,1.3346

data/models/bach_ckpt.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5066f41719d4509f1391c298be02382b6204e83ece0e38a0240c7812847036a3
+size 3539895

data/models/reel_ckpt.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6504e8633a1533ba01e0df10827b6ee261efcae24065df97d7c4d9e153b851be
+size 3548407

data/models/reel_sv_ckpt.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:149711e857fd356aa00e45065f51890849c37d1e603839fd4c8249bea0d86548
+size 3549105

data/models/waltz_ckpt.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d2a982c5cd7e2b71353185d1fe5a39b0731e8a1a0caf8c5ca55071abedb24c5
+size 3548981

reports/raport-baseline.html

@@ -0,0 +1,169 @@
+<title>Raport — Baseline generatora muzyki ABC (n-gram)</title>
+<style>
+  :root{
+    --ink:#1a1726; --muted:#6b6580; --line:#e7e3f0; --bg:#faf9fd;
+    --accent:#6d4aff; --accent2:#12a594; --warn:#c2410c; --paper:#fff;
+  }
+  *{box-sizing:border-box}
+  .wrap{max-width:880px;margin:0 auto;padding:36px 22px 80px;
+    font-family:"Segoe UI",system-ui,-apple-system,sans-serif;color:var(--ink);
+    background:var(--bg);line-height:1.62;font-size:16px;-webkit-font-smoothing:antialiased}
+  h1{font-size:30px;line-height:1.2;margin:0 0 6px;letter-spacing:-.02em}
+  h2{font-size:20px;margin:38px 0 12px;padding-top:18px;border-top:1px solid var(--line);letter-spacing:-.01em}
+  h3{font-size:15px;margin:22px 0 6px;color:var(--accent);text-transform:uppercase;letter-spacing:.06em}
+  p{margin:10px 0}
+  .sub{color:var(--muted);font-size:14.5px;margin:0 0 4px}
+  .tag{display:inline-block;background:var(--accent);color:#fff;font-size:11px;
+    font-weight:700;letter-spacing:.08em;padding:3px 9px;border-radius:20px;text-transform:uppercase}
+  .abstract{background:var(--paper);border:1px solid var(--line);border-left:4px solid var(--accent);
+    border-radius:10px;padding:16px 20px;margin:22px 0;font-size:15.5px}
+  .cards{display:flex;gap:12px;flex-wrap:wrap;margin:18px 0}
+  .card{flex:1;min-width:150px;background:var(--paper);border:1px solid var(--line);
+    border-radius:12px;padding:16px 18px}
+  .card .n{font-size:26px;font-weight:800;color:var(--accent);letter-spacing:-.02em}
+  .card .l{font-size:13px;color:var(--muted);margin-top:2px}
+  .chart{background:var(--paper);border:1px solid var(--line);border-radius:12px;padding:20px 22px;margin:14px 0}
+  .cap{font-size:13px;color:var(--muted);margin-top:10px}
+  /* vertical bars */
+  .barv-row{display:flex;align-items:flex-end;gap:10px;height:220px;margin-top:6px}
+  .barv-col{flex:1;display:flex;flex-direction:column;align-items:center;height:100%;justify-content:flex-end}
+  .barv{width:100%;border-radius:6px 6px 0 0;background:linear-gradient(180deg,#8a6bff,#6d4aff)}
+  .barv-v{font-size:12.5px;font-weight:700;margin-bottom:5px;color:var(--ink)}
+  .barv-x{font-size:12px;color:var(--muted);margin-top:7px}
+  /* horizontal bars */
+  .barh{display:grid;grid-template-columns:54px 1fr;gap:8px;align-items:center;margin:5px 0}
+  .barh .k{font-family:ui-monospace,Consolas,monospace;font-size:13px;text-align:right;color:var(--muted)}
+  .track{background:#f0edf8;border-radius:6px;height:22px;overflow:hidden;position:relative}
+  .fill{height:100%;background:linear-gradient(90deg,#6d4aff,#9a82ff);border-radius:6px;
+    display:flex;align-items:center;justify-content:flex-end;padding-right:7px;color:#fff;font-size:11.5px;font-weight:700}
+  /* stacked novelty */
+  .stack{display:flex;height:30px;border-radius:7px;overflow:hidden;margin:7px 0;font-size:12px;font-weight:700;color:#fff}
+  .seg-copy{background:#b8b2cc;display:flex;align-items:center;justify-content:center}
+  .seg-new{background:var(--accent2);display:flex;align-items:center;justify-content:center}
+  .skey{font-family:ui-monospace,Consolas,monospace;font-size:13px;color:var(--muted);margin-right:8px;min-width:60px;display:inline-block}
+  .finding{background:#eafaf6;border:1px solid #b9ece1;border-radius:10px;padding:14px 18px;margin:18px 0}
+  .finding b{color:var(--accent2)}
+  .warnbox{background:#fff5ed;border:1px solid #fcd9bf;border-radius:10px;padding:14px 18px;margin:18px 0}
+  pre{background:#1a1726;color:#e8e3f7;border-radius:10px;padding:16px 18px;overflow-x:auto;
+    font-family:ui-monospace,Consolas,monospace;font-size:13px;line-height:1.5}
+  table{width:100%;border-collapse:collapse;margin:12px 0;font-size:14.5px}
+  th,td{text-align:left;padding:8px 10px;border-bottom:1px solid var(--line)}
+  th{color:var(--muted);font-weight:600;font-size:13px}
+  .ok{color:var(--accent2);font-weight:700}
+  .no{color:var(--warn);font-weight:700}
+  footer{margin-top:40px;padding-top:16px;border-top:1px solid var(--line);color:var(--muted);font-size:13px}
+  .flow{font-family:ui-monospace,Consolas,monospace;font-size:13.5px;background:var(--paper);
+    border:1px solid var(--line);border-radius:10px;padding:14px 16px;text-align:center;color:var(--accent)}
+</style>
+
+<div class="wrap">
+
+  <span class="tag">Slayer · NaukaML · Capstone (baseline)</span>
+  <h1>Generator melodii fortepianowych metodą n-gram</h1>
+  <p class="sub">Raport z eksperymentu &middot; 2026-06-20 &middot; Arkadiusz Słota</p>
+  <p class="sub">Korpus: 11&nbsp;404 jigów 6/8 (thesession.org) &middot; model i kod własne, bez bibliotek ML</p>
+
+  <div class="abstract">
+    <b>Streszczenie.</b> Zbudowano od podstaw statystyczny model językowy (n-gram rzędu&nbsp;6)
+    przewidujący kolejny <i>znak</i> notacji ABC i generujący nowe melodie taneczne (jigi 6/8).
+    Model — w całości napisany w czystym Pythonie — odtwarza strukturę metryczną, kreski taktowe
+    i kadencje <b>bez żadnej zakodowanej wiedzy muzycznej</b>, wyłącznie ze statystyki 2,3&nbsp;mln znaków.
+    Wygenerowane utwory przekonwertowano do MIDI (fortepian). Praca stanowi <b>punkt odniesienia</b>
+    dla planowanego modelu neuronowego (GPT od zera).
+  </div>
+
+  <div class="cards">
+    <div class="card"><div class="n">2 321 606</div><div class="l">znaków w korpusie</div></div>
+    <div class="card"><div class="n">53</div><div class="l">znaki w słowniku</div></div>
+    <div class="card"><div class="n">306 858</div><div class="l">unikalne konteksty (rząd 6)</div></div>
+    <div class="card"><div class="n">5 / 5</div><div class="l">melodii → MIDI</div></div>
+  </div>
+
+  <h2>1. Metoda</h2>
+  <p>Muzykę potraktowano jako <b>tekst</b> w notacji ABC, a generację jako zadanie „przewidź następny token"
+  — identycznie jak w modelach językowych, tylko na poziomie znaku. Pipeline:</p>
+  <p class="flow">dane (ABC) → zliczanie n-gramów → próbkowanie z backoffem → ABC → MIDI (fortepian)</p>
+  <p>Model przechowuje, dla każdego kontekstu długości 0–6 znaków, rozkład następnego znaku.
+  Przy generacji stosuje <b>backoff</b>: używa najdłuższego zaobserwowanego kontekstu, a gdy go brak —
+  skraca. Próbkowanie z temperaturą&nbsp;0,7. Uczenie = zliczanie (brak wag, gradientu, GPU).</p>
+
+  <h2>2. Struktura danych: „pamięć" modelu</h2>
+  <div class="chart">
+    <div class="barv-row">
+      <div class="barv-col"><div class="barv-v">53</div><div class="barv" style="height:31%"></div><div class="barv-x">1</div></div>
+      <div class="barv-col"><div class="barv-v">1 295</div><div class="barv" style="height:57%"></div><div class="barv-x">2</div></div>
+      <div class="barv-col"><div class="barv-v">13 410</div><div class="barv" style="height:75%"></div><div class="barv-x">3</div></div>
+      <div class="barv-col"><div class="barv-v">56 461</div><div class="barv" style="height:87%"></div><div class="barv-x">4</div></div>
+      <div class="barv-col"><div class="barv-v">154 688</div><div class="barv" style="height:94%"></div><div class="barv-x">5</div></div>
+      <div class="barv-col"><div class="barv-v">306 858</div><div class="barv" style="height:100%"></div><div class="barv-x">6</div></div>
+    </div>
+    <div class="cap">Ryc. 1 — Liczba unikalnych kontekstów wg długości n-gramu (skala log). Im dłuższy kontekst,
+    tym więcej różnych wzorców — i tym bliżej do zapamiętywania pojedynczych fragmentów.</div>
+  </div>
+
+  <h2>3. Z czego zbudowana jest notacja ABC</h2>
+  <div class="chart">
+    <div class="barh"><div class="k">spacja</div><div class="track"><div class="fill" style="width:100%">291 488</div></div></div>
+    <div class="barh"><div class="k">|</div><div class="track"><div class="fill" style="width:92.6%">269 821</div></div></div>
+    <div class="barh"><div class="k">A</div><div class="track"><div class="fill" style="width:61.6%">179 528</div></div></div>
+    <div class="barh"><div class="k">d</div><div class="track"><div class="fill" style="width:54.7%">159 584</div></div></div>
+    <div class="barh"><div class="k">B</div><div class="track"><div class="fill" style="width:53.8%">156 938</div></div></div>
+    <div class="barh"><div class="k">e</div><div class="track"><div class="fill" style="width:43%">125 418</div></div></div>
+    <div class="barh"><div class="k">G</div><div class="track"><div class="fill" style="width:38.8%">113 138</div></div></div>
+    <div class="barh"><div class="k">2</div><div class="track"><div class="fill" style="width:35.2%">102 474</div></div></div>
+    <div class="barh"><div class="k">:</div><div class="track"><div class="fill" style="width:26.4%">76 971</div></div></div>
+    <div class="cap">Ryc. 2 — Najczęstsze znaki w korpusie. Dominują <b>spacja</b> i <b>kreska taktowa „|"</b>
+    (rytm/struktura), potem nuty (A, d, B…) — model najpierw uczy się „rusztowania" utworu.</div>
+  </div>
+
+  <h2>4. Wynik kluczowy: kopiuje czy komponuje?</h2>
+  <p>Sprawdzono, jaki procent fragmentów wygenerowanej muzyki <b>występuje dosłownie</b> w danych treningowych
+  (im dłuższe okno, tym ostrzejszy test oryginalności):</p>
+  <div class="chart">
+    <div><span class="skey">okno 4</span></div>
+    <div class="stack"><div class="seg-copy" style="width:97.7%">97,7% skopiowane</div><div class="seg-new" style="width:2.3%">2,3%</div></div>
+    <div><span class="skey">okno 6</span></div>
+    <div class="stack"><div class="seg-copy" style="width:94.2%">94,2% skopiowane</div><div class="seg-new" style="width:5.8%">5,8%</div></div>
+    <div><span class="skey">okno 8</span></div>
+    <div class="stack"><div class="seg-copy" style="width:83.9%">83,9% skopiowane</div><div class="seg-new" style="width:16.1%">16,1% nowe</div></div>
+    <div class="cap">Ryc. 3 — Udział fragmentów skopiowanych (szare) vs nowych (zielone) wg długości okna.</div>
+  </div>
+  <div class="finding">
+    <b>Wniosek:</b> na krótkich oknach model niemal wyłącznie powtarza zapamiętane wzorce (97,7%),
+    ale na dłuższych <b>16,1% sekwencji jest nowych</b> — model <b>skleja zapamiętane fragmenty
+    w nowe, niewidziane wcześniej całości</b>. To jest „kompozycja" n-gramu: lokalnie poprawna,
+    globalnie świeża.
+  </div>
+
+  <h2>5. Dyskusja — uczciwie o ograniczeniach</h2>
+  <div class="warnbox">
+    To <b>model statystyczny (n-gram), nie sieć neuronowa.</b> „Widzi" maksymalnie 6 znaków wstecz,
+    więc nie ma <b>długiego łuku formalnego</b> (powtórzenie tematu, budowa AABB), a MIDI jest
+    mechaniczne (stała głośność, brak pedału i frazowania). Wysoki odsetek kopiowania to wprost
+    skutek braku uogólniania — czego nauczyliśmy się jako granicy małych/prostych modeli (L04, L08).
+  </div>
+
+  <h2>6. Następny krok (Tor 2)</h2>
+  <table>
+    <tr><th>Aspekt</th><th>Teraz (baseline)</th><th>GPT neuronowy</th></tr>
+    <tr><td>Mechanizm</td><td>zliczanie n-gramów</td><td>wagi + gradient (backprop)</td></tr>
+    <tr><td>Pamięć kontekstu</td><td class="no">6 znaków</td><td class="ok">setki tokenów (uwaga)</td></tr>
+    <tr><td>Uogólnianie</td><td class="no">słabe (kopiuje)</td><td class="ok">realne</td></tr>
+    <tr><td>Sprzęt</td><td>CPU, sekundy</td><td>GPU (RTX 3050)</td></tr>
+    <tr><td>Cel docelowy</td><td>jigi ABC</td><td class="ok">fortepian, styl Chopina</td></tr>
+  </table>
+  <p>Baseline będzie <b>miarą</b>, o ile model neuronowy poprawi spójność i oryginalność.</p>
+
+  <h2>Aneks — przykładowa wygenerowana melodia</h2>
+  <pre>X:1
+M:6/8
+K:G
+|:DED F2A|d2f a2f|fge fdB|AdB AFD|FED E2 A|cA/B/c dcd|
+efe edB|dBA GBd|~g3 gfg|afd e2 g|f2 d def|efe edB|AGF Gdc:|</pre>
+
+  <footer>
+    Eksperyment wykonany w ramach kursu NaukaML (Slayer). Model i kod: własne (czysty Python).
+    Konwersja ABC→MIDI: music21. Dane: thesession.org. Metryki liczone na 2,3&nbsp;mln znaków korpusu.
+  </footer>
+
+</div>

requirements.txt

@@ -0,0 +1,2 @@
+torch>=2.0
+music21>=9.0

samples/clean_1.abc

@@ -0,0 +1,10 @@
+X:1
+M:6/8
+K:G
+|:Edc B2A|EDE FED|EGA AFD|EDE DED|
+EGA FEE|DED EFE|GBA AFE|1 AGE G2 :|2 AGE D2G||
+|:DEG Ade|gfg efe|fed cBA|G2A GED|
+DDE AEB|BGA ded|efe dBA|AAG AFE|
+AFA Adc|dcd BAF|Adc BGD|
+DFA ded|ded gfd|Bcd gfe|faf fdB|
+cdf edB|ddd f2e|cdA AFD|DFD D2:|

samples/clean_2.abc

@@ -0,0 +1,6 @@
+X:1
+M:6/8
+K:G
+|:D|GAF EFG|Bde dAB|ABG FDB|1 DAB B2d:|2 edB d2B:||2 gfg fdB|
+GB ABd|GBd g2e|dBd gfe|abd egf|
+gag gfd|cBG GAG|BAG GAG|AGE D2:|

samples/clean_3.abc

@@ -0,0 +1,9 @@
+X:1
+M:6/8
+K:G
+|:dBA cAF|GBG BAF|FDF AFD|dcd cAF|
+d2A AFC|AFA cAF|BAd cBF|DFD DFF|
+GFA AFD|DBG cBc|dcB cBA|cdc d2:|
+|:DDED AFD|DFG AFF|FDD FED|dDG D2F|
+DFD EFD|dfd d2d|ddB FGE|DED D2C F|
+DDFD FEA|cdd cAG|(BAF BAF|1 FDD D2E:|2 FFG G2 E||

src/abc_to_midi.py

@@ -0,0 +1,50 @@
+"""Konwersja wygenerowanych melodii ABC -> MIDI (fortepian) przez music21.
+Każda melodia osobno; błędy parsowania nie wywalają całości.
+"""
+import sys, re
+from music21 import converter, instrument
+
+def sanitize(abc: str) -> str:
+    """Usuwa powtórzenia/volty z ciała, ALE ZOSTAWIA akordy [ace]. Nagłówki nietknięte."""
+    out = []
+    for ln in abc.split("\n"):
+        if re.match(r"^[A-Za-z]:", ln):       # nagłówek
+            out.append(ln); continue
+        b = re.sub(r"\[[12]", "", ln)         # volty [1 [2  (akordy [ace] ZOSTAJĄ!)
+        b = b.replace(":", "")                # dwukropki powtórzeń (|: :| ::)
+        b = re.sub(r"\|\s*[12]", "|", b)      # numery volt po kresce |1 |2
+        b = re.sub(r"\|+", "|", b)            # scal wielokrotne kreski
+        b = re.sub(r"\^=|=\^|_=|=_", lambda m: m.group(0).replace("=", ""), b)  # zepsute akcydencje (^=)
+        out.append(b)
+    return "\n".join(out)
+
+def to_midi(abc: str, out_path: str, inst=None) -> bool:
+    try:
+        score = converter.parse(sanitize(abc), format="abc")
+        # spłaszcz do samych nut/pauz (omija konflikt TimeSignature przy budowie taktów)
+        notes = score.flatten().notesAndRests.stream()
+        if inst is not None:                  # ustaw instrument (np. Violin); domyślnie fortepian (GM 0)
+            notes.insert(0, inst)
+        notes.write("midi", fp=out_path)
+        return True
+    except Exception as e:
+        print(f"  [pominięto] {out_path}: {type(e).__name__}: {e}")
+        return False
+
+def main():
+    sys.stdout.reconfigure(encoding="utf-8")
+    infile = sys.argv[1] if len(sys.argv) > 1 else "data/generated.abc"
+    prefix = sys.argv[2] if len(sys.argv) > 2 else "data/jig"
+    text = open(infile, encoding="utf-8").read()
+    tunes = [t.strip() for t in text.split("\n\n") if "X:" in t]
+    print(f"melodii do konwersji: {len(tunes)} (z {infile})")
+    ok = 0
+    for i, tune in enumerate(tunes, 1):
+        path = f"{prefix}_{i}.mid"
+        if to_midi(tune, path):
+            print(f"  OK -> {path}")
+            ok += 1
+    print(f"\ngotowe: {ok}/{len(tunes)} plików MIDI (fortepian) w data/")
+
+if __name__ == "__main__":
+    main()

src/analyze.py

@@ -0,0 +1,40 @@
+"""Metryki do raportu: rozkład znaków, nowość (kopiuje vs komponuje), długości."""
+import sys, collections, json
+
+sys.stdout.reconfigure(encoding="utf-8")
+train = open("data/jigs.abc", encoding="utf-8").read()
+gen = open("data/generated.abc", encoding="utf-8").read()
+
+# ciało generacji bez nagłówków (do metryki nowości)
+def bodies(text):
+    return "".join(ln for ln in text.split("\n")
+                    if ln and not ln[:2] in ("X:", "M:", "K:"))
+
+gen_body = bodies(gen)
+
+# 1) rozkład znaków (top 15) w treningu
+freq = collections.Counter(c for c in train if c != "\n")
+top = freq.most_common(15)
+
+# 2) nowość: jaki % k-gramów generacji WYSTĘPUJE w treningu (kopiowanie)
+novelty = {}
+for k in (4, 6, 8):
+    tr = set(train[i:i+k] for i in range(len(train)-k))
+    gk = [gen_body[i:i+k] for i in range(len(gen_body)-k)]
+    seen = sum(1 for g in gk if g in tr)
+    novelty[k] = {"skopiowane_%": round(100*seen/len(gk), 1),
+                  "nowe_%": round(100*(1-seen/len(gk)), 1)}
+    del tr
+
+# 3) długości wygenerowanych melodii
+tunes = [t for t in gen.split("\n\n") if "X:" in t]
+lens = [len(t) for t in tunes]
+
+print(json.dumps({
+    "korpus_znaki": len(train),
+    "slownik": len(set(train)),
+    "top_znaki": top,
+    "nowosc": novelty,
+    "wygenerowane_melodie": len(tunes),
+    "srednia_dlugosc_znaki": round(sum(lens)/len(lens), 1),
+}, ensure_ascii=False, indent=2))

src/duet.py

@@ -0,0 +1,60 @@
+"""DUET: walc (fortepian) + reel (skrzypce) grają RAZEM — dwie ścieżki naraz, ta sama tonacja.
+To NIE fuzja w jedną linię (jak ensemble), tylko dwie niezależne linie złożone jednocześnie.
+"""
+import sys, os
+sys.path.insert(0, "src")
+import torch
+from gpt import GPT
+from abc_to_midi import sanitize
+from music21 import converter, stream, instrument as M, tempo
+
+def load(p):
+    ck = torch.load(p, map_location="cpu", weights_only=False)
+    m = GPT(ck["config"]); m.load_state_dict(ck["model"]); m.eval()
+    return m, ck
+
+def first_tune(raw):
+    out = []
+    for ln in raw.split("\n"):
+        if ln.startswith("X:") and out:
+            break
+        out.append(ln)
+    return "\n".join(out).strip()
+
+@torch.no_grad()
+def gen(model, stoi, itos, seed, n=360, temp=0.85, topk=18):
+    idx = torch.tensor([[stoi[c] for c in seed]])
+    out = model.generate(idx, n, temperature=temp, top_k=topk)[0].tolist()
+    return first_tune("".join(itos[t] for t in out))
+
+def to_part(abc, inst):
+    sc = converter.parse(sanitize(abc), format="abc")
+    notes = sc.flatten().notesAndRests.stream()
+    notes.insert(0, inst)
+    return notes
+
+def main():
+    sys.stdout.reconfigure(encoding="utf-8")
+    waltz, ckW = load("data/models/waltz_ckpt.pt")
+    reel, ckR = load("data/models/reel_sv_ckpt.pt")
+    stoi, itos = ckW["stoi"], ckW["itos"]
+    os.makedirs("data/recordings/duet", exist_ok=True)
+    torch.manual_seed(20260621)
+    ok = 0
+    for key in ["D", "G", "Emin"]:
+        wabc = gen(waltz, stoi, itos, f"X:1\nM:3/4\nK:{key}\n")   # fortepian, walc 3/4
+        rabc = gen(reel,  stoi, itos, f"X:1\nM:4/4\nK:{key}\n")   # skrzypce, reel 4/4
+        try:
+            sc = stream.Score()
+            sc.insert(0, tempo.MetronomeMark(number=96))
+            sc.insert(0, to_part(wabc, M.Piano()))
+            sc.insert(0, to_part(rabc, M.Violin()))
+            path = f"data/recordings/duet/duet_{key}.mid"
+            sc.write("midi", fp=path)
+            print(f"  duet {key} [OK] -> {path}"); ok += 1
+        except Exception as e:
+            print(f"  duet {key} [błąd]: {type(e).__name__}: {e}")
+    print(f"\ngotowe: {ok}/3 duetów w data/recordings/duet/ — fortepian + skrzypce RAZEM 🎻🎹")
+
+if __name__ == "__main__":
+    main()

src/e0_stitch.py

@@ -0,0 +1,79 @@
+"""E0 — self-stitch (benchmark zerowy).
+Wstaw liniowy mapper g (n_embd x n_embd) na styku PO bloku 2 TEGO SAMEGO modelu,
+zamroź resztę. Waliduje MECHANIZM mappera (hydraulikę), NIE tezę.
+  - sanity: g = identyczność -> dokładnie baseline.
+  - E0:     g losowy -> trenuj tylko g -> powinien wrócić do baseline (Δppl≈0).
+Użycie: python src/e0_stitch.py [ckpt] [dane]
+"""
+import sys, math
+sys.path.insert(0, "src")
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+from gpt import GPT
+
+sys.stdout.reconfigure(encoding="utf-8")
+CKPT = sys.argv[1] if len(sys.argv) > 1 else "data/gpt_ckpt.pt"
+DATA = sys.argv[2] if len(sys.argv) > 2 else "data/jigs.abc"
+SEAM = 2          # g przed blokiem o indeksie 2 = styk po 2 blokach
+TRAIN_STEPS = 500
+
+ck = torch.load(CKPT, map_location="cpu", weights_only=False)
+stoi, itos, cfg = ck["stoi"], ck["itos"], ck["config"]
+model = GPT(cfg); model.load_state_dict(ck["model"]); model.eval()
+for p in model.parameters():
+    p.requires_grad_(False)
+print(f"model: {model.num_params():,} param | val loss z ckpt: {ck['val_loss']:.4f} | bloków: {cfg.n_layer} | styk po: {SEAM}")
+
+text = open(DATA, encoding="utf-8").read()
+data = torch.tensor([stoi[c] for c in text], dtype=torch.long)
+n = int(0.9 * len(data)); train, val = data[:n], data[n:]
+block, bs = cfg.block_size, 32
+
+def get_batch(split):
+    d = train if split == "train" else val
+    ix = torch.randint(len(d) - block, (bs,))
+    x = torch.stack([d[i:i+block] for i in ix])
+    y = torch.stack([d[i+1:i+1+block] for i in ix])
+    return x, y
+
+g = nn.Linear(cfg.n_embd, cfg.n_embd)
+
+def fwd(idx, targets, use_g):
+    B, T = idx.shape
+    pos = torch.arange(T)
+    x = model.drop(model.tok_emb(idx) + model.pos_emb(pos))
+    for i, blk in enumerate(model.blocks):
+        if use_g and i == SEAM:
+            x = g(x)
+        x = blk(x)
+    logits = model.head(model.ln_f(x))
+    return F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
+
+@torch.no_grad()
+def eval_loss(use_g, iters=60, seed=1234):
+    torch.manual_seed(seed)               # te same batche val dla każdej oceny
+    return sum(fwd(*get_batch("val"), use_g).item() for _ in range(iters)) / iters
+
+base = eval_loss(use_g=False)
+with torch.no_grad():                      # sanity: identyczność
+    g.weight.copy_(torch.eye(cfg.n_embd)); g.bias.zero_()
+ident = eval_loss(use_g=True)
+print(f"baseline (bez g):    val {base:.4f} | ppl {math.exp(base):.4f}")
+print(f"g = identyczność:    val {ident:.4f} | ppl {math.exp(ident):.4f}   (sanity: == baseline)")
+
+torch.manual_seed(1)                        # E0: g losowy -> trening tylko g
+nn.init.normal_(g.weight, std=0.02); nn.init.zeros_(g.bias)
+rand0 = eval_loss(use_g=True)
+opt = torch.optim.AdamW(g.parameters(), lr=1e-3)
+for _ in range(TRAIN_STEPS):
+    loss = fwd(*get_batch("train"), True)
+    opt.zero_grad(); loss.backward(); opt.step()
+trained = eval_loss(use_g=True)
+print(f"g losowy (przed):    val {rand0:.4f} | ppl {math.exp(rand0):.4f}")
+print(f"g po treningu ({TRAIN_STEPS}): val {trained:.4f} | ppl {math.exp(trained):.4f}")
+
+dppl = math.exp(trained) - math.exp(base)
+print(f"\nΔppl (po treningu - baseline): {dppl:+.4f}")
+print("WERDYKT E0:", "PASS ✅ — mapper bezstratny, mechanizm szwu działa (benchmark zerowy)"
+      if abs(dppl) < 0.05 else "FAIL ❌ — bug w mechanizmie szwu, stop")

src/fuse.py

@@ -0,0 +1,78 @@
+"""Złączenie przez ensemble (logit-mix) DWÓCH modeli o WSPÓLNYM słowniku.
+W każdym kroku: logits = alpha*A + (1-alpha)*B -> sampluj. Melodia wychodzi stylistycznie pomiędzy.
+To jest baseline „płaskiego ważenia" (KMS5). Stitch reprezentacji = osobny eksperyment (E1).
+Użycie:
+  python src/fuse.py --a data/models/waltz_ckpt.pt --b data/models/reel_sv_ckpt.pt \
+      --alpha 0.5 --meter 3/4 --keys D,G,Emin --inst piano --out data/recordings/fuzja
+"""
+import argparse, sys, os, math
+sys.path.insert(0, "src")
+import torch
+from torch.nn import functional as F
+from gpt import GPT
+from abc_to_midi import to_midi
+from music21 import instrument as M
+
+INST = {"piano": M.Piano, "violin": M.Violin, "none": None}
+
+def load(path):
+    ck = torch.load(path, map_location="cpu", weights_only=False)
+    m = GPT(ck["config"]); m.load_state_dict(ck["model"]); m.eval()
+    return m, ck
+
+def first_tune(raw):
+    out = []
+    for ln in raw.split("\n"):
+        if ln.startswith("X:") and out:
+            break
+        out.append(ln)
+    return "\n".join(out).strip()
+
+@torch.no_grad()
+def gen_mix(A, B, idx, n, alpha, temp, topk, block):
+    for _ in range(n):
+        ic = idx[:, -block:]
+        la, _ = A(ic); lb, _ = B(ic)
+        logits = (alpha * la[:, -1, :] + (1 - alpha) * lb[:, -1, :]) / temp
+        if topk:
+            v, _ = torch.topk(logits, topk)
+            logits[logits < v[:, [-1]]] = float("-inf")
+        probs = F.softmax(logits, dim=-1)
+        idx = torch.cat([idx, torch.multinomial(probs, 1)], dim=1)
+    return idx
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--a", required=True); ap.add_argument("--b", required=True)
+    ap.add_argument("--alpha", type=float, default=0.5)
+    ap.add_argument("--meter", default="3/4"); ap.add_argument("--keys", default="D,G,Emin")
+    ap.add_argument("--inst", default="piano", choices=list(INST))
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--new", type=int, default=420); ap.add_argument("--temp", type=float, default=0.85)
+    ap.add_argument("--topk", type=int, default=18)
+    a = ap.parse_args()
+    sys.stdout.reconfigure(encoding="utf-8")
+
+    A, ckA = load(a.a); B, ckB = load(a.b)
+    assert ckA["stoi"] == ckB["stoi"], "Modele mają RÓŻNY słownik — najpierw wspólny słownik!"
+    stoi, itos = ckA["stoi"], ckA["itos"]
+    block = ckA["config"].block_size
+    os.makedirs(a.out, exist_ok=True)
+    inst_cls = INST[a.inst]
+    print(f"FUZJA α={a.alpha} (A={a.a} : B={a.b}) | wspólny słownik {len(stoi)} | -> {a.out}")
+    torch.manual_seed(20260621)
+    ok = 0
+    for i, key in enumerate(a.keys.split(","), 1):
+        seed = f"X:1\nM:{a.meter}\nK:{key}\n"
+        idx = torch.tensor([[stoi[c] for c in seed]])
+        gen = gen_mix(A, B, idx, a.new, a.alpha, a.temp, a.topk, block)[0].tolist()
+        tune = first_tune("".join(itos[t] for t in gen))
+        base = f"{a.out}/fuzja_{i}_{key}"
+        open(base + ".abc", "w", encoding="utf-8").write(tune + "\n")
+        good = to_midi(tune, base + ".mid", inst=inst_cls() if inst_cls else None)
+        ok += good
+        print(f"  #{i} ({key}) [{'MIDI OK' if good else 'błąd'}] -> {base}.mid")
+    print(f"\ngotowe: {ok}/{len(a.keys.split(','))} fuzji w {a.out}/")
+
+if __name__ == "__main__":
+    main()

src/gen_samples.py

@@ -0,0 +1,60 @@
+"""Generuje N próbek z wytrenowanego modelu i renderuje do MIDI z wybranym instrumentem.
+Po jednej melodii na podaną tonację. Zapisuje ABC + MIDI do osobnego katalogu.
+Użycie:
+  python src/gen_samples.py --ckpt data/models/waltz_ckpt.pt --meter 3/4 --keys D,G,C,Emin,Amin --inst piano  --out data/recordings/waltz
+  python src/gen_samples.py --ckpt data/models/reel_ckpt.pt  --meter 4/4 --keys D,G,A,Emin,Bmin --inst violin --out data/recordings/reel
+"""
+import argparse, sys, os
+sys.path.insert(0, "src")
+import torch
+from gpt import GPT
+from abc_to_midi import to_midi
+from music21 import instrument as M
+
+INST = {"piano": M.Piano, "violin": M.Violin, "guitar": M.AcousticGuitar, "none": None}
+
+def first_tune(raw):
+    lines = []
+    for ln in raw.split("\n"):
+        if ln.startswith("X:") and lines:
+            break
+        lines.append(ln)
+    return "\n".join(lines).strip()
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", required=True)
+    ap.add_argument("--meter", default="4/4")
+    ap.add_argument("--keys", default="D,G,A,Emin,Bmin")
+    ap.add_argument("--inst", default="none", choices=list(INST))
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--new", type=int, default=420)
+    ap.add_argument("--temp", type=float, default=0.85)
+    ap.add_argument("--topk", type=int, default=18)
+    a = ap.parse_args()
+    sys.stdout.reconfigure(encoding="utf-8")
+
+    ck = torch.load(a.ckpt, map_location="cpu", weights_only=False)
+    stoi, itos, cfg = ck["stoi"], ck["itos"], ck["config"]
+    model = GPT(cfg); model.load_state_dict(ck["model"]); model.eval()
+    os.makedirs(a.out, exist_ok=True)
+    inst_cls = INST[a.inst]
+    print(f"{a.ckpt} | val {ck['val_loss']:.3f} | instrument: {a.inst} -> {a.out}")
+    torch.manual_seed(20260621)
+    ok = 0
+    for i, key in enumerate(a.keys.split(","), 1):
+        seed = f"X:1\nM:{a.meter}\nK:{key}\n"
+        if any(c not in stoi for c in seed):
+            print(f"  #{i} ({key}): seed ma znak spoza słownika — pomijam"); continue
+        idx = torch.tensor([[stoi[c] for c in seed]])
+        gen = model.generate(idx, a.new, temperature=a.temp, top_k=a.topk)[0].tolist()
+        tune = first_tune("".join(itos[t] for t in gen))
+        base = f"{a.out}/sample_{i}_{key}"
+        open(base + ".abc", "w", encoding="utf-8").write(tune + "\n")
+        good = to_midi(tune, base + ".mid", inst=inst_cls() if inst_cls else None)
+        ok += good
+        print(f"  #{i} ({key}) [{'MIDI OK' if good else 'błąd'}] -> {base}.mid")
+    print(f"\ngotowe: {ok}/{len(a.keys.split(','))} próbek w {a.out}/")
+
+if __name__ == "__main__":
+    main()

src/gpt.py

@@ -0,0 +1,128 @@
+"""Mały GPT od zera (char-level) — architektura z lekcji L07.
+Embedding -> [Blok: uwaga (Q/K/V + maska) + MLP/GELU + residual + LayerNorm] x N -> logity.
+Czysty PyTorch, bez gotowych warstw transformera.
+"""
+import math
+from dataclasses import dataclass
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+
+
+@dataclass
+class GPTConfig:
+    vocab_size: int = 53
+    block_size: int = 256      # ile znaków kontekstu (uwaga sięga tak daleko)
+    n_layer: int = 4
+    n_head: int = 4
+    n_embd: int = 128
+    dropout: float = 0.1
+
+
+class CausalSelfAttention(nn.Module):
+    """Uwaga z maską przyczynową (L07): token patrzy tylko wstecz."""
+    def __init__(self, cfg: GPTConfig):
+        super().__init__()
+        assert cfg.n_embd % cfg.n_head == 0
+        self.qkv = nn.Linear(cfg.n_embd, 3 * cfg.n_embd)   # Q, K, V naraz
+        self.proj = nn.Linear(cfg.n_embd, cfg.n_embd)
+        self.attn_drop = nn.Dropout(cfg.dropout)
+        self.resid_drop = nn.Dropout(cfg.dropout)
+        self.n_head = cfg.n_head
+        self.n_embd = cfg.n_embd
+        # maska dolnotrójkątna: pozycja t widzi tylko <= t
+        self.register_buffer("mask", torch.tril(torch.ones(cfg.block_size, cfg.block_size))
+                             .view(1, 1, cfg.block_size, cfg.block_size))
+
+    def forward(self, x):
+        B, T, C = x.shape
+        q, k, v = self.qkv(x).split(self.n_embd, dim=2)
+        # rozbij na głowice: (B, nh, T, hs)
+        hs = C // self.n_head
+        q = q.view(B, T, self.n_head, hs).transpose(1, 2)
+        k = k.view(B, T, self.n_head, hs).transpose(1, 2)
+        v = v.view(B, T, self.n_head, hs).transpose(1, 2)
+        # scores = Q·Kᵀ / √d  (L07: /√d normalizuje wariancję)
+        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(hs))
+        att = att.masked_fill(self.mask[:, :, :T, :T] == 0, float("-inf"))
+        att = self.attn_drop(F.softmax(att, dim=-1))
+        y = att @ v                                  # ważona suma V
+        y = y.transpose(1, 2).contiguous().view(B, T, C)
+        return self.resid_drop(self.proj(y))
+
+
+class MLP(nn.Module):
+    """Przetwarzanie w tokenie (L07): 768->4x->768 z GELU."""
+    def __init__(self, cfg: GPTConfig):
+        super().__init__()
+        self.fc = nn.Linear(cfg.n_embd, 4 * cfg.n_embd)
+        self.proj = nn.Linear(4 * cfg.n_embd, cfg.n_embd)
+        self.drop = nn.Dropout(cfg.dropout)
+
+    def forward(self, x):
+        return self.drop(self.proj(F.gelu(self.fc(x))))
+
+
+class Block(nn.Module):
+    """Residual + LayerNorm wokół uwagi i MLP (L07: autostrada x + f(x))."""
+    def __init__(self, cfg: GPTConfig):
+        super().__init__()
+        self.ln1 = nn.LayerNorm(cfg.n_embd)
+        self.attn = CausalSelfAttention(cfg)
+        self.ln2 = nn.LayerNorm(cfg.n_embd)
+        self.mlp = MLP(cfg)
+
+    def forward(self, x):
+        x = x + self.attn(self.ln1(x))      # komunikacja MIĘDZY tokenami
+        x = x + self.mlp(self.ln2(x))       # przetwarzanie W tokenie
+        return x
+
+
+class GPT(nn.Module):
+    def __init__(self, cfg: GPTConfig):
+        super().__init__()
+        self.cfg = cfg
+        self.tok_emb = nn.Embedding(cfg.vocab_size, cfg.n_embd)   # ID -> wektor
+        self.pos_emb = nn.Embedding(cfg.block_size, cfg.n_embd)   # pozycja
+        self.drop = nn.Dropout(cfg.dropout)
+        self.blocks = nn.ModuleList([Block(cfg) for _ in range(cfg.n_layer)])
+        self.ln_f = nn.LayerNorm(cfg.n_embd)
+        self.head = nn.Linear(cfg.n_embd, cfg.vocab_size, bias=False)
+        self.head.weight = self.tok_emb.weight                   # weight tying
+        self.apply(self._init)
+
+    def _init(self, m):
+        if isinstance(m, (nn.Linear, nn.Embedding)):
+            nn.init.normal_(m.weight, mean=0.0, std=0.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.zeros_(m.bias)
+
+    def forward(self, idx, targets=None):
+        B, T = idx.shape
+        pos = torch.arange(T, device=idx.device)
+        x = self.drop(self.tok_emb(idx) + self.pos_emb(pos))
+        for blk in self.blocks:
+            x = blk(x)
+        logits = self.head(self.ln_f(x))
+        loss = None
+        if targets is not None:
+            # cross-entropy (L03): -log p(prawdziwego następnego znaku)
+            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
+        return logits, loss
+
+    @torch.no_grad()
+    def generate(self, idx, max_new_tokens, temperature=0.8, top_k=None):
+        for _ in range(max_new_tokens):
+            idx_cond = idx[:, -self.cfg.block_size:]      # przytnij do okna
+            logits, _ = self(idx_cond)
+            logits = logits[:, -1, :] / temperature
+            if top_k is not None:
+                v, _ = torch.topk(logits, top_k)
+                logits[logits < v[:, [-1]]] = float("-inf")
+            probs = F.softmax(logits, dim=-1)
+            nxt = torch.multinomial(probs, num_samples=1)
+            idx = torch.cat((idx, nxt), dim=1)
+        return idx
+
+    def num_params(self):
+        return sum(p.numel() for p in self.parameters())

src/make_midi.py

@@ -0,0 +1,61 @@
+"""JEDNO POLECENIE: użyj wytrenowanego GPT, by stworzyć nowe melodie + pliki MIDI.
+
+Przykłady:
+  python src/make_midi.py                      # 3 melodie w D, do data/out_*.mid
+  python src/make_midi.py --key G --n 5         # 5 melodii w G
+  python src/make_midi.py --temp 1.0 --out data/eksperyment
+"""
+import argparse, sys
+import torch
+from gpt import GPT
+from abc_to_midi import to_midi          # konwersja ABC -> MIDI (music21)
+
+
+def first_tune(raw: str) -> str:
+    """Wytnij pierwszą melodię (nagłówek + ciało aż do kolejnego 'X:')."""
+    lines = []
+    for ln in raw.split("\n"):
+        if ln.startswith("X:") and lines:
+            break
+        lines.append(ln)
+    return "\n".join(lines).strip()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--key",  default="D",   help="tonacja, np. D, G, Am, Edor")
+    ap.add_argument("--n",    type=int,   default=3,   help="ile melodii")
+    ap.add_argument("--temp", type=float, default=0.8, help="temperatura (więcej = śmielej)")
+    ap.add_argument("--topk", type=int,   default=20)
+    ap.add_argument("--new",  type=int,   default=400, help="ile znaków generować na melodię")
+    ap.add_argument("--ckpt", default="data/gpt_ckpt.pt")
+    ap.add_argument("--out",  default="data/out", help="prefiks plików wyjściowych")
+    args = ap.parse_args()
+    sys.stdout.reconfigure(encoding="utf-8")
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    ck = torch.load(args.ckpt, map_location=device, weights_only=False)
+    stoi, itos, cfg = ck["stoi"], ck["itos"], ck["config"]
+    model = GPT(cfg).to(device)
+    model.load_state_dict(ck["model"])
+    model.eval()
+    print(f"GPT {model.num_params():,} param | val loss {ck['val_loss']:.3f} | {device}")
+
+    seed = f"X:1\nM:6/8\nK:{args.key}\n"
+    made = 0
+    for i in range(1, args.n + 1):
+        idx = torch.tensor([[stoi[c] for c in seed]], dtype=torch.long, device=device)
+        out = model.generate(idx, args.new, temperature=args.temp, top_k=args.topk)[0].tolist()
+        tune = first_tune("".join(itos[t] for t in out))
+        abc_path, mid_path = f"{args.out}_{i}.abc", f"{args.out}_{i}.mid"
+        with open(abc_path, "w", encoding="utf-8") as f:
+            f.write(tune + "\n")
+        ok = to_midi(tune, mid_path)
+        made += int(ok)
+        print(f"\n--- #{i}  [{'MIDI OK -> '+mid_path if ok else 'MIDI błąd'}] ---\n{tune}")
+
+    print(f"\nGotowe: {made}/{args.n} plików MIDI ({args.out}_*.mid)")
+
+
+if __name__ == "__main__":
+    main()

src/ngram_model.py

@@ -0,0 +1,62 @@
+"""Baseline: char-level n-gram z backoffem (czysty Python, bez bibliotek).
+Uczy się 'następny znak' z korpusu ABC i generuje nowe jigi.
+To samo zadanie co LLM (next-token), tu na znakach i bez sieci neuronowej.
+"""
+import random, sys, collections
+
+ORDER = 6                      # ile znaków kontekstu (max)
+CTX = list(range(ORDER, -1, -1))  # [6,5,4,3,2,1,0] — backoff od najdłuższego
+
+def train(text):
+    models = {c: collections.defaultdict(collections.Counter) for c in CTX}
+    for i, ch in enumerate(text):
+        for c in CTX:
+            ctx = text[i - c:i] if c <= i else None
+            if ctx is None and c != 0:
+                continue
+            models[c][text[i - c:i]][ch] += 1
+    return models
+
+def sample_next(models, history, temp):
+    for c in CTX:                          # backoff: najdłuższy znaleziony kontekst
+        ctx = history[-c:] if c > 0 else ""
+        counter = models[c].get(ctx)
+        if counter:
+            chars = list(counter)
+            weights = [counter[ch] ** (1.0 / temp) for ch in chars]
+            return random.choices(chars, weights=weights)[0]
+    return "\n"
+
+def generate(models, seed, temp=0.8, maxlen=600, minbody=90):
+    out = seed
+    while len(out) < maxlen:
+        ch = sample_next(models, out, temp)
+        out += ch
+        body = out[len(seed):]
+        if out.endswith("\n\n") and len(body) >= minbody:  # koniec melodii
+            break
+    return out.strip()
+
+def main():
+    sys.stdout.reconfigure(encoding="utf-8")
+    text = open("data/jigs.abc", encoding="utf-8").read()
+    print(f"trenuję n-gram (order={ORDER}) na {len(text):,} znakach…")
+    models = train(text)
+    print("gotowe. Konteksty na poziom:",
+          {c: len(models[c]) for c in CTX})
+
+    seed = "X:1\nM:6/8\nK:D\n"
+    random.seed(20260620)
+    outs = []
+    for i in range(3):
+        tune = generate(models, seed, temp=0.7)
+        outs.append(tune)
+        print(f"\n========== WYGENEROWANY JIG #{i+1} ==========")
+        print(tune)
+
+    with open("data/generated.abc", "w", encoding="utf-8") as f:
+        f.write("\n\n".join(outs) + "\n")
+    print("\n[zapisano do data/generated.abc]")
+
+if __name__ == "__main__":
+    main()

src/prepare_bach.py

@@ -0,0 +1,83 @@
+"""Monofoniczny korpus Bacha (ABC) z linii SOPRANU chorałów (music21, lokalnie).
+Chorały są 4-głosowe (SATB) — bierzemy TYLKO sopran => monofonia, zgodna z kontraktem.
+Własny enkoder mono->ABC (music21 nie umie pisać ABC); słownik zgodny z jigami.
+"""
+import sys, os
+from fractions import Fraction
+from music21 import corpus
+
+def pitch_to_abc(p):
+    step, octv = p.step, p.octave
+    acc = ""
+    if p.accidental is not None:
+        a = p.accidental.alter
+        acc = {1: "^", -1: "_", 0: "=", 2: "^^", -2: "__"}.get(int(a), "")
+    if octv >= 5:
+        return acc + step.lower() + "'" * (octv - 5)
+    return acc + step.upper() + "," * (4 - octv)
+
+def dur_to_abc(ql):
+    units = Fraction(ql).limit_denominator(8) / Fraction(1, 2)  # L:1/8 => ósemka=1
+    if units == 1: return ""
+    if units.denominator == 1: return str(units.numerator)
+    if units.numerator == 1: return "/" + str(units.denominator)
+    return f"{units.numerator}/{units.denominator}"
+
+def chorale_to_abc(score):
+    sop = score.parts[0]
+    # tonacja z sygnatury (szybciej niż analyze)
+    kname = "C"
+    ks = sop.recurse().getElementsByClass('KeySignature')
+    if ks:
+        try:
+            k = ks[0].asKey()
+            kname = k.tonic.name.replace('-', 'b') + ("" if k.mode == "major" else "m")
+        except Exception:
+            pass
+    meter = "4/4"
+    ts = sop.recurse().getElementsByClass('TimeSignature')
+    if ts:
+        meter = ts[0].ratioString
+    toks = []
+    for m in sop.getElementsByClass('Measure'):
+        for el in m.notesAndRests:
+            if el.isRest:
+                toks.append("z" + dur_to_abc(el.quarterLength))
+            elif el.isChord:
+                top = max(el.notes, key=lambda x: x.pitch.midi)
+                toks.append(pitch_to_abc(top.pitch) + dur_to_abc(el.quarterLength))
+            else:
+                toks.append(pitch_to_abc(el.pitch) + dur_to_abc(el.quarterLength))
+        toks.append("|")
+    return f"X:1\nM:{meter}\nL:1/8\nK:{kname}\n" + " ".join(toks)
+
+def main():
+    sys.stdout.reconfigure(encoding="utf-8")
+    paths = corpus.getComposer('bach')
+    blocks, n = [], 0
+    for p in paths:
+        n += 1
+        try:
+            sc = corpus.parse(p)
+            if len(sc.parts) < 1:
+                continue
+            abc = chorale_to_abc(sc)
+            if 40 < len(abc) < 2500 and abc.count("|") >= 4:
+                blocks.append(abc)
+        except Exception:
+            continue
+        if len(blocks) >= 350:
+            break
+    text = "\n\n".join(blocks)
+    os.makedirs("data/corpus", exist_ok=True)
+    with open("data/corpus/bach.abc", "w", encoding="utf-8") as f:
+        f.write(text)
+    vocab = sorted(set(text))
+    print(f"przetworzono plików: {n} | zachowanych bloków (sopran): {len(blocks)}")
+    print(f"znaki: {len(text):,} | słownik: {len(vocab)}")
+    print("słownik:", repr("".join(vocab)))
+    print("\n--- pierwszy blok ---")
+    print(blocks[0] if blocks else "BRAK")
+
+if __name__ == "__main__":
+    main()

src/prepare_data.py

@@ -0,0 +1,69 @@
+"""Przygotowanie korpusu ABC z thesession.org tunes.csv.
+Filtr: typ + metrum z argumentów (domyślnie jigi 6/8). Buduje grające bloki ABC + normalizuje tonację.
+Użycie: python src/prepare_data.py [typ] [metrum] [wyjście]
+  np. python src/prepare_data.py waltz 3/4 data/corpus/waltz.abc
+"""
+import csv, re, sys, os
+csv.field_size_limit(10**7)
+
+TYPE_KW = sys.argv[1] if len(sys.argv) > 1 else "jig"
+METER   = sys.argv[2] if len(sys.argv) > 2 else "6/8"
+OUT     = sys.argv[3] if len(sys.argv) > 3 else "data/jigs.abc"
+
+MODE_TABLE = {
+    "major": "", "ionian": "", "minor": "min", "aeolian": "min",
+    "dorian": "dor", "mixolydian": "mix", "phrygian": "phr",
+    "lydian": "lyd", "locrian": "loc", "": "",
+}
+
+def norm_key(mode: str) -> str:
+    m = re.match(r"^([A-Ga-g][#b]?)(.*)$", mode.strip())
+    if not m:
+        return "C"
+    root, word = m.group(1), m.group(2).lower()
+    return root + MODE_TABLE.get(word, "")
+
+ALLOWED = set("ABCDEFGabcdefg0123456789|:[]()<>/'^_=.,~- zZxX")
+
+def clean_abc(body: str) -> str:
+    body = body.replace("\r\n", "\n").replace("\r", "\n").strip()
+    body = re.sub(r'"[^"]*"', "", body)       # usuń symbole akordów / adnotacje "..."
+    body = re.sub(r"[ \t]+", " ", body)        # scal podwójne spacje po usunięciu
+    body = re.sub(r"\n+", "\n", body)
+    return body
+
+def main():
+    rows_out, n_total, n_kept = [], 0, 0
+    with open("data/tunes.csv", encoding="utf-8", newline="") as f:
+        for row in csv.DictReader(f):
+            n_total += 1
+            if TYPE_KW not in row["type"].lower():
+                continue
+            if row["meter"].strip() != METER:
+                continue
+            body = clean_abc(row["abc"])
+            if not (40 <= len(body) <= 700):
+                continue
+            if any(ch not in ALLOWED for ch in body.replace("\n", "")):
+                continue
+            key = norm_key(row["mode"])
+            block = f"X:1\nM:{METER}\nK:{key}\n{body}\n"
+            rows_out.append(block)
+            n_kept += 1
+
+    text = "\n".join(rows_out)
+    os.makedirs(os.path.dirname(OUT) or ".", exist_ok=True)
+    with open(OUT, "w", encoding="utf-8") as f:
+        f.write(text)
+
+    vocab = sorted(set(text))
+    sys.stdout.reconfigure(encoding="utf-8")
+    print(f"melodii w pliku        : {n_total}")
+    print(f"{TYPE_KW} ({METER}) zachowane: {n_kept}")
+    print(f"znaki łącznie          : {len(text):,}")
+    print(f"słownik ({len(vocab)})        : {''.join(vocab)!r}")
+    print("\n--- pierwszy blok ---")
+    print(rows_out[0] if rows_out else "BRAK")
+
+if __name__ == "__main__":
+    main()

src/sample_gpt.py

@@ -0,0 +1,37 @@
+"""Generacja melodii z wytrenowanego GPT (wczytuje checkpoint)."""
+import sys
+import torch
+from gpt import GPT
+
+sys.stdout.reconfigure(encoding="utf-8")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+ck = torch.load("data/gpt_ckpt.pt", map_location=device, weights_only=False)
+stoi, itos, cfg = ck["stoi"], ck["itos"], ck["config"]
+
+model = GPT(cfg).to(device)
+model.load_state_dict(ck["model"])
+model.eval()
+print(f"wczytano GPT ({model.num_params():,} param) | val loss {ck['val_loss']:.3f}")
+
+def gen(seed, n_new=400, temp=0.8, top_k=20):
+    idx = torch.tensor([[stoi[c] for c in seed]], dtype=torch.long, device=device)
+    out = model.generate(idx, n_new, temperature=temp, top_k=top_k)[0].tolist()
+    return "".join(itos[i] for i in out)
+
+seed = "X:1\nM:6/8\nK:D\n"
+raw = gen(seed, n_new=500, temp=0.8, top_k=20)
+# potnij na osobne melodie po pustej linii
+tunes, cur = [], []
+for line in raw.split("\n"):
+    if line.startswith("X:") and cur:
+        tunes.append("\n".join(cur)); cur = []
+    cur.append(line)
+if cur:
+    tunes.append("\n".join(cur))
+tunes = [t.strip() for t in tunes if "X:" in t][:5]
+
+for i, t in enumerate(tunes, 1):
+    print(f"\n===== GPT JIG #{i} =====\n{t}")
+with open("data/generated_gpt.abc", "w", encoding="utf-8") as f:
+    f.write("\n\n".join(tunes) + "\n")
+print("\n[zapisano -> data/generated_gpt.abc]")

src/train_gpt.py

@@ -0,0 +1,115 @@
+"""Trening GPT od zera na korpusie ABC (L03/L08 w praktyce).
+Batche -> strata cross-entropy -> backprop -> AdamW -> val loss -> checkpoint.
+"""
+import os, time, math, sys
+from contextlib import nullcontext
+import torch
+from gpt import GPT, GPTConfig
+
+# --- hiperparametry ---
+block_size  = 128
+batch_size  = 32
+n_layer     = 4
+n_head      = 4
+n_embd      = 128
+dropout     = 0.1
+lr          = 3e-4
+max_iters   = 2000
+eval_interval = 200
+eval_iters  = 100
+warmup      = 100
+
+torch.manual_seed(20260620)
+device = "cuda" if torch.cuda.is_available() else "cpu"
+use_bf16 = device == "cuda" and torch.cuda.is_bf16_supported()
+ctx = torch.autocast(device_type="cuda", dtype=torch.bfloat16) if use_bf16 else nullcontext()
+sys.stdout.reconfigure(encoding="utf-8")
+print(f"urządzenie: {device} | bf16: {use_bf16}")
+
+# --- ścieżki z argumentów (domyślnie: jigi) ---
+DATA    = sys.argv[1] if len(sys.argv) > 1 else "data/jigs.abc"
+CKPT    = sys.argv[2] if len(sys.argv) > 2 else "data/gpt_ckpt.pt"
+LOSSLOG = sys.argv[3] if len(sys.argv) > 3 else "data/loss_log.csv"
+VOCAB_FROM = sys.argv[4] if len(sys.argv) > 4 else None   # wspólny słownik z innego ckpt (do stitchu)
+print(f"dane: {DATA} -> checkpoint: {CKPT}")
+
+# --- dane: char-level ---
+text = open(DATA, encoding="utf-8").read()
+if VOCAB_FROM:
+    vck = torch.load(VOCAB_FROM, map_location="cpu", weights_only=False)
+    stoi, itos = vck["stoi"], vck["itos"]
+    chars = [itos[i] for i in range(len(itos))]
+    print(f"wspólny słownik z {VOCAB_FROM}: {len(chars)} znaków")
+else:
+    chars = sorted(set(text))
+    stoi = {c: i for i, c in enumerate(chars)}
+    itos = {i: c for i, c in enumerate(chars)}
+data = torch.tensor([stoi[c] for c in text], dtype=torch.long)
+n = int(0.9 * len(data))
+train_data, val_data = data[:n], data[n:]
+print(f"słownik: {len(chars)} | tokeny: train {len(train_data):,} / val {len(val_data):,}")
+
+def get_batch(split):
+    d = train_data if split == "train" else val_data
+    ix = torch.randint(len(d) - block_size, (batch_size,))
+    x = torch.stack([d[i:i+block_size] for i in ix])
+    y = torch.stack([d[i+1:i+1+block_size] for i in ix])
+    return x.to(device), y.to(device)
+
+@torch.no_grad()
+def estimate_loss():
+    model.eval()
+    out = {}
+    for split in ("train", "val"):
+        losses = torch.zeros(eval_iters)
+        for k in range(eval_iters):
+            x, y = get_batch(split)
+            with ctx:
+                _, loss = model(x, y)
+            losses[k] = loss.item()
+        out[split] = losses.mean().item()
+    model.train()
+    return out
+
+def lr_at(it):  # warmup + cosine decay (L08)
+    if it < warmup:
+        return lr * it / warmup
+    r = (it - warmup) / (max_iters - warmup)
+    return lr * 0.1 + 0.5 * lr * 0.9 * (1 + math.cos(math.pi * r))
+
+cfg = GPTConfig(vocab_size=len(chars), block_size=block_size,
+                n_layer=n_layer, n_head=n_head, n_embd=n_embd, dropout=dropout)
+model = GPT(cfg).to(device)
+print(f"parametry modelu: {model.num_params():,}")
+opt = torch.optim.AdamW(model.parameters(), lr=lr, betas=(0.9, 0.99), weight_decay=0.1)
+
+best_val = float("inf")
+log = [("iter", "train_loss", "val_loss")]
+t0 = time.time()
+for it in range(max_iters + 1):
+    if it % eval_interval == 0 or it == max_iters:
+        L = estimate_loss()
+        ppl = math.exp(L["val"])
+        print(f"iter {it:4d} | train {L['train']:.3f} | val {L['val']:.3f} | ppl {ppl:.2f} | {time.time()-t0:.0f}s")
+        log.append((it, round(L["train"], 4), round(L["val"], 4)))
+        if L["val"] < best_val:           # zapis najlepszego (early-stop logic)
+            best_val = L["val"]
+            torch.save({"model": model.state_dict(), "config": cfg,
+                        "stoi": stoi, "itos": itos, "val_loss": best_val},
+                       CKPT)
+    if it == max_iters:
+        break
+    for g in opt.param_groups:
+        g["lr"] = lr_at(it)
+    x, y = get_batch("train")
+    with ctx:
+        _, loss = model(x, y)
+    opt.zero_grad(set_to_none=True)
+    loss.backward()
+    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+    opt.step()
+
+with open(LOSSLOG, "w", encoding="utf-8") as f:
+    f.write("\n".join(",".join(map(str, row)) for row in log))
+print(f"\ngotowe. best val loss: {best_val:.3f} (ppl {math.exp(best_val):.2f})")
+print(f"checkpoint -> {CKPT} | krzywa -> {LOSSLOG}")

src/upload_hf.py

@@ -0,0 +1,33 @@
+"""Upload paczki modelu na Hugging Face Hub.
+Wymaga wcześniejszego `huggingface-cli login`. Uruchom z katalogu repo:
+    python src/upload_hf.py Maggio33/slay-piano-gpt
+"""
+import sys
+from huggingface_hub import HfApi, create_repo
+
+IGNORE = [
+    "data/tunes.csv", "data/jigs.abc", "data/gpt_ckpt_v1_dirty.pt",
+    "data/_test_chord.mid", "data/generated*.abc",
+    "data/demo_*.mid", "data/clean_*.mid", "data/gpt_jig_*.mid",
+    "data/jig_*.mid", "data/out_*.*",
+    "**/__pycache__/**", "*.pyc",
+]
+
+def main():
+    repo_id = sys.argv[1] if len(sys.argv) > 1 else "Maggio33/slay-piano-gpt"
+    api = HfApi()
+    who = api.whoami()
+    print("zalogowany jako:", who.get("name"))
+    create_repo(repo_id, repo_type="model", exist_ok=True, private=False)
+    print(f"repo gotowe: {repo_id} — wysyłam pliki…")
+    api.upload_folder(
+        folder_path=".",
+        repo_id=repo_id,
+        repo_type="model",
+        ignore_patterns=IGNORE,
+        commit_message="Initial: slay-piano-gpt (0.82M char-level GPT, jigs ABC)",
+    )
+    print(f"\nGOTOWE -> https://huggingface.co/{repo_id}")
+
+if __name__ == "__main__":
+    main()