genai-spit 1.0.0__tar.gz

genai_spit-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Amey Jagannath Sonvadkar
+
+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.

genai_spit-1.0.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: genai-spit
+Version: 1.0.0
+Summary: 9 Generative-AI lab experiments (VAE, GAN, text generation, text-to-image, DeepFake AE, music, CycleGAN, chatbot, diffusion) that run offline without pretrained models
+Author: Amey Jagannath Sonvadkar
+License: MIT
+Keywords: generative-ai,vae,gan,diffusion,cyclegan,education
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Provides-Extra: all
+Requires-Dist: torch; extra == "all"
+Requires-Dist: matplotlib; extra == "all"
+Requires-Dist: scikit-learn; extra == "all"
+Provides-Extra: mnist
+Requires-Dist: torch; extra == "mnist"
+Requires-Dist: torchvision; extra == "mnist"
+Dynamic: license-file
+
+# genai-spit
+
+9 Generative-AI lab experiments that run **offline, without pretrained models or downloaded datasets** (every experiment creates its own data). For each one you can read the **title, theory and full Python source**, save it, run it, and create its datasets.
+
+## Install
+
+```bash
+pip install --upgrade "genai-spit[all]"        # with torch, matplotlib, scikit-learn
+pip install --upgrade genai-spit               # code + theory only
+```
+Colab / Jupyter: `!pip install --upgrade "genai-spit[all]"`
+
+## Command line
+
+```bash
+genai-spit --list                          # list the 9 experiments
+genai-spit --show chatbot                  # title + theory + full source
+genai-spit --theory vae                    # only theory
+genai-spit --code diffusion                # only code
+genai-spit --save cyclegan --out cyclegan.py
+genai-spit --save-all --out genai_code     # all 9 (.py, .txt, theory)
+genai-spit --data --out genai_data         # create all datasets
+genai-spit --all --out genai_all           # code + theory + datasets in one folder
+genai-spit --all --mnist                   # + MNIST (internet)
+genai-spit --run gan                       # run an experiment
+```
+
+## Python
+
+```python
+from genai_spit import list_experiments, show_experiment, get_source, save_experiment, run_experiment, download_all
+
+list_experiments()
+show_experiment("chatbot")        # title, theory, then the full Python source
+code = get_source("diffusion")
+save_experiment("vae", "vae.py")
+run_experiment("cyclegan")
+download_all("genai_all")
+```
+
+## Experiments
+
+| # | Name (aliases) | Experiment |
+|---|---|---|
+| 1 | `vae` (autoencoder) | Autoencoder + Variational Autoencoder |
+| 2 | `gan` | Basic GAN |
+| 3 | `text_generation` (gpt2) | Tokenization, embedding, pre-train + fine-tune, temperature / top-k / top-p |
+| 4 | `text_to_image` (dalle) | Text-to-image with a conditional VAE |
+| 5 | `deepfake` (faceswap) | Shared encoder + two decoders, reconstruction analysis |
+| 6 | `music` (jukebox) | Markov-chain music → WAV, waveform, spectrogram |
+| 7 | `cyclegan` | Unpaired style transfer |
+| 8 | `chatbot` | TF-IDF retrieval chatbot with context and exit loop |
+| 9 | `diffusion` (ddpm) | DDPM, noise schedules, guided generation |
+
+Source files: `src/genai_spit/experiments/*.py.txt`
+
+See **PUBLISHING.md** for how this package is built and uploaded to PyPI.
+
+## License
+MIT

genai_spit-1.0.0/README.md

@@ -0,0 +1,60 @@
+# genai-spit
+
+9 Generative-AI lab experiments that run **offline, without pretrained models or downloaded datasets** (every experiment creates its own data). For each one you can read the **title, theory and full Python source**, save it, run it, and create its datasets.
+
+## Install
+
+```bash
+pip install --upgrade "genai-spit[all]"        # with torch, matplotlib, scikit-learn
+pip install --upgrade genai-spit               # code + theory only
+```
+Colab / Jupyter: `!pip install --upgrade "genai-spit[all]"`
+
+## Command line
+
+```bash
+genai-spit --list                          # list the 9 experiments
+genai-spit --show chatbot                  # title + theory + full source
+genai-spit --theory vae                    # only theory
+genai-spit --code diffusion                # only code
+genai-spit --save cyclegan --out cyclegan.py
+genai-spit --save-all --out genai_code     # all 9 (.py, .txt, theory)
+genai-spit --data --out genai_data         # create all datasets
+genai-spit --all --out genai_all           # code + theory + datasets in one folder
+genai-spit --all --mnist                   # + MNIST (internet)
+genai-spit --run gan                       # run an experiment
+```
+
+## Python
+
+```python
+from genai_spit import list_experiments, show_experiment, get_source, save_experiment, run_experiment, download_all
+
+list_experiments()
+show_experiment("chatbot")        # title, theory, then the full Python source
+code = get_source("diffusion")
+save_experiment("vae", "vae.py")
+run_experiment("cyclegan")
+download_all("genai_all")
+```
+
+## Experiments
+
+| # | Name (aliases) | Experiment |
+|---|---|---|
+| 1 | `vae` (autoencoder) | Autoencoder + Variational Autoencoder |
+| 2 | `gan` | Basic GAN |
+| 3 | `text_generation` (gpt2) | Tokenization, embedding, pre-train + fine-tune, temperature / top-k / top-p |
+| 4 | `text_to_image` (dalle) | Text-to-image with a conditional VAE |
+| 5 | `deepfake` (faceswap) | Shared encoder + two decoders, reconstruction analysis |
+| 6 | `music` (jukebox) | Markov-chain music → WAV, waveform, spectrogram |
+| 7 | `cyclegan` | Unpaired style transfer |
+| 8 | `chatbot` | TF-IDF retrieval chatbot with context and exit loop |
+| 9 | `diffusion` (ddpm) | DDPM, noise schedules, guided generation |
+
+Source files: `src/genai_spit/experiments/*.py.txt`
+
+See **PUBLISHING.md** for how this package is built and uploaded to PyPI.
+
+## License
+MIT

