Upload sort_parquets_by_category.ipynb

sort_parquets_by_category.ipynb

@@ -0,0 +1,510 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Using https://huggingface.co/datasets/lodestones/booru-essence"
+      ],
+      "metadata": {
+        "id": "U-yf5jnY3gSd"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "id": "HFy5aDxM3G7O"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Sort Parquet texts by Rating → T5 encode → KMeans clusters (up to 100)\n",
+        "# Loads the parquet, groups by the 'rating' column, builds one combined descriptive text per row,\n",
+        "# encodes with T5, then runs KMeans (max 100 clusters) and saves results to /content/output/ only.\n",
+        "\n",
+        "!pip install -q transformers scikit-learn umap-learn matplotlib tqdm\n",
+        "\n",
+        "import os\n",
+        "import re\n",
+        "import json\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import torch\n",
+        "from transformers import T5Tokenizer, T5Model\n",
+        "from sklearn.cluster import KMeans\n",
+        "from sklearn.metrics import silhouette_score\n",
+        "from umap import UMAP\n",
+        "import matplotlib.pyplot as plt\n",
+        "from tqdm.auto import tqdm\n",
+        "import warnings\n",
+        "warnings.filterwarnings(\"ignore\")\n",
+        "\n",
+        "# ============================================================\n",
+        "# 0. Load the Parquet file\n",
+        "# ============================================================\n",
+        "file_path = \"/content/drive/MyDrive/booru_essence.parquet\"  #@param {type:\"string\"}\n",
+        "\n",
+        "print(f\"Loading parquet from: {file_path}\")\n",
+        "df = pd.read_parquet(file_path)\n",
+        "print(f\"Loaded dataframe shape: {df.shape}\")\n",
+        "print(f\"Columns: {df.columns.tolist()}\")\n",
+        "\n",
+        "# ============================================================\n",
+        "# Configuration\n",
+        "# ============================================================\n",
+        "n_clusters = 100          #@param {type:\"slider\", min:2, max:100, step:1}\n",
+        "t5_model_name = \"t5-base\" #@param [\"t5-small\", \"t5-base\"]\n",
+        "max_length = 512          #@param {type:\"slider\", min:128, max:512, step:64}\n",
+        "batch_size = 16           #@param {type:\"slider\", min:4, max:32, step:4}\n",
+        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "print(f\"Using device: {device}\")\n",
+        "\n",
+        "# Which text columns to combine (in order of priority)\n",
+        "TEXT_COLS = [\n",
+        "    \"brief_summary\",\n",
+        "    \"midjourney_style_summary\",\n",
+        "    \"tags\",\n",
+        "    \"trigger_tag\",\n",
+        "    # \"10_word_summary\",   # currently all-null in your file\n",
+        "]\n",
+        "\n",
+        "# ============================================================\n",
+        "# 1. Helper: clean & combine descriptive texts for one row\n",
+        "# ============================================================\n",
+        "def combine_texts(row):\n",
+        "    parts = []\n",
+        "    for col in TEXT_COLS:\n",
+        "        val = row.get(col)\n",
+        "        if pd.isna(val) or val is None:\n",
+        "            continue\n",
+        "        text = str(val).strip()\n",
+        "        if text and text.lower() != \"none\":\n",
+        "            # simple cleanup\n",
+        "            text = re.sub(r'\\s+', ' ', text)\n",
+        "            parts.append(text)\n",
+        "    return \" | \".join(parts) if parts else \"\"\n",
+        "\n",
+        "# ============================================================\n",
+        "# 2. Load T5 encoder\n",
+        "# ============================================================\n",
+        "print(f\"Loading {t5_model_name}...\")\n",
+        "tokenizer = T5Tokenizer.from_pretrained(t5_model_name)\n",
+        "model = T5Model.from_pretrained(t5_model_name).to(device)\n",
+        "model.eval()\n",
+        "\n",
+        "def get_t5_embeddings(texts, batch_size=16):\n",
+        "    \"\"\"Return mean-pooled encoder embeddings (N, hidden_size)\"\"\"\n",
+        "    all_embs = []\n",
+        "    for i in tqdm(range(0, len(texts), batch_size), desc=\"Encoding\"):\n",
+        "        batch = texts[i:i+batch_size]\n",
+        "        inputs = tokenizer(\n",
+        "            batch,\n",
+        "            return_tensors=\"pt\",\n",
+        "            padding=True,\n",
+        "            truncation=True,\n",
+        "            max_length=max_length\n",
+        "        ).to(device)\n",
+        "\n",
+        "        with torch.no_grad():\n",
+        "            outputs = model.encoder(**inputs)\n",
+        "            # mean pool over sequence length (ignore padding via attention mask)\n",
+        "            last_hidden = outputs.last_hidden_state          # (B, L, H)\n",
+        "            mask = inputs.attention_mask.unsqueeze(-1).float()\n",
+        "            summed = (last_hidden * mask).sum(dim=1)\n",
+        "            counts = mask.sum(dim=1).clamp(min=1e-9)\n",
+        "            mean_pooled = summed / counts                    # (B, H)\n",
+        "            all_embs.append(mean_pooled.cpu().numpy())\n",
+        "\n",
+        "    return np.vstack(all_embs)\n",
+        "\n",
+        "# ============================================================\n",
+        "# 3. Process each rating group separately\n",
+        "# ============================================================\n",
+        "assert \"rating\" in df.columns, \"Column 'rating' not found!\"\n",
+        "\n",
+        "# All results go ONLY to /content/output/\n",
+        "output_base = \"/content/output\"\n",
+        "os.makedirs(output_base, exist_ok=True)\n",
+        "\n",
+        "unique_ratings = df[\"rating\"].dropna().unique().tolist()\n",
+        "print(f\"Found ratings: {unique_ratings}\")\n",
+        "\n",
+        "for rating in unique_ratings:\n",
+        "    print(f\"\\n{'='*60}\")\n",
+        "    print(f\"Processing rating = '{rating}'\")\n",
+        "    print(f\"{'='*60}\")\n",
+        "\n",
+        "    # Filter\n",
+        "    group = df[df[\"rating\"] == rating].copy().reset_index(drop=True)\n",
+        "    print(f\"  Rows: {len(group)}\")\n",
+        "\n",
+        "    # Build combined text\n",
+        "    group[\"combined_text\"] = group.apply(combine_texts, axis=1)\n",
+        "\n",
+        "    # Drop empty texts\n",
+        "    group = group[group[\"combined_text\"].str.len() > 5].reset_index(drop=True)\n",
+        "    print(f\"  After dropping near-empty texts: {len(group)}\")\n",
+        "\n",
+        "    if len(group) < 2:\n",
+        "        print(\"  Skipping – not enough samples\")\n",
+        "        continue\n",
+        "\n",
+        "    texts = group[\"combined_text\"].tolist()\n",
+        "\n",
+        "    # Encode with T5\n",
+        "    embeddings = get_t5_embeddings(texts, batch_size=batch_size)\n",
+        "    print(f\"  Embeddings shape: {embeddings.shape}\")\n",
+        "\n",
+        "    # Decide number of clusters (never more than samples, never more than requested)\n",
+        "    k = min(n_clusters, len(group) // 2, 100)   # safety\n",
+        "    k = max(k, 2)\n",
+        "    print(f\"  Using k = {k} clusters\")\n",
+        "\n",
+        "    # KMeans\n",
+        "    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10, verbose=0)\n",
+        "    labels = kmeans.fit_predict(embeddings)\n",
+        "    group[\"cluster\"] = labels\n",
+        "\n",
+        "    # Silhouette (optional, can be slow on large sets)\n",
+        "    try:\n",
+        "        sil = silhouette_score(embeddings, labels, sample_size=min(5000, len(embeddings)))\n",
+        "        print(f\"  Silhouette score: {sil:.3f}\")\n",
+        "    except Exception as e:\n",
+        "        print(f\"  Silhouette skipped: {e}\")\n",
+        "\n",
+        "    # Save full group with cluster labels\n",
+        "    rating_safe = re.sub(r'[^a-zA-Z0-9_]', '_', str(rating))\n",
+        "    out_dir = os.path.join(output_base, f\"rating_{rating_safe}\")\n",
+        "    os.makedirs(out_dir, exist_ok=True)\n",
+        "\n",
+        "    # Save the whole dataframe for this rating\n",
+        "    group.to_parquet(os.path.join(out_dir, f\"all_with_clusters.parquet\"), index=False)\n",
+        "    group.to_csv(os.path.join(out_dir, f\"all_with_clusters.csv\"), index=False)\n",
+        "\n",
+        "    # Also save one CSV per cluster (easy to inspect)\n",
+        "    for c in range(k):\n",
+        "        cluster_df = group[group[\"cluster\"] == c]\n",
+        "        cluster_df.to_csv(\n",
+        "            os.path.join(out_dir, f\"cluster_{c:03d}.csv\"),\n",
+        "            index=False\n",
+        "        )\n",
+        "        # Optional: save only the combined text\n",
+        "        with open(os.path.join(out_dir, f\"cluster_{c:03d}_texts.txt\"), \"w\", encoding=\"utf-8\") as f:\n",
+        "            for t in cluster_df[\"combined_text\"]:\n",
+        "                f.write(t + \"\\n\\n---\\n\\n\")\n",
+        "\n",
+        "    print(f\"  Saved to: {out_dir}\")\n",
+        "\n",
+        "    # Optional 2-D UMAP plot\n",
+        "    if len(embeddings) >= 10:\n",
+        "        try:\n",
+        "            reducer = UMAP(n_components=2, random_state=42, n_neighbors=15, min_dist=0.1)\n",
+        "            emb_2d = reducer.fit_transform(embeddings)\n",
+        "\n",
+        "            plt.figure(figsize=(10, 8))\n",
+        "            scatter = plt.scatter(emb_2d[:, 0], emb_2d[:, 1],\n",
+        "                                  c=labels, cmap=\"tab20\", s=20, alpha=0.7)\n",
+        "            plt.colorbar(scatter, label=\"Cluster\")\n",
+        "            plt.title(f\"T5 + KMeans – rating='{rating}' (k={k})\")\n",
+        "            plt.xlabel(\"UMAP-1\")\n",
+        "            plt.ylabel(\"UMAP-2\")\n",
+        "            plt.tight_layout()\n",
+        "            plt.savefig(os.path.join(out_dir, \"umap_plot.png\"), dpi=150)\n",
+        "            plt.show()\n",
+        "        except Exception as e:\n",
+        "            print(f\"  UMAP plot failed: {e}\")\n",
+        "\n",
+        "print(\"\\n✅ Done!\")\n",
+        "print(f\"All results are under: {output_base}\")\n",
+        "print(\"Structure:\")\n",
+        "print(\"  /content/output/\")\n",
+        "print(\"    rating_explicit/\")\n",
+        "print(\"      all_with_clusters.parquet / .csv\")\n",
+        "print(\"      cluster_000.csv ... cluster_099.csv\")\n",
+        "print(\"      cluster_000_texts.txt ...\")\n",
+        "print(\"      umap_plot.png\")\n",
+        "print(\"    rating_questionable/\")\n",
+        "print(\"    rating_general/\")\n",
+        "print(\"    ...\")"
+      ],
+      "metadata": {
+        "id": "3WfqNYWD7V-h"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Generate text files from clustered prompts + create ZIP\n",
+        "# Creates one .txt file per cluster (sorted by rating → cluster number)\n",
+        "# Each file follows the exact //start ... format you provided.\n",
+        "# All .txt files are then zipped into /content/output/js_files.zip\n",
+        "\n",
+        "import os\n",
+        "import re\n",
+        "import zipfile\n",
+        "from pathlib import Path\n",
+        "from tqdm.auto import tqdm\n",
+        "\n",
+        "# ============================================================\n",
+        "# Configuration\n",
+        "# ============================================================\n",
+        "input_base = \"/content/output\"                    # where the previous cell saved results\n",
+        "output_dir = \"/content/output/js_files\"           # final .txt files go here\n",
+        "os.makedirs(output_dir, exist_ok=True)\n",
+        "\n",
+        "name = \"booru_essence\"                                    #@param {type:\"string\"}\n",
+        "emoji = \"🏖️\"                                      #@param {type:\"string\"}\n",
+        "showComments = True\n",
+        "showDemo = True\n",
+        "\n",
+        "# Placeholder image (you can change later)\n",
+        "placeholder_image = \"https://www.iguides.ru/upload/iblock/ccf/ccf3e83b95a8b350d5089424687fc133.jpg\"\n",
+        "placeholder_description = \"a space ship , used as a placeholder\"\n",
+        "placeholder_caption = \"This is text\"\n",
+        "meta_image = \"https://i.imgur.com/TPHIzaa.jpeg\"\n",
+        "\n",
+        "# ============================================================\n",
+        "# 1. Collect all cluster text files, sorted by rating then cluster number\n",
+        "# ============================================================\n",
+        "text_files = []\n",
+        "\n",
+        "for rating_dir in sorted(Path(input_base).glob(\"rating_*\")):\n",
+        "    if not rating_dir.is_dir():\n",
+        "        continue\n",
+        "    rating_name = rating_dir.name.replace(\"rating_\", \"\")\n",
+        "\n",
+        "    for txt_file in sorted(rating_dir.glob(\"cluster_*_texts.txt\")):\n",
+        "        # extract cluster number for proper sorting\n",
+        "        match = re.search(r\"cluster_(\\d+)_texts\\.txt\", txt_file.name)\n",
+        "        if match:\n",
+        "            cluster_num = int(match.group(1))\n",
+        "            text_files.append({\n",
+        "                \"path\": txt_file,\n",
+        "                \"rating\": rating_name,\n",
+        "                \"cluster\": cluster_num\n",
+        "            })\n",
+        "\n",
+        "# Final sort: rating name → cluster number\n",
+        "text_files = sorted(text_files, key=lambda x: (x[\"rating\"], x[\"cluster\"]))\n",
+        "\n",
+        "print(f\"Found {len(text_files)} cluster text files\")\n",
+        "if len(text_files) == 0:\n",
+        "    raise FileNotFoundError(\"No cluster_*_texts.txt files found under /content/output/\")\n",
+        "\n",
+        "# ============================================================\n",
+        "# 2. Helper: read prompts from a *_texts.txt file\n",
+        "# ============================================================\n",
+        "def load_prompts(txt_path):\n",
+        "    content = Path(txt_path).read_text(encoding=\"utf-8\")\n",
+        "    # Split on the separator used in the previous cell\n",
+        "    raw_prompts = re.split(r'\\n\\s*---\\s*\\n', content)\n",
+        "    prompts = []\n",
+        "    for p in raw_prompts:\n",
+        "        p = p.strip()\n",
+        "        if p and len(p) > 5:\n",
+        "            # clean newlines inside a single prompt → single space\n",
+        "            p = re.sub(r'\\s+', ' ', p)\n",
+        "            prompts.append(p)\n",
+        "    return prompts\n",
+        "\n",
+        "# ============================================================\n",
+        "# 3. Generate one .txt file per cluster\n",
+        "# ============================================================\n",
+        "total = len(text_files)\n",
+        "generated_files = []\n",
+        "\n",
+        "for idx, item in enumerate(tqdm(text_files, desc=\"Generating TXT files\"), start=1):\n",
+        "    prompts = load_prompts(item[\"path\"])\n",
+        "\n",
+        "    if not prompts:\n",
+        "        print(f\"  Skipping empty cluster: {item['path']}\")\n",
+        "        continue\n",
+        "\n",
+        "    # Join all prompts with single \"|\"\n",
+        "    dataset_str = \"|\".join(prompts)\n",
+        "\n",
+        "    # Build backward / forward links\n",
+        "    if idx == 1:\n",
+        "        backward = f'[\"fusion-t2i-{name}-1\"]'\n",
+        "    else:\n",
+        "        backward = f'[\"fusion-t2i-{name}-{idx-1}\"]'\n",
+        "\n",
+        "    if idx == total:\n",
+        "        forward = f'[\"fusion-t2i-{name}-{idx}\"]'\n",
+        "    else:\n",
+        "        forward = f'[\"fusion-t2i-{name}-{idx+1}\"]'\n",
+        "\n",
+        "    # Full content matching your template\n",
+        "    content = f\"\"\"//start\n",
+        "index = {idx}\n",
+        "emoji = {emoji}\n",
+        "showComments = {str(showComments).lower()}\n",
+        "showDemo = {str(showDemo).lower()}\n",
+        "name = {name}\n",
+        "pageTitle = [emoji] fusion-t2i-[name]-[index]\n",
+        "pageDescription = captioned works by booru_parquet\n",
+        "\n",
+        "tagBlackListRaw = [\"\"]\n",
+        "tagBlackList= [tagBlackListRaw.replaceText(' ' , ',')]\n",
+        "\n",
+        "// Generator browse destinations\n",
+        "backward={backward}\n",
+        "forward={forward}\n",
+        "backward_em= {emoji}\n",
+        "forward_em= {emoji}\n",
+        "numItemsStart=1\n",
+        "//----//\n",
+        "\n",
+        "\n",
+        "image_url = [\"{placeholder_image}\"]\n",
+        "image_description= [\"{placeholder_description}\"]\n",
+        "optional_image_caption= [\"{placeholder_caption}\"]\n",
+        "\n",
+        "$meta\n",
+        "  title = [emoji] [name] [index]   // <-- notice that this shows up in the browser tab - it overrides the <h1> text\n",
+        "  description = This is subset [index] of [name] , which contains various descriptions of [name]\n",
+        "  image = {meta_image}\n",
+        "$output\n",
+        "  [dataset]\n",
+        "\n",
+        "\n",
+        "data = [(($output.selectMany(document.numItems).join(\" \")+' '))]\n",
+        "\n",
+        "dataset\n",
+        "  [\"{dataset_str}\"]\n",
+        "//----//\n",
+        "\"\"\"\n",
+        "\n",
+        "    # Save as .txt file\n",
+        "    out_name = f\"fusion-t2i-{name}-{idx}.txt\"\n",
+        "    out_path = os.path.join(output_dir, out_name)\n",
+        "    with open(out_path, \"w\", encoding=\"utf-8\") as f:\n",
+        "        f.write(content)\n",
+        "\n",
+        "    generated_files.append(out_path)\n",
+        "\n",
+        "print(f\"\\n✅ Generated {len(generated_files)} .txt files in: {output_dir}\")\n",
+        "\n",
+        "# ============================================================\n",
+        "# 4. Create ZIP archive\n",
+        "# ============================================================\n",
+        "zip_path = \"/content/output/js_files.zip\"\n",
+        "\n",
+        "with zipfile.ZipFile(zip_path, \"w\", zipfile.ZIP_DEFLATED) as zipf:\n",
+        "    for file_path in generated_files:\n",
+        "        # store only the filename inside the zip (no folder structure)\n",
+        "        zipf.write(file_path, arcname=os.path.basename(file_path))\n",
+        "\n",
+        "print(f\"✅ ZIP created: {zip_path}\")\n",
+        "print(f\"   Contains {len(generated_files)} files\")\n",
+        "print(\"\\nYou can download it from the Colab file browser or with:\")\n",
+        "print(f\"!files.download('{zip_path}')\")"
+      ],
+      "metadata": {
+        "id": "vJh25rT9_14a"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#@title Clean \"|\" before every \"by ...\" in the generated TXT files + re-zip\n",
+        "# Removes the \"|\" that appears immediately before artist credits like:\n",
+        "#   \"white sweater | by hyde (tabakko)|1girl\"  →  \"white sweater by hyde (tabakko)|1girl\"\n",
+        "#   \"eyebrows | by alexmaster|1girl\"           →  \"eyebrows by alexmaster|1girl\"\n",
+        "\n",
+        "import os\n",
+        "import re\n",
+        "import zipfile\n",
+        "from pathlib import Path\n",
+        "from tqdm.auto import tqdm\n",
+        "\n",
+        "# ============================================================\n",
+        "# Paths\n",
+        "# ============================================================\n",
+        "txt_dir = Path(\"/content/output/js_files\")\n",
+        "zip_path = \"/content/js_files.zip\"          # ← final zip now saved directly to /content/\n",
+        "\n",
+        "if not txt_dir.exists():\n",
+        "    raise FileNotFoundError(f\"Directory not found: {txt_dir}\")\n",
+        "\n",
+        "txt_files = sorted(txt_dir.glob(\"fusion-t2i-*.txt\"))\n",
+        "print(f\"Found {len(txt_files)} files to clean\")\n",
+        "\n",
+        "# ============================================================\n",
+        "# Cleaning function\n",
+        "# ============================================================\n",
+        "def clean_pipe_before_by(text: str) -> str:\n",
+        "    \"\"\"\n",
+        "    Remove the '|' that sits right before an artist credit starting with 'by '.\n",
+        "    Examples:\n",
+        "        \"... sweater | by hyde (tabakko)|1girl\"\n",
+        "        → \"... sweater by hyde (tabakko)|1girl\"\n",
+        "    \"\"\"\n",
+        "    # Pattern: optional whitespace + | + optional whitespace + \"by \" (case-insensitive)\n",
+        "    # We keep the \"by \" and just remove the preceding |\n",
+        "    cleaned = re.sub(r'\\s*\\|\\s*(by\\s)', r' \\1', text, flags=re.IGNORECASE)\n",
+        "\n",
+        "    # Also clean any double spaces that may have been created\n",
+        "    cleaned = re.sub(r' {2,}', ' ', cleaned)\n",
+        "\n",
+        "    return cleaned\n",
+        "\n",
+        "# ============================================================\n",
+        "# Process every file\n",
+        "# ============================================================\n",
+        "cleaned_count = 0\n",
+        "\n",
+        "for txt_path in tqdm(txt_files, desc=\"Cleaning files\"):\n",
+        "    original = txt_path.read_text(encoding=\"utf-8\")\n",
+        "    cleaned = clean_pipe_before_by(original)\n",
+        "\n",
+        "    if cleaned != original:\n",
+        "        txt_path.write_text(cleaned, encoding=\"utf-8\")\n",
+        "        cleaned_count += 1\n",
+        "\n",
+        "print(f\"\\n✅ Cleaned {cleaned_count} files (others already clean)\")\n",
+        "\n",
+        "# ============================================================\n",
+        "# Re-create the ZIP with the cleaned files → saved to /content/\n",
+        "# ============================================================\n",
+        "with zipfile.ZipFile(zip_path, \"w\", zipfile.ZIP_DEFLATED) as zipf:\n",
+        "    for txt_path in sorted(txt_dir.glob(\"fusion-t2i-*.txt\")):\n",
+        "        zipf.write(txt_path, arcname=txt_path.name)\n",
+        "\n",
+        "print(f\"✅ Updated ZIP created: {zip_path}\")\n",
+        "print(f\"   Contains {len(list(txt_dir.glob('fusion-t2i-*.txt')))} files\")"
+      ],
+      "metadata": {
+        "id": "gtoiWXwEBHP4"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}