Upload Precompute_Moss_embeddings_for_Kaggle_train.ipynb

Precompute_Moss_embeddings_for_Kaggle_train.ipynb

@@ -0,0 +1,317 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "collapsed_sections": [
+        "2UkdVxcYo9HZ",
+        "jRFJRfzHpK_k"
+      ]
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Precompute Moss Image embeddings for Lora Training on Kaggle\n"
+      ],
+      "metadata": {
+        "id": "2UkdVxcYo9HZ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "1c6f852e"
+      },
+      "source": [
+        "# =============================================================================\n",
+        "# Kromoss (MOSS-Image) LoRA Training – PART 1: PRECOMPUTE EMBEDDINGS\n",
+        "# =============================================================================\n",
+        "\n",
+        "from google.colab import userdata, drive\n",
+        "import os\n",
+        "from huggingface_hub import login\n",
+        "\n",
+        "HF_TOKEN = userdata.get(\"HF_TOKEN\")\n",
+        "login(token=HF_TOKEN, add_to_git_credential=False)\n",
+        "print(\"Logged in with HF_TOKEN\")\n",
+        "\n",
+        "#@title 2. Mount Drive + unpack dataset\n",
+        "drive.mount(\"/content/drive\")\n",
+        "\n",
+        "import zipfile, shutil, gc\n",
+        "from pathlib import Path\n",
+        "\n",
+        "DATA_ZIP = \"/content/drive/MyDrive/tetsu_training_data.zip\"\n",
+        "DATA_DIR = Path(\"/content/tetsu_training_data\")\n",
+        "\n",
+        "if DATA_DIR.exists():\n",
+        "    shutil.rmtree(DATA_DIR)\n",
+        "DATA_DIR.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "print(f\"Extracting {DATA_ZIP} ...\")\n",
+        "with zipfile.ZipFile(DATA_ZIP, \"r\") as z:\n",
+        "    z.extractall(DATA_DIR)\n",
+        "\n",
+        "# Flatten single top-level folder if present\n",
+        "subdirs = [d for d in DATA_DIR.iterdir() if d.is_dir()]\n",
+        "if len(list(DATA_DIR.glob(\"*\"))) == 1 and subdirs:\n",
+        "    for item in subdirs[0].iterdir():\n",
+        "        shutil.move(str(item), str(DATA_DIR / item.name))\n",
+        "    subdirs[0].rmdir()\n",
+        "\n",
+        "print(\"Dataset ready:\", list(DATA_DIR.iterdir())[:8], \"...\")\n",
+        "\n",
+        "#@title 3. Global Configuration\n",
+        "import torch\n",
+        "from transformers import AutoTokenizer, AutoModel, BitsAndBytesConfig\n",
+        "\n",
+        "REPO_ID          = \"lodestones/Kromoss\"\n",
+        "RESOLUTION       = 1024\n",
+        "MIXED_PRECISION  = \"bf16\"\n",
+        "SEED             = 42\n",
+        "MAX_SEQ_LEN      = 512\n",
+        "\n",
+        "device = torch.device(\"cuda\")\n",
+        "dtype  = torch.bfloat16 if MIXED_PRECISION == \"bf16\" else torch.float16\n",
+        "torch.manual_seed(SEED)\n",
+        "\n",
+        "#@title 4. Collect image-caption pairs\n",
+        "IMG_EXTS = {\".jpg\", \".jpeg\", \".png\", \".webp\", \".bmp\"}\n",
+        "pairs = []\n",
+        "for img_path in sorted(DATA_DIR.rglob(\"*\")):\n",
+        "    if img_path.suffix.lower() not in IMG_EXTS:\n",
+        "        continue\n",
+        "    txt_path = img_path.with_suffix(\".txt\")\n",
+        "    if txt_path.exists():\n",
+        "        caption = txt_path.read_text(encoding=\"utf-8\").strip()\n",
+        "        if caption:\n",
+        "            pairs.append((str(img_path), caption))\n",
+        "\n",
+        "print(f\"Found {len(pairs)} image-text pairs\")\n",
+        "assert len(pairs) > 0, \"No image + .txt pairs found\"\n",
+        "\n",
+        "#@title 5. Precompute text embeddings with 4-bit quantized TE\n",
+        "print(\">>> Loading tokenizer ...\")\n",
+        "tokenizer = AutoTokenizer.from_pretrained(\n",
+        "    REPO_ID, subfolder=\"tokenizer\", trust_remote_code=True, token=HF_TOKEN\n",
+        ")\n",
+        "\n",
+        "def build_prompt(text: str) -> str:\n",
+        "    return f\"<|im_start|>user\\n{text}<|im_end|>\\n<|im_start|>assistant\\n<think>\\n\"\n",
+        "\n",
+        "print(\">>> Loading 4-bit NF4 text encoder (fits in ~6 GB) ...\")\n",
+        "bnb_config = BitsAndBytesConfig(\n",
+        "    load_in_4bit=True,\n",
+        "    bnb_4bit_quant_type=\"nf4\",\n",
+        "    bnb_4bit_compute_dtype=torch.bfloat16,\n",
+        "    bnb_4bit_use_double_quant=True,\n",
+        ")\n",
+        "\n",
+        "try:\n",
+        "    text_encoder = AutoModel.from_pretrained(\n",
+        "        REPO_ID,\n",
+        "        subfolder=\"text_encoder\",\n",
+        "        quantization_config=bnb_config,\n",
+        "        device_map=\"auto\",\n",
+        "        trust_remote_code=True,\n",
+        "        token=HF_TOKEN,\n",
+        "    )\n",
+        "    print(\"Loaded quantized text_encoder from lodestones/Kromoss\")\n",
+        "except Exception as e:\n",
+        "    print(f\"Kromoss text_encoder quant failed ({e}), falling back to Qwen/Qwen3.5-9B\")\n",
+        "    text_encoder = AutoModel.from_pretrained(\n",
+        "        \"Qwen/Qwen3.5-9B\",\n",
+        "        quantization_config=bnb_config,\n",
+        "        device_map=\"auto\",\n",
+        "        trust_remote_code=True,\n",
+        "        token=HF_TOKEN,\n",
+        "    )\n",
+        "\n",
+        "text_encoder.eval()\n",
+        "text_encoder.requires_grad_(False)\n",
+        "\n",
+        "EMB_CACHE = Path(\"/content/text_emb_cache\")\n",
+        "EMB_CACHE.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "@torch.no_grad()\n",
+        "def encode_prompt(prompt: str):\n",
+        "    text = build_prompt(prompt)\n",
+        "    tokens = tokenizer(\n",
+        "        text,\n",
+        "        return_tensors=\"pt\",\n",
+        "        padding=False,\n",
+        "        truncation=True,\n",
+        "        max_length=MAX_SEQ_LEN,\n",
+        "        add_special_tokens=False,\n",
+        "    )\n",
+        "    input_ids = tokens.input_ids.to(device)\n",
+        "    attention_mask = tokens.attention_mask.to(device)\n",
+        "\n",
+        "    outputs = text_encoder(\n",
+        "        input_ids=input_ids,\n",
+        "        attention_mask=attention_mask,\n",
+        "        output_hidden_states=False,\n",
+        "        return_dict=True,\n",
+        "    )\n",
+        "    return outputs.last_hidden_state.cpu(), attention_mask.cpu()\n",
+        "\n"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from tqdm.auto import tqdm\n",
+        "import torch\n",
+        "\n",
+        "print(\">>> Precomputing text embeddings ...\")\n",
+        "for idx, (img_path, caption) in enumerate(tqdm(pairs)):\n",
+        "    cache_file = EMB_CACHE / f\"{idx:06d}.pt\"\n",
+        "    if cache_file.exists():\n",
+        "        continue\n",
+        "    emb, mask = encode_prompt(caption)\n",
+        "    torch.save({\"emb\": emb, \"mask\": mask, \"caption\": caption, \"img\": img_path}, cache_file)\n",
+        "\n",
+        "# ---------- Fully unload the quantized text encoder ----------\n",
+        "print(\">>> Unloading text encoder completely ...\")\n",
+        "if 'text_encoder' in globals():\n",
+        "    del text_encoder\n",
+        "if 'tokenizer' in globals():\n",
+        "    del tokenizer\n",
+        "gc.collect()\n",
+        "torch.cuda.empty_cache()\n",
+        "torch.cuda.ipc_collect()\n",
+        "print(f\"VRAM after TE unload: {torch.cuda.memory_allocated()/1024**3:.2f} GB\")"
+      ],
+      "metadata": {
+        "id": "HDGJLFrocjqs"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {
+        "id": "fc52c645"
+      },
+      "source": [
+        "# =============================================================================\n",
+        "# STEP A: PRE-ENCODE IMAGES WITH VAE & SAVE COMPLETE DATASET TO GOOGLE DRIVE\n",
+        "# =============================================================================\n",
+        "# This step completely encodes both the images (using VAE) and matches them\n",
+        "# with the precomputed text embeddings from the previous step. It saves\n",
+        "# them as unified, ready-to-train torch tensors on your Google Drive.\n",
+        "# =============================================================================\n",
+        "\n",
+        "\"\"\"\n",
+        "[EXPLANATION OF DATASET PREPARATION]\n",
+        "This cell processes our active dataset by:\n",
+        "1. Loading the high-fidelity AutoencoderKLFlux2 VAE on CUDA.\n",
+        "2. Iterating through the images configured during dataset setup.\n",
+        "3. Downsampling/Center-cropping to 1024x1024 resolution.\n",
+        "4. Passing the image through the VAE encoder to yield compressed 2D latents.\n",
+        "5. Coupling these latents with the matching text embeddings cached in the previous step.\n",
+        "6. Saving the combined state (latents + text embeddings + attention masks) directly to Google Drive\n",
+        "   under '/content/drive/MyDrive/kromoss_precomputed_dataset/' for instantaneous future loading.\n",
+        "\"\"\"\n",
+        "\n",
+        "import torch\n",
+        "import gc\n",
+        "from pathlib import Path\n",
+        "from PIL import Image\n",
+        "from tqdm.auto import tqdm\n",
+        "from torchvision import transforms\n",
+        "from google.colab import userdata\n",
+        "from diffusers import AutoencoderKLFlux2\n",
+        "\n",
+        "# Configuration\n",
+        "REPO_ID = \"lodestones/Kromoss\"\n",
+        "HF_TOKEN = userdata.get(\"HF_TOKEN\")\n",
+        "RESOLUTION = 1024\n",
+        "EMB_CACHE = Path(\"/content/text_emb_cache\")\n",
+        "\n",
+        "# Target directory on Google Drive\n",
+        "DRIVE_DATASET_DIR = Path(\"/content/drive/MyDrive/kromoss_precomputed_dataset\")\n",
+        "DRIVE_DATASET_DIR.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "device = torch.device(\"cuda\")\n",
+        "\n",
+        "print(\">>> Loading VAE model onto CUDA...\")\n",
+        "vae = AutoencoderKLFlux2.from_pretrained(\n",
+        "    REPO_ID,\n",
+        "    subfolder=\"vae\",\n",
+        "    torch_dtype=torch.float32, # Encode in float32 for high fidelity\n",
+        "    token=HF_TOKEN,\n",
+        ").to(device)\n",
+        "vae.eval()\n",
+        "vae.requires_grad_(False)\n",
+        "\n",
+        "# Transformation Pipeline\n",
+        "image_transforms = transforms.Compose([\n",
+        "    transforms.Resize(RESOLUTION, interpolation=transforms.InterpolationMode.LANCZOS),\n",
+        "    transforms.CenterCrop(RESOLUTION),\n",
+        "    transforms.ToTensor(),\n",
+        "    transforms.Normalize([0.5], [0.5]),\n",
+        "])\n",
+        "\n",
+        "@torch.no_grad()\n",
+        "def pre_encode_and_save():\n",
+        "    # Retrieve all pre-encoded text embedding cache files\n",
+        "    cached_text_files = sorted(EMB_CACHE.glob(\"*.pt\"))\n",
+        "    print(f\">>> Found {len(cached_text_files)} cached text embeddings. Encoding corresponding images...\")\n",
+        "\n",
+        "    for text_file in tqdm(cached_text_files, desc=\"Pre-encoding dataset\"):\n",
+        "        # Load text cached data\n",
+        "        text_data = torch.load(text_file, map_location=\"cpu\", weights_only=False)\n",
+        "\n",
+        "        # Prepare output destination on Drive\n",
+        "        drive_save_path = DRIVE_DATASET_DIR / text_file.name\n",
+        "        if drive_save_path.exists():\n",
+        "            continue\n",
+        "\n",
+        "        # Load corresponding raw image\n",
+        "        img_path = text_data[\"img\"]\n",
+        "        img = Image.open(img_path).convert(\"RGB\")\n",
+        "\n",
+        "        # Process image through VAE\n",
+        "        pixel_values = image_transforms(img).unsqueeze(0).to(device, dtype=torch.float32)\n",
+        "        image_latents = vae.encode(pixel_values).latent_dist.sample()\n",
+        "\n",
+        "        # Unified output state containing both modalities\n",
+        "        precomputed_sample = {\n",
+        "            \"image_latents\": image_latents.squeeze(0).to(torch.bfloat16).cpu(), # Save in bf16 to conserve space\n",
+        "            \"encoder_hidden_states\": text_data[\"emb\"].squeeze(0).to(torch.bfloat16).cpu(),\n",
+        "            \"encoder_attention_mask\": text_data[\"mask\"].squeeze(0).cpu(),\n",
+        "            \"caption\": text_data[\"caption\"]\n",
+        "        }\n",
+        "\n",
+        "        # Write directly to Google Drive\n",
+        "        torch.save(precomputed_sample, drive_save_path)\n",
+        "\n",
+        "# Execute pre-encoding\n",
+        "pre_encode_and_save()\n",
+        "\n",
+        "# Release VAE and empty GPU memory cache\n",
+        "print(\">>> Pre-encoding finished. Unloading VAE model...\")\n",
+        "del vae\n",
+        "gc.collect()\n",
+        "torch.cuda.empty_cache()\n",
+        "torch.cuda.ipc_collect()\n",
+        "print(f\"VRAM after VAE unload: {torch.cuda.memory_allocated()/1024**3:.2f} GB\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}