genai_spit-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "genai-spit"
+version = "1.0.0"
+description = "9 Generative-AI lab experiments (VAE, GAN, text generation, text-to-image, DeepFake AE, music, CycleGAN, chatbot, diffusion) that run offline without pretrained models"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "Amey Jagannath Sonvadkar"}]
+keywords = ["generative-ai", "vae", "gan", "diffusion", "cyclegan", "education"]
+dependencies = ["numpy"]
+
+[project.optional-dependencies]
+all = ["torch", "matplotlib", "scikit-learn"]
+mnist = ["torch", "torchvision"]
+
+[project.scripts]
+genai-spit = "genai_spit.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+genai_spit = ["experiments/*.json", "experiments/*.txt"]

genai_spit-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

genai_spit-1.0.0/src/genai_spit/__init__.py

@@ -0,0 +1,68 @@
+"""genai-spit — 9 Generative-AI lab experiments (offline, no pretrained models).
+
+>>> from genai_spit import list_experiments, show_experiment
+>>> list_experiments()
+>>> show_experiment("chatbot")        # title, theory, then the full Python source
+"""
+import json, runpy, tempfile
+from importlib import resources
+from pathlib import Path
+
+__version__ = "1.0.0"
+_CAT = json.loads(resources.files("genai_spit").joinpath("experiments", "catalog.json").read_text(encoding="utf-8"))
+
+def _find(name):
+    q = str(name).lower().replace("-", "_").replace(" ", "_")
+    for e in _CAT:
+        if q in (e["key"], str(e["number"])) or q in e["aliases"]:
+            return e
+    raise ValueError(f"unknown experiment '{name}'. Choose from: " + ", ".join(e["key"] for e in _CAT))
+
+def list_experiments():
+    """Print number, name and title of the 9 experiments."""
+    for e in _CAT:
+        print(f"{e['number']}. {e['key']:<16} {e['title']}")
+
+def get_source(name):
+    """Full Python source of an experiment (str)."""
+    return resources.files("genai_spit").joinpath("experiments", _find(name)["file"]).read_text(encoding="utf-8")
+
+def get_theory(name):
+    return _find(name)["theory"]
+
+def show_experiment(name, theory=True, source=True):
+    """Print title, theory and full Python source."""
+    e = _find(name); bar = "=" * 90
+    print(f"{bar}\nExperiment {e['number']}: {e['title']}\n{bar}")
+    if theory: print("\nTHEORY\n------\n" + e["theory"] + "\n")
+    if source: print("SOURCE\n------\n" + get_source(name))
+
+def save_experiment(name, path=None):
+    """Save the source of one experiment as a .py (or .txt) file."""
+    e = _find(name); path = Path(path or f"{e['key']}.py")
+    path.write_text(get_source(name), encoding="utf-8"); return path
+
+def save_all(folder="genai_code"):
+    """Save all 9 experiments as .py, .txt and _theory.txt files."""
+    folder = Path(folder); folder.mkdir(parents=True, exist_ok=True)
+    for e in _CAT:
+        stem = f"{e['number']:02d}_{e['key']}"
+        save_experiment(e["key"], folder / f"{stem}.py"); save_experiment(e["key"], folder / f"{stem}.txt")
+        (folder / f"{stem}_theory.txt").write_text(f"{e['title']}\n\n{e['theory']}\n", encoding="utf-8")
+    return folder
+
+def run_experiment(name):
+    """Run an experiment as a normal Python script."""
+    with tempfile.TemporaryDirectory() as d:
+        runpy.run_path(str(save_experiment(name, Path(d) / "experiment.py")), run_name="__main__")
+
+def download_data(folder="genai_data", mnist=False):
+    """Create every dataset used by the experiments (mnist=True also downloads MNIST, needs internet)."""
+    from . import datasets
+    return datasets.save_all(folder, mnist=mnist)
+
+def download_all(folder="genai_all", mnist=False):
+    """Everything in one call: code + theory + datasets."""
+    folder = Path(folder)
+    save_all(folder / "code"); download_data(folder / "data", mnist=mnist)
+    print(f"Everything saved in: {folder.resolve()}"); return folder

genai_spit-1.0.0/src/genai_spit/cli.py

@@ -0,0 +1,32 @@
+"""genai-spit [options]"""
+import argparse, sys
+import genai_spit as g
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="genai-spit", description="9 Generative-AI lab experiments (offline, no pretrained models)")
+    p.add_argument("--list", action="store_true", help="list the experiments")
+    p.add_argument("--show", metavar="NAME", help="print title, theory and source (name or number)")
+    p.add_argument("--theory", metavar="NAME", help="print only the theory")
+    p.add_argument("--code", metavar="NAME", help="print only the source code")
+    p.add_argument("--save", metavar="NAME", help="save one experiment as a .py file")
+    p.add_argument("--save-all", action="store_true", help="save all experiments")
+    p.add_argument("--data", action="store_true", help="create all datasets")
+    p.add_argument("--all", action="store_true", help="code + theory + datasets in one folder")
+    p.add_argument("--mnist", action="store_true", help="with --data / --all: also download MNIST (internet)")
+    p.add_argument("--run", metavar="NAME", help="run an experiment")
+    p.add_argument("--out", metavar="PATH", help="output file / folder")
+    a = p.parse_args(argv)
+    did = False
+    if a.list: g.list_experiments(); did = True
+    if a.show: g.show_experiment(a.show); did = True
+    if a.theory: g.show_experiment(a.theory, source=False); did = True
+    if a.code: print(g.get_source(a.code)); did = True
+    if a.save: print("saved", g.save_experiment(a.save, a.out)); did = True
+    if a.save_all: print("saved in", g.save_all(a.out or "genai_code")); did = True
+    if a.data: g.download_data(a.out or "genai_data", mnist=a.mnist); did = True
+    if a.all: g.download_all(a.out or "genai_all", mnist=a.mnist); did = True
+    if a.run: g.run_experiment(a.run); did = True
+    if not did: g.list_experiments()
+
+if __name__ == "__main__":
+    main()

genai_spit-1.0.0/src/genai_spit/datasets.py

@@ -0,0 +1,116 @@
+"""Dataset generators used by the 9 experiments (all offline), plus optional standard datasets."""
+import json
+from pathlib import Path
+import numpy as np
+
+# ---------------- Exp 1, 2: shapes ----------------
+def shapes(n=3000, size=16, seed=0):
+    rng = np.random.default_rng(seed); yy, xx = np.mgrid[0:size, 0:size]
+    X = np.zeros((n, size, size), np.float32); y = rng.integers(0, 3, n)
+    for i in range(n):
+        r = rng.uniform(3, 5); cx, cy = rng.uniform(r, size - r, 2)
+        if y[i] == 0:   m = (xx - cx)**2 + (yy - cy)**2 <= r*r
+        elif y[i] == 1: m = (abs(xx - cx) <= 0.8*r) & (abs(yy - cy) <= 0.8*r)
+        else:           m = ((abs(xx - cx) <= 0.3*r) & (abs(yy - cy) <= r)) | ((abs(yy - cy) <= 0.3*r) & (abs(xx - cx) <= r))
+        X[i][m] = 1.0
+    return X, y
+
+# ---------------- Exp 4: coloured shapes with captions ----------------
+def coloured_shapes(n=6000, size=16, seed=0):
+    SH, CO, SI = ["circle", "square", "plus"], ["red", "green", "blue"], ["small", "big"]
+    rng = np.random.default_rng(seed); yy, xx = np.mgrid[0:size, 0:size]; imgs, caps = [], []
+    for _ in range(n):
+        sh, co, si = rng.choice(SH), rng.choice(CO), rng.choice(SI)
+        r = rng.uniform(2.5, 3.5) if si == "small" else rng.uniform(4.5, 5.5); cx, cy = rng.uniform(r, size - r, 2)
+        if sh == "circle":   m = (xx-cx)**2 + (yy-cy)**2 <= r*r
+        elif sh == "square": m = (abs(xx-cx) <= 0.8*r) & (abs(yy-cy) <= 0.8*r)
+        else:                m = ((abs(xx-cx) <= 0.3*r) & (abs(yy-cy) <= r)) | ((abs(yy-cy) <= 0.3*r) & (abs(xx-cx) <= r))
+        img = np.zeros((size, size, 3), np.float32); img[m, CO.index(co)] = 1.0
+        imgs.append(img); caps.append(f"{si} {co} {sh}")
+    return np.stack(imgs), np.array(caps)
+
+# ---------------- Exp 5: two synthetic people ----------------
+def face(person, expr, pose, S=24):
+    yy, xx = np.mgrid[0:S, 0:S]; img = np.zeros((S, S), np.float32); cx, cy = 12, 12
+    skin = (xx-cx)**2 + (yy-cy)**2 <= 100 if person == "A" else (abs(xx-cx) <= 9) & (abs(yy-cy) <= 10)
+    img[skin] = 0.8; fx = cx + pose; er = 1.2 if person == "A" else 2.0
+    for ex in (fx - 4, fx + 4): img[(xx-ex)**2 + (yy-9)**2 <= er**2] = 0.05
+    if person == "B":
+        img[(abs(yy-6) <= 0.6) & (abs(xx-fx) <= 7) & (abs(xx-fx) >= 1.5)] = 0.05; img[skin & (yy >= 18)] = 0.35
+    mouth_y = 16 - expr * 0.12 * (xx-fx)**2 + expr * 1.5
+    img[(abs(yy-mouth_y) <= 0.7) & (abs(xx-fx) <= 4)] = 0.05
+    return img
+
+def faces(person, n=1500, seed=1):
+    rng = np.random.default_rng(seed); P = np.c_[rng.uniform(-1, 1, n), rng.uniform(-3, 3, n)]
+    return np.stack([face(person, e, p) for e, p in P]), P
+
+# ---------------- Exp 7: light / dark domains (unpaired) ----------------
+def light_dark(n=2000, S=16, seed=1, style="light"):
+    rng = np.random.default_rng(seed); yy, xx = np.mgrid[0:S, 0:S]; out = []
+    for _ in range(n):
+        r = rng.uniform(4, 6.5); sh = rng.integers(2); cx, cy = rng.uniform(r, S - r, 2)
+        m = (xx-cx)**2 + (yy-cy)**2 <= r*r if sh == 0 else (abs(xx-cx) <= 0.85*r) & (abs(yy-cy) <= 0.85*r)
+        img = m.astype(np.float32); out.append(img if style == "light" else 1 - img)
+    return np.stack(out)
+
+# ---------------- Exp 9: 2-D data ----------------
+def two_moons(n=4000, noise=0.05, seed=0):
+    rng = np.random.default_rng(seed); t = rng.random(n) * np.pi; h = n // 2
+    X = np.r_[np.c_[np.cos(t[:h]), np.sin(t[:h])], np.c_[1 - np.cos(t[h:]), 0.5 - np.sin(t[h:])]] + rng.normal(0, noise, (n, 2))
+    return (X - X.mean(0)) / X.std(0)
+
+def three_clusters(n=3000, seed=0):
+    rng = np.random.default_rng(seed); C = np.array([[-2.0, 0.0], [2.0, 0.0], [0.0, 2.5]])
+    y = rng.integers(0, 3, n); return C[y] + 0.35 * rng.standard_normal((n, 2)), y
+
+# ---------------- Exp 3, 6, 8: text / music / chatbot data ----------------
+GENERAL_TEXT = ("the sun rises in the east and sets in the west. people walk to work in the morning.\n"
+                "children play in the park after school. the weather is cool and pleasant today.\n"
+                "we read books to learn new things. the market is busy in the evening. birds sing in the trees.\n"
+                "my friend likes to cook food at home. the train arrives at the station on time.\n")
+AI_TEXT = ("artificial intelligence is the science of making machines intelligent.\n"
+           "machine learning is a branch of artificial intelligence that learns patterns from data.\n"
+           "deep learning uses neural networks with many layers. a neural network learns by updating its weights.\n"
+           "generative models create new data such as text, images and music.\n"
+           "a language model predicts the next token in a sentence. transformers use attention to understand context.\n"
+           "training a model means reducing the loss on the training data.\n")
+MELODIES = {"classical": [60, 62, 64, 65, 67, 65, 64, 62, 60, 64, 67, 72, 71, 69, 67, 65, 64, 62, 64, 60,
+                          67, 69, 71, 72, 71, 69, 67, 65, 64, 65, 67, 64, 62, 60],
+            "jazz": [60, 63, 65, 66, 67, 70, 72, 70, 67, 66, 65, 63, 60, 63, 67, 70, 67, 65, 63, 65,
+                     66, 67, 63, 60, 70, 72, 75, 72, 70, 67, 63, 60]}
+CHATBOT_KB = {
+    "what is artificial intelligence": "Artificial intelligence is the science of making machines perform tasks that need human intelligence.",
+    "what is machine learning": "Machine learning lets computers learn patterns from data instead of being explicitly programmed.",
+    "what is deep learning": "Deep learning uses neural networks with many layers to learn features directly from data.",
+    "what is a gan generative adversarial network": "A GAN has a generator that makes fake data and a discriminator that tries to tell real from fake.",
+    "what is a vae variational autoencoder": "A VAE encodes data to a distribution in latent space and decodes samples from it.",
+    "what is a diffusion model": "A diffusion model adds noise step by step and learns to remove it to generate new samples.",
+}
+
+def save_all(folder="genai_ese_data", mnist=False):
+    """Create every dataset used by the 9 experiments and save it in `folder`."""
+    f = Path(folder); f.mkdir(parents=True, exist_ok=True)
+    X, y = shapes();                       np.savez_compressed(f / "exp1_exp2_shapes.npz", X=X, y=y)
+    X, c = coloured_shapes();              np.savez_compressed(f / "exp4_coloured_shapes.npz", X=X, captions=c)
+    (XA, PA), (XB, PB) = faces("A", seed=1), faces("B", seed=2)
+    np.savez_compressed(f / "exp5_faces_A_B.npz", XA=XA, params_A=PA, XB=XB, params_B=PB)
+    np.savez_compressed(f / "exp7_light_dark.npz", A=light_dark(seed=1, style="light"), B=light_dark(seed=2, style="dark"))
+    X3, y3 = three_clusters()
+    np.savez_compressed(f / "exp9_2d_data.npz", two_moons=two_moons(), clusters=X3, cluster_labels=y3)
+    (f / "exp3_general_text.txt").write_text(GENERAL_TEXT); (f / "exp3_ai_text.txt").write_text(AI_TEXT)
+    (f / "exp6_melodies.json").write_text(json.dumps(MELODIES, indent=1))
+    (f / "exp8_chatbot_kb.json").write_text(json.dumps(CHATBOT_KB, indent=1))
+    try:                                   # bundled inside scikit-learn, no internet needed
+        from sklearn.datasets import load_digits
+        d = load_digits(); np.savez_compressed(f / "sklearn_digits_8x8.npz", X=(d.images / 16).astype(np.float32), y=d.target)
+    except ImportError:
+        print("scikit-learn not installed: skipped sklearn digits")
+    if mnist:                              # standard dataset, needs internet
+        from torchvision import datasets as tvd
+        m = tvd.MNIST(str(f / "mnist_raw"), train=True, download=True)
+        np.savez_compressed(f / "mnist_train.npz", X=m.data.numpy(), y=m.targets.numpy())
+    for p in sorted(f.glob("*")):
+        if p.is_file(): print(f"  {p.name:<32} {p.stat().st_size/1024:8.1f} KB")
+    return f
+

genai_spit-1.0.0/src/genai_spit/experiments/catalog.json

@@ -0,0 +1,106 @@
+[
+ {
+  "number": 1,
+  "key": "vae",
+  "aliases": [
+   "autoencoder",
+   "ae",
+   "1"
+  ],
+  "title": "Autoencoder + Variational Autoencoder (VAE)",
+  "theory": "# ESE Practice — Exp 1: Autoencoder + Variational Autoencoder (VAE)\nNo pretrained model, no internet (default). Runs on CPU in about 1 minute.\n\nWhat to remember\n* AE: x → encoder → z → decoder → x̂, loss = reconstruction (BCE/MSE).\n* VAE: the encoder outputs μ and log σ²; reparameterization z = μ + σ·ε, with ε ~ N(0, 1).\n* VAE loss = reconstruction + KL, KL = −0.5 · Σ(1 + logσ² − μ² − σ²).\n* Generate: sample z ~ N(0, I) → decoder.\n\n## Dataset — 3 options (change DATA in the next cell)\nDATA =  |  What it is  |  Internet?\n\"shapes\" (default, exam-safe)  |  Images drawn with NumPy: circle / square / plus at random size and position  |  No\n\"digits\"  |  sklearn.datasets.load_digits(): 1,797 handwritten digits, 8×8, ships inside scikit-learn  |  No\n\"mnist\"  |  Standard MNIST 28×28 via torchvision  |  Yes\n\nThe rest of the code does not change: it only uses IMG (side length) and X (N × IMG × IMG, values 0–1).",
+  "file": "vae.py.txt"
+ },
+ {
+  "number": 2,
+  "key": "gan",
+  "aliases": [
+   "2"
+  ],
+  "title": "Basic GAN",
+  "theory": "# ESE Practice — Exp 2: Basic GAN\nNo pretrained model, no internet (default). Runs on CPU in about 1–2 minutes.\n\nWhat to remember\n* Generator G: noise z → fake image (tanh output, so real images are scaled to −1…1).\n* Discriminator D: image → probability of being real (here a logit, used with BCEWithLogitsLoss).\n* D step: real → label 1, fake → label 0. G step: fake → label 1 (fool D). Use fake.detach() in the D step.\n* Equilibrium: D(x) ≈ D(G(z)) ≈ 0.5, L_D ≈ 1.386, L_G ≈ 0.693. Mode collapse: all samples look alike.\n\n## Dataset — 3 options (change DATA in the next cell)\nDATA =  |  What it is  |  Internet?\n\"shapes\" (default, exam-safe)  |  Images drawn with NumPy: circle / square / plus at random size and position  |  No\n\"digits\"  |  sklearn.datasets.load_digits(): 1,797 handwritten digits, 8×8, ships inside scikit-learn  |  No\n\"mnist\"  |  Standard MNIST 28×28 via torchvision  |  Yes\n\nThe rest of the code does not change: it only uses IMG (side length) and X (N × IMG × IMG, values 0–1).",
+  "file": "gan.py.txt"
+ },
+ {
+  "number": 3,
+  "key": "text_generation",
+  "aliases": [
+   "gpt2",
+   "gpt",
+   "finetune",
+   "3"
+  ],
+  "title": "Text generation: tokenization, embedding, pre-train + fine-tune, sampling (GPT-2 idea)",
+  "theory": "# ESE Practice — Exp 3: Text generation (GPT-2 idea, without a pretrained model)\nThe lab fine-tuned DistilGPT2. In the ESE no pretrained model is allowed, so the same pipeline is built from scratch with a small character-level language model:\n\nLab concept  |  ESE version\nTokenization (BPE)  |  Character tokenization: char → id\nEmbedding  |  nn.Embedding(vocab, 32): id → vector\nGPT-2 Transformer  |  Small GRU language model (option: tiny Transformer layer)\nPre-training + fine-tuning  |  Train on general text, then continue training on AI text\nCausal LM loss, perplexity  |  Cross-entropy of the next character, perplexity = e^loss\nTemperature / top-k / top-p  |  Written by hand in sample()\n\nText is typed inside the code, so there is no dataset and no internet. Runs on CPU in about 1 minute.",
+  "file": "text_generation.py.txt"
+ },
+ {
+  "number": 4,
+  "key": "text_to_image",
+  "aliases": [
+   "dalle",
+   "dalle_mini",
+   "4"
+  ],
+  "title": "Text-to-image with a conditional VAE (DALL·E Mini idea)",
+  "theory": "# ESE Practice — Exp 4: Text-to-image generation (DALL·E Mini idea, without a pretrained model)\nDALL·E Mini needs huge pretrained weights. The ESE version builds a tiny text-to-image model from scratch:\n* Images: coloured shapes drawn with NumPy (circle / square / plus × red / green / blue × small / big).\n* Text prompt → condition vector: each known word switches on one position, a multi-hot \"text embedding\". Attributes the prompt does not mention are chosen at random, so short prompts give varied images.\n* Model: a Conditional VAE (CVAE). The decoder receives [z, text vector], so the prompt controls *what* is drawn and z controls *how* (position, size details).\n* Studies: richer prompts, random seed, and \"temperature\" = scale of z.\n\nNo dataset, no internet. Runs on CPU in about 1 minute.",
+  "file": "text_to_image.py.txt"
+ },
+ {
+  "number": 5,
+  "key": "deepfake",
+  "aliases": [
+   "deepfake_ae",
+   "faceswap",
+   "5"
+  ],
+  "title": "Autoencoder DeepFake: shared encoder + two decoders, reconstruction analysis",
+  "theory": "# ESE Practice — Exp 5: Autoencoder DeepFake demo (face swap + reconstruction analysis)\nNo pretrained model, no internet: the faces are drawn with NumPy, so the experiment runs anywhere in about 1 minute.\n\nWhat to remember\n* Reconstruction system: image → preprocess (grayscale, resize, normalise) → autoencoder → reconstruction → error (MSE / PSNR) → show side by side.\n* Face swap = one shared encoder + two decoders. Train A → Enc → Dec_A → A and B → Enc → Dec_B → B.\n  * The shared encoder learns *pose / expression*; each decoder learns one *identity*.\n  * Swap: Dec_B(Enc(A)) gives A's expression and pose with B's face.",
+  "file": "deepfake.py.txt"
+ },
+ {
+  "number": 6,
+  "key": "music",
+  "aliases": [
+   "jukebox",
+   "music_generation",
+   "6"
+  ],
+  "title": "AI music generation (Markov chain) + WAV, waveform, spectrogram (Jukebox idea)",
+  "theory": "# ESE Practice — Exp 6: AI music generation (Jukebox idea, without a pretrained model)\nJukebox is a huge pretrained model. The ESE version learns from a melody written in code and generates new music, then does exactly the lab's audio analysis:\n\n1. \"Training data\": short melodies (note sequences) per genre, typed in code.\n2. Model: a Markov chain that learns P(next note | current note) by counting transitions. It is a tiny autoregressive model, the same idea as Jukebox's prior (next token given previous tokens).\n3. Conditioning: genre chooses the training melody, the scale and the tempo; mood = tempo + temperature.\n4. Synthesis: note → frequency f = 440·2^((m−69)/12) → sine wave + harmonics + envelope → WAV with Python's built-in wave module.\n5. Analysis: play the file, verify it, plot the waveform and the spectrogram, and compare genres.\n\nNo dataset, no internet, only NumPy and Matplotlib.",
+  "file": "music.py.txt"
+ },
+ {
+  "number": 7,
+  "key": "cyclegan",
+  "aliases": [
+   "style_transfer",
+   "7"
+  ],
+  "title": "CycleGAN unpaired style transfer",
+  "theory": "# ESE Practice — Exp 7: CycleGAN for unpaired style transfer (small, offline)\nHorse2Zebra cannot be used offline. The ESE version keeps the *same algorithm* with two image domains drawn in code:\n* Domain A = white shapes on a dark background (like \"day / summer photos\")\n* Domain B = dark shapes on a light background (like \"night / winter photos\": same kind of content, different *style*)\n\nThe two sets are generated independently (unpaired). CycleGAN has to learn A ↔ B without being told which image matches which.\n\nWhat to remember\n* 2 generators G_AB, G_BA and 2 discriminators D_A, D_B.\n* Adversarial loss (LSGAN): D(real) → 1, D(fake) → 0; the generators want D(fake) → 1.\n* Cycle loss: |G_BA(G_AB(a)) − a| + |G_AB(G_BA(b)) − b|, weighted by λ_cycle (10 in the lab). Optional identity loss: |G_AB(b) − b|.\n* Adam, lr = 0.0002, β = (0.5, 0.999), as in the lab.\n\nRuns on CPU in about 1–2 minutes.",
+  "file": "cyclegan.py.txt"
+ },
+ {
+  "number": 8,
+  "key": "chatbot",
+  "aliases": [
+   "8"
+  ],
+  "title": "Chatbot: tokenizer, TF-IDF + cosine similarity, context memory, exit loop",
+  "theory": "# ESE Practice — Exp 8: Chatbot (without a pretrained Transformer)\nDistilGPT2 is pretrained, so it is not allowed. The ESE chatbot is built from scratch while keeping the lab's pipeline steps:\n\nLab step  |  ESE version\nLoad tokenizer + model  |  Own tokenizer (lowercase, words, stop-words) + a knowledge base of Q&A pairs typed in code\nTokenize the input  |  tokenize()\nModel produces a response  |  TF-IDF vectors + cosine similarity: pick the best-matching answer (retrieval chatbot)\nControlled sampling  |  Confidence threshold + fallback reply; small random choice between equivalent replies\nContext awareness  |  Remembers the last topic: \"tell me more\" or \"what about it\" continue the previous topic\nLoop until exit  |  while True with input()\n\nEverything uses NumPy only. No internet.",
+  "file": "chatbot.py.txt"
+ },
+ {
+  "number": 9,
+  "key": "diffusion",
+  "aliases": [
+   "ddpm",
+   "stable_diffusion",
+   "9"
+  ],
+  "title": "Diffusion model (DDPM): forward/reverse process, schedules, guided generation",
+  "theory": "# ESE Practice — Exp 9: Simple diffusion model (DDPM) — fully offline\nWhat to remember\n* Forward: x_t = √ᾱ_t · x0 + √(1−ᾱ_t) · ε, with ᾱ_t = Π(1−β_s).\n* Train: network predicts the noise ε, loss = MSE(ε, ε̂).\n* Sample: x_{t−1} = (x_t − β_t/√(1−ᾱ_t) · ε̂) / √α_t + √β_t · z, starting from pure noise.\n* Schedules: linear β, or cosine ᾱ_t = cos²(((t/T + s)/(1 + s)) · π/2).\n* Part 3 (instead of Stable Diffusion): a *class-conditional* diffusion model with classifier-free guidance, the same \"guidance scale\" idea as Stable Diffusion, on 2-D data.\n\nRuns on CPU in about 2–3 minutes.",
+  "file": "diffusion.py.txt"
+ }
+]

genai_spit-1.0.0/src/genai_spit/experiments/chatbot.py.txt

@@ -0,0 +1,106 @@
+# GENAI Experiment 8: Chatbot: tokenizer, TF-IDF + cosine similarity, context memory, exit loop
+# ===========================================================================
+
+# # Part 1 — Knowledge base and tokenization
+
+import re, math, random
+import numpy as np
+random.seed(0)
+
+KB = {
+    "what is artificial intelligence": "Artificial intelligence is the science of making machines perform tasks that need human intelligence.",
+    "what is machine learning": "Machine learning lets computers learn patterns from data instead of being explicitly programmed.",
+    "what is deep learning": "Deep learning uses neural networks with many layers to learn features directly from data.",
+    "what is a neural network": "A neural network is layers of connected neurons that compute weighted sums followed by activations.",
+    "what is a gan generative adversarial network": "A GAN has a generator that makes fake data and a discriminator that tries to tell real from fake.",
+    "what is a vae variational autoencoder": "A VAE encodes data to a distribution in latent space and decodes samples from it to generate new data.",
+    "what is a transformer attention": "A transformer uses self-attention so every word can look at every other word to understand context.",
+    "what is a diffusion model": "A diffusion model adds noise to data step by step and learns to remove it, turning noise into new samples.",
+    "how do i study for exams tips": "Make a timetable, revise in short sessions, practise previous papers and sleep well.",
+    "hello hi hey good morning": "Hello! I am your GenAI lab assistant. Ask me about AI topics.",
+    "how are you": "I am just a program, but I am working fine. How can I help you?",
+    "thank you thanks": "You are welcome!",
+}
+MORE = {   # second-level answers used for "tell me more" (context)
+    "what is machine learning": "There are three main types: supervised, unsupervised and reinforcement learning.",
+    "what is deep learning": "Popular deep networks are CNNs for images, RNNs/LSTMs for sequences and transformers for language.",
+    "what is a gan generative adversarial network": "Training alternates: update the discriminator on real and fake, then update the generator to fool it.",
+    "what is a vae variational autoencoder": "Its loss is reconstruction loss plus KL divergence, and it uses the reparameterization trick z = mu + sigma * eps.",
+    "what is a diffusion model": "The network is trained to predict the added noise; sampling runs the denoising steps from t = T down to 1.",
+}
+STOP = {"what", "is", "a", "an", "the", "of", "me", "about", "please", "can", "you", "tell", "do", "i", "to", "how", "it"}
+
+def tokenize(text):
+    return [w for w in re.findall(r"[a-z]+", text.lower()) if w not in STOP]
+
+print(tokenize("What is Machine Learning, please?"))
+
+# # Part 2 — TF-IDF vectors and cosine similarity (the "model")
+
+questions = list(KB.keys())
+vocab = sorted({w for q in questions for w in tokenize(q)})
+widx = {w: i for i, w in enumerate(vocab)}
+df = np.zeros(len(vocab))
+for q in questions:
+    for w in set(tokenize(q)): df[widx[w]] += 1
+idf = np.log((1 + len(questions)) / (1 + df)) + 1                 # inverse document frequency
+
+def tfidf(text):
+    v = np.zeros(len(vocab))
+    for w in tokenize(text):
+        if w in widx: v[widx[w]] += 1                              # term frequency
+    v *= idf
+    n = np.linalg.norm(v); return v / n if n > 0 else v
+
+Q = np.stack([tfidf(q) for q in questions])                      # matrix: one row per known question
+def best_match(text):
+    sims = Q @ tfidf(text)                                       # cosine similarity (vectors are normalised)
+    i = int(np.argmax(sims)); return questions[i], float(sims[i])
+
+print(best_match("explain neural networks"))
+
+# # Part 3 — Response generation with context and a confidence threshold
+
+state = {"last_topic": None}
+FALLBACK = ["Sorry, I don't know that yet. Try asking about AI, ML, GANs, VAEs or diffusion.",
+            "I am not sure. Could you rephrase your question?"]
+
+def chatbot_reply(user_text, threshold=0.3):
+    t = user_text.lower()
+    if re.search(r"\b(more|elaborate|explain it|what about it|continue)\b", t) and state["last_topic"]:
+        return MORE.get(state["last_topic"], "That's all I know about this topic.")      # context
+    q, score = best_match(user_text)
+    if score < threshold:
+        return random.choice(FALLBACK)                                                  # low confidence
+    state["last_topic"] = q
+    return KB[q]
+
+for q in ["Hi!", "What is deep learning?", "Tell me more", "What's a GAN?", "can you elaborate",
+          "what is the capital of France", "how do I prepare for exams", "thanks"]:
+    print(f"You: {q}\nBot: {chatbot_reply(q)}\n")
+
+# # Part 4 — Interactive loop (type exit to stop)
+
+def run_chatbot():
+    print("GenAI lab chatbot - type 'exit' to quit")
+    while True:
+        try:
+            user_text = input("You: ")
+        except Exception:                      # no keyboard (e.g. auto-run) -> short demo
+            for user_text in ["what is a vae", "tell me more", "exit"]:
+                print("You:", user_text)
+                if user_text == "exit": print("Bot: Goodbye!"); return
+                print("Bot:", chatbot_reply(user_text))
+            return
+        if user_text.strip().lower() == "exit":
+            print("Bot: Goodbye!"); break
+        print("Bot:", chatbot_reply(user_text))
+
+run_chatbot()
+
+# Exam explanation: the input is tokenized (lowercase words without stop-words), turned into a TF-IDF
+# vector and compared with every known question by cosine similarity. The most similar answer is
+# returned. A threshold rejects unrelated questions (e.g. capitals of countries) instead of
+# hallucinating, and a last-topic memory gives context-aware follow-ups ("tell me more"). Compared
+# with DistilGPT2: retrieval answers are always correct for known topics but cannot invent new
+# sentences, while the pretrained model is fluent but often wrong.