Upload sort_parquets_by_category.ipynb

sort_parquets_by_category.ipynb

@@ -4,7 +4,11 @@
   "metadata": {
     "colab": {
       "provenance": [],
-      "gpuType": "T4"
+      "gpuType": "T4",
+      "collapsed_sections": [
+        "PvAtznhla3jS",
+        "fB-SLVdVQvA4"
+      ]
     },
     "kernelspec": {
       "name": "python3",
@@ -19,10 +23,21 @@
     {
       "cell_type": "markdown",
       "source": [
-        "Using https://huggingface.co/datasets/lodestones/booru-essence"
+        "Using https://huggingface.co/datasets/lodestones/booru-essence\n",
+        "\n",
+        "* Dowload the parquet from the huggingface huggingface repo and save to your google drive as /content/drive/MyDrive/booru_essence.parquet  and  /content/drive/MyDrive/e621_essence.parquet respectively"
       ],
       "metadata": {
-        "id": "U-yf5jnY3gSd"
+        "id": "oSQKdE5VYMoS"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Parquet Explorer"
+      ],
+      "metadata": {
+        "id": "PvAtznhla3jS"
       }
     },
     {
@@ -32,366 +47,467 @@
         "drive.mount('/content/drive')"
       ],
       "metadata": {
-        "id": "HFy5aDxM3G7O"
+        "id": "HFy5aDxM3G7O",
+        "outputId": "c64bc8f1-8416-4511-9927-04a8167402e5",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
       },
       "execution_count": null,
-      "outputs": []
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ]
     },
     {
       "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",
+        "# Step 1: Mount Google Drive\n",
+        "#from google.colab import drive\n",
+        "#drive.mount('/content/drive')\n",
         "\n",
-        "!pip install -q transformers scikit-learn umap-learn matplotlib tqdm\n",
+        "#@markdown paste .parquet file stored on your Google Drive folder to see its characteristics\n",
         "\n",
-        "import os\n",
-        "import re\n",
-        "import json\n",
-        "import numpy as np\n",
+        "# Step 2: Import required libraries\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",
+        "# Step 3: Define the path to the Parquet file\n",
+        "file_path = '/content/drive/MyDrive/booru_essence.parquet' #@param {type:'string'}\n",
         "\n",
-        "print(f\"Loading parquet from: {file_path}\")\n",
+        "# Step 4: Read the Parquet file\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",
+        "# Step 5: Basic exploration of the Parquet file\n",
+        "print(\"First 5 rows of the dataset:\")\n",
+        "print(df.head())\n",
         "\n",
-        "    return np.vstack(all_embs)\n",
+        "print(\"\\nDataset Info:\")\n",
+        "print(df.info())\n",
         "\n",
-        "# ============================================================\n",
-        "# 3. Process each rating group separately\n",
-        "# ============================================================\n",
-        "assert \"rating\" in df.columns, \"Column 'rating' not found!\"\n",
+        "print(\"\\nBasic Statistics:\")\n",
+        "print(df.describe())\n",
         "\n",
-        "# All results go ONLY to /content/output/\n",
-        "output_base = \"/content/output\"\n",
-        "os.makedirs(output_base, exist_ok=True)\n",
+        "print(\"\\nColumn Names:\")\n",
+        "print(df.columns.tolist())\n",
         "\n",
-        "unique_ratings = df[\"rating\"].dropna().unique().tolist()\n",
-        "print(f\"Found ratings: {unique_ratings}\")\n",
+        "print(\"\\nMissing Values:\")\n",
+        "print(df.isnull().sum())\n",
         "\n",
-        "for rating in unique_ratings:\n",
-        "    print(f\"\\n{'='*60}\")\n",
-        "    print(f\"Processing rating = '{rating}'\")\n",
-        "    print(f\"{'='*60}\")\n",
+        "# Optional: Display number of rows and columns\n",
+        "print(f\"\\nShape of the dataset: {df.shape}\")"
+      ],
+      "metadata": {
+        "id": "So-PKtbo5AVA",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "f029c8f6-d8b7-424b-ec0e-a98fda652b34"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "First 5 rows of the dataset:\n",
+            "                                url  image_width  image_height  \\\n",
+            "0  1c3e0a16ca474016d2d870605e607c14         2507          3541   \n",
+            "1  1d97251e72ac672625531d6da2754e0a          706          1000   \n",
+            "2  ce657d922d6b3689d759c5e1a7a0136d          644          1000   \n",
+            "3  2bf4eed7892f89f70f4f77ca8bc5fe5a         1000           690   \n",
+            "4  3eb89d65e51046de960e50913ad15065          850          1200   \n",
+            "\n",
+            "                                       brief_summary  \\\n",
+            "0                                               None   \n",
+            "1  NSFW anime image of Reimu Hakurei receiving an...   \n",
+            "2                                               None   \n",
+            "3  Flandre and Remilia Scarlet from *Touhou*, alo...   \n",
+            "4                                               None   \n",
+            "\n",
+            "                            midjourney_style_summary  \\\n",
+            "0                                               None   \n",
+            "1  Reimu Hakurei, Touhou character, anal sex, cum...   \n",
+            "2  Nami, One Piece character, lifting white shirt...   \n",
+            "3  Three Touhou Project characters, Flandre Scarl...   \n",
+            "4                                               None   \n",
+            "\n",
+            "                                                tags 10_word_summary  \\\n",
+            "0  1boy, 1girl, absurdres, ass, ass grab, bar cen...            None   \n",
+            "1  1boy, 1girl, ascot, ass, bar censor, bow, brow...            None   \n",
+            "2  1girl, :o, ?, areola slip, bad id, bad pixiv i...            None   \n",
+            "3  2girls, :d, ascot, bat wings, bed, blonde hair...            None   \n",
+            "4  1boy, 1girl, barefoot, blue archive, blush, bo...            None   \n",
+            "\n",
+            "  subreddit        rating  fav_count  ...  is_ai_generated  \\\n",
+            "0      None      explicit        574  ...             <NA>   \n",
+            "1      None      explicit        177  ...             <NA>   \n",
+            "2      None  questionable        575  ...             <NA>   \n",
+            "3      None       general        199  ...             <NA>   \n",
+            "4      None  questionable        114  ...             <NA>   \n",
+            "\n",
+            "                        created_at solo_subject  multi_subject  \\\n",
+            "0 2020-03-15 02:46:12.630000-07:00         True          False   \n",
+            "1 2023-02-11 10:11:05.214000-08:00         True          False   \n",
+            "2 2022-03-16 06:31:10.380000-07:00         True          False   \n",
+            "3 2011-05-27 03:03:52.099000-07:00        False           True   \n",
+            "4 2023-10-06 12:51:35.622000-07:00         True          False   \n",
+            "\n",
+            "                                     artist_weights  \\\n",
+            "0               {\"ebifurya\": 7.542241240977748e-06}   \n",
+            "1  {\"hammer_(sunset_beach)\": 7.783193106820236e-06}   \n",
+            "2           {\"yaegashi_nan\": 8.593942374516996e-06}   \n",
+            "3          {\"ruu_(tksymkw)\": 8.518144291024462e-06}   \n",
+            "4    {\"kouji_(campus_life)\": 8.428515205822908e-06}   \n",
+            "\n",
+            "                                   character_weights species_weights  \\\n",
+            "0       {\"hibiki_(kancolle)\": 8.120579857377395e-06}              {}   \n",
+            "1           {\"hakurei_reimu\": 4.829851527251942e-06}              {}   \n",
+            "2        {\"nami_(one_piece)\": 1.105513713098661e-05}              {}   \n",
+            "3  {\"bowser\": 8.348764728924828e-06, \"flandre_sca...              {}   \n",
+            "4    {\"yuzu_(blue_archive)\": 1.4766504894334119e-05}              {}   \n",
+            "\n",
+            "  sampling_probability    source               trigger_tag  \n",
+            "0             0.233719  danbooru               by ebifurya  \n",
+            "1             0.196160  danbooru  by hammer (sunset beach)  \n",
+            "2             0.284688  danbooru           by yaegashi nan  \n",
+            "3             0.228091  danbooru          by ruu (tksymkw)  \n",
+            "4             0.313498  danbooru    by kouji (campus life)  \n",
+            "\n",
+            "[5 rows x 21 columns]\n",
+            "\n",
+            "Dataset Info:\n",
+            "<class 'pandas.core.frame.DataFrame'>\n",
+            "RangeIndex: 19987 entries, 0 to 19986\n",
+            "Data columns (total 21 columns):\n",
+            " #   Column                    Non-Null Count  Dtype                              \n",
+            "---  ------                    --------------  -----                              \n",
+            " 0   url                       19987 non-null  object                             \n",
+            " 1   image_width               19987 non-null  int64                              \n",
+            " 2   image_height              19987 non-null  int64                              \n",
+            " 3   brief_summary             11230 non-null  object                             \n",
+            " 4   midjourney_style_summary  12797 non-null  object                             \n",
+            " 5   tags                      19987 non-null  object                             \n",
+            " 6   10_word_summary           0 non-null      object                             \n",
+            " 7   subreddit                 0 non-null      object                             \n",
+            " 8   rating                    19987 non-null  object                             \n",
+            " 9   fav_count                 19987 non-null  int64                              \n",
+            " 10  is_nsfw                   0 non-null      boolean                            \n",
+            " 11  is_ai_generated           0 non-null      boolean                            \n",
+            " 12  created_at                19987 non-null  datetime64[us, America/Los_Angeles]\n",
+            " 13  solo_subject              19987 non-null  bool                               \n",
+            " 14  multi_subject             19987 non-null  bool                               \n",
+            " 15  artist_weights            19987 non-null  object                             \n",
+            " 16  character_weights         19987 non-null  object                             \n",
+            " 17  species_weights           19987 non-null  object                             \n",
+            " 18  sampling_probability      19987 non-null  float32                            \n",
+            " 19  source                    19987 non-null  object                             \n",
+            " 20  trigger_tag               19987 non-null  object                             \n",
+            "dtypes: bool(2), boolean(2), datetime64[us, America/Los_Angeles](1), float32(1), int64(3), object(12)\n",
+            "memory usage: 2.6+ MB\n",
+            "None\n",
+            "\n",
+            "Basic Statistics:\n",
+            "        image_width  image_height     fav_count  sampling_probability\n",
+            "count  19987.000000  19987.000000  19987.000000          19987.000000\n",
+            "mean    1631.031120   1929.382298    209.043678              0.616547\n",
+            "std     1016.239287   1201.701401    193.320715              0.178348\n",
+            "min      250.000000    240.000000      0.000000              0.106295\n",
+            "25%      952.000000   1097.000000     79.000000              0.492193\n",
+            "50%     1311.000000   1540.000000    152.000000              0.593897\n",
+            "75%     2048.000000   2400.000000    277.000000              0.722180\n",
+            "max    29700.000000  27772.000000   2633.000000              1.382085\n",
+            "\n",
+            "Column Names:\n",
+            "['url', 'image_width', 'image_height', 'brief_summary', 'midjourney_style_summary', 'tags', '10_word_summary', 'subreddit', 'rating', 'fav_count', 'is_nsfw', 'is_ai_generated', 'created_at', 'solo_subject', 'multi_subject', 'artist_weights', 'character_weights', 'species_weights', 'sampling_probability', 'source', 'trigger_tag']\n",
+            "\n",
+            "Missing Values:\n",
+            "url                             0\n",
+            "image_width                     0\n",
+            "image_height                    0\n",
+            "brief_summary                8757\n",
+            "midjourney_style_summary     7190\n",
+            "tags                            0\n",
+            "10_word_summary             19987\n",
+            "subreddit                   19987\n",
+            "rating                          0\n",
+            "fav_count                       0\n",
+            "is_nsfw                     19987\n",
+            "is_ai_generated             19987\n",
+            "created_at                      0\n",
+            "solo_subject                    0\n",
+            "multi_subject                   0\n",
+            "artist_weights                  0\n",
+            "character_weights               0\n",
+            "species_weights                 0\n",
+            "sampling_probability            0\n",
+            "source                          0\n",
+            "trigger_tag                     0\n",
+            "dtype: int64\n",
+            "\n",
+            "Shape of the dataset: (19987, 21)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Create text files from parquet\n",
         "\n",
-        "    # Filter\n",
-        "    group = df[df[\"rating\"] == rating].copy().reset_index(drop=True)\n",
-        "    print(f\"  Rows: {len(group)}\")\n",
+        "Goals:\n",
+        "1) First , sort each parquet item inte separate groups. First by the parquet columns 'solo_subject'  vs 'multi_subject rating'. These columns are boolean values with True / False possible values. You will now have four boolean groups.\n",
         "\n",
-        "    # Build combined text\n",
-        "    group[\"combined_text\"] = group.apply(combine_texts, axis=1)\n",
+        "2) Then for each of these four boolean groups , sort the contents  by its 'rating'  category. The ratings are a string , and can be 'explicit' , 'sensitive' , 'questionable' or 'general'.   You should now have 16 groups. Assign a name to each group.\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",
+        "3) For each of the 16 groups ,  append the texts from the parquet columns 'brief_summary'  ,  'midjourney_style_summary' , and 'tags' into a single text for each item.  \n",
         "\n",
-        "    if len(group) < 2:\n",
-        "        print(\"  Skipping – not enough samples\")\n",
-        "        continue\n",
+        "4) Once each item has the full descriptive text , replace all double quations \" with single quotations ' .  \n",
         "\n",
-        "    texts = group[\"combined_text\"].tolist()\n",
+        "5) Make sure all commas , have one space before and one space after them.\n",
         "\n",
-        "    # Encode with T5\n",
-        "    embeddings = get_t5_embeddings(texts, batch_size=batch_size)\n",
-        "    print(f\"  Embeddings shape: {embeddings.shape}\")\n",
+        "5) For each text , remove all symbols of the following types:  { , } ,] , [ , | , ^ , / , \\\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",
+        "6) Replace all captilized letters for lowercase. Except for at the start of a sentence , or at the start of a quatation , for example 'Tree'\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",
+        "7) Once the T5 model is loaded , truncate the text for each item to 500 tokens in length\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",
+        "8) Encode the full descriptive texts using the T5 for each of the 12 group.\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",
+        "9) For each of the 12 groups , put similiar texts into folders using K-means. Each group may contain a maximum of 100 folders of similiar texts.\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",
+        "10) For each folder , create a txt file with the contents , using the format shown in the code. The dataset string should be enclosed with the {} symbols and each text should be separated by the | symbol , {text1|text2|....|text1000} . This txt file is javascript for a website. Make sure the indentation is correct.  The name of the group and folder id should be included in the javascript as strings.  Each txt file may contain a maximum of 1000 texts. Should the amount be exceeded , create more txt files until all texts within that similarity category are listed.\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(\"    ...\")"
+        "11) Package the txt files into a single zip file. The folder structure within the zip file should be sorted by its 12 groups , then by the similiar texts found within each folder.\n",
+        "\n"
       ],
       "metadata": {
-        "id": "3WfqNYWD7V-h"
-      },
-      "execution_count": null,
-      "outputs": []
+        "id": "fB-SLVdVQvA4"
+      }
     },
     {
       "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",
+        "#@title Complete Pipeline – All groups  → T5 → KMeans → JS TXT files → ZIP\n",
+        "# Merges booru_essence.parquet + e621_essence.parquet\n",
+        "# NEW: any txt file < 300 items is merged with other small clusters\n",
+        "\n",
+        "!pip install -q transformers scikit-learn tqdm\n",
+        "\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
         "\n",
         "import os\n",
         "import re\n",
         "import zipfile\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import torch\n",
         "from pathlib import Path\n",
+        "from transformers import T5Tokenizer, T5Model\n",
+        "from sklearn.cluster import KMeans\n",
         "from tqdm.auto import tqdm\n",
+        "import warnings\n",
+        "warnings.filterwarnings(\"ignore\")\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",
+        "file_path_booru = \"/content/drive/MyDrive/booru_essence.parquet\"\n",
+        "file_path_e621  = \"/content/drive/MyDrive/e621_essence.parquet\"\n",
+        "t5_model_name = \"t5-base\"                                   #@param [\"t5-small\", \"t5-base\"]\n",
+        "max_tokens = 500                                            #@param {type:\"slider\", min:128, max:512, step:32}\n",
+        "batch_size = 1                                              # fixed to 1\n",
+        "max_clusters_per_group = 10\n",
+        "max_texts_per_file = 1000\n",
+        "min_texts_per_file = 300                                    # NEW: minimum size before merging\n",
         "\n",
-        "name = \"booru_essence\"                                    #@param {type:\"string\"}\n",
-        "emoji = \"🏖️\"                                      #@param {type:\"string\"}\n",
-        "showComments = True\n",
-        "showDemo = True\n",
+        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "print(f\"Device: {device}\")\n",
+        "print(f\"Batch size: {batch_size}\")\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",
+        "output_base = Path(\"/content/output\")\n",
+        "js_root = output_base / \"js_files\"\n",
+        "os.makedirs(js_root, exist_ok=True)\n",
         "\n",
         "# ============================================================\n",
-        "# 1. Collect all cluster text files, sorted by rating then cluster number\n",
+        "# 0. Load both Parquets and combine\n",
         "# ============================================================\n",
-        "text_files = []\n",
+        "print(f\"Loading: {file_path_booru}\")\n",
+        "df_booru = pd.read_parquet(file_path_booru)\n",
+        "print(f\"  Shape: {df_booru.shape}\")\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",
+        "print(f\"Loading: {file_path_e621}\")\n",
+        "df_e621 = pd.read_parquet(file_path_e621)\n",
+        "print(f\"  Shape: {df_e621.shape}\")\n",
+        "\n",
+        "assert list(df_booru.columns) == list(df_e621.columns), \\\n",
+        "    \"Column structures differ between the two Parquet files!\"\n",
+        "\n",
+        "df = pd.concat([df_booru, df_e621], ignore_index=True)\n",
+        "print(f\"\\nCombined shape: {df.shape}\")\n",
+        "print(f\"Columns: {df.columns.tolist()}\")\n",
+        "\n",
+        "assert \"solo_subject\" in df.columns and df[\"solo_subject\"].dtype == bool\n",
+        "assert \"multi_subject\" in df.columns and df[\"multi_subject\"].dtype == bool\n",
+        "assert \"rating\" in df.columns\n",
+        "print(\"Unique ratings:\", df[\"rating\"].unique().tolist())\n",
+        "print(\"solo_subject value counts:\\n\", df[\"solo_subject\"].value_counts())\n",
+        "print(\"multi_subject value counts:\\n\", df[\"multi_subject\"].value_counts())\n",
         "\n",
         "# ============================================================\n",
-        "# 2. Helper: read prompts from a *_texts.txt file\n",
+        "# Helper: Text cleaning (Goals 3 → 6)\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",
+        "def clean_text(text: str) -> str:\n",
+        "    if not isinstance(text, str) or not text.strip():\n",
+        "        return \"\"\n",
+        "\n",
+        "    text = text.strip()\n",
+        "    text = text.replace('\"', \"'\")\n",
+        "    text = re.sub(r'\\s*,\\s*', ' , ', text)\n",
+        "    text = re.sub(r'[{}\\[\\]\\|\\^/\\\\]', '', text)\n",
+        "    text = re.sub(r'\\s+', ' ', text).strip()\n",
+        "\n",
+        "    def smart_case(s):\n",
+        "        parts = re.split(r'([.!?]\\s+)', s)\n",
+        "        result = []\n",
+        "        capitalize_next = True\n",
+        "\n",
+        "        for part in parts:\n",
+        "            if not part:\n",
+        "                continue\n",
+        "\n",
+        "            if capitalize_next and part and part[0].isalpha():\n",
+        "                part = part[0].upper() + part[1:].lower()\n",
+        "            else:\n",
+        "                part = part.lower()\n",
+        "\n",
+        "            part = re.sub(\n",
+        "                r\"(['‘’])([a-z])\",\n",
+        "                lambda m: m.group(1) + m.group(2).upper(),\n",
+        "                part\n",
+        "            )\n",
+        "\n",
+        "            result.append(part)\n",
+        "            capitalize_next = part.endswith(('.', '!', '?')) or bool(re.search(r'[.!?]\\s*$', part))\n",
+        "\n",
+        "        return ''.join(result)\n",
+        "\n",
+        "    return smart_case(text)\n",
+        "\n",
+        "\n",
+        "def combine_and_clean(row) -> str:\n",
+        "    parts = []\n",
+        "    for col in [\"brief_summary\", \"midjourney_style_summary\", \"tags\"]:\n",
+        "        val = row.get(col)\n",
+        "        if pd.isna(val) or val is None:\n",
+        "            continue\n",
+        "        t = str(val).strip()\n",
+        "        if t and t.lower() != \"none\":\n",
+        "            parts.append(t)\n",
+        "    combined = \" \".join(parts)\n",
+        "    return clean_text(combined)\n",
         "\n",
         "# ============================================================\n",
-        "# 3. Generate one .txt file per cluster\n",
+        "# 1 + 2. Create the groups (includes 'sensitive')\n",
         "# ============================================================\n",
-        "total = len(text_files)\n",
-        "generated_files = []\n",
+        "boolean_masks = {\n",
+        "    \"solo_true__multi_false\":  (df[\"solo_subject\"] == True)  & (df[\"multi_subject\"] == False),\n",
+        "    \"solo_false__multi_true\":  (df[\"solo_subject\"] == False) & (df[\"multi_subject\"] == True),\n",
+        "    \"solo_true__multi_true\":   (df[\"solo_subject\"] == True)  & (df[\"multi_subject\"] == True),\n",
+        "    \"solo_false__multi_false\": (df[\"solo_subject\"] == False) & (df[\"multi_subject\"] == False),\n",
+        "}\n",
         "\n",
-        "for idx, item in enumerate(tqdm(text_files, desc=\"Generating TXT files\"), start=1):\n",
-        "    prompts = load_prompts(item[\"path\"])\n",
+        "ratings = [\"explicit\", \"questionable\", \"general\", \"sensitive\"]\n",
+        "ratings = [r for r in ratings if r in df[\"rating\"].unique()]\n",
         "\n",
-        "    if not prompts:\n",
-        "        print(f\"  Skipping empty cluster: {item['path']}\")\n",
-        "        continue\n",
+        "groups = {}\n",
         "\n",
-        "    # Join all prompts with single \"|\"\n",
-        "    dataset_str = \"|\".join(prompts)\n",
+        "print(\"\\nCreating groups...\")\n",
+        "for bname, mask in boolean_masks.items():\n",
+        "    subset = df[mask]\n",
+        "    for rating in ratings:\n",
+        "        gname = f\"{bname}__{rating}\"\n",
+        "        gdf = subset[subset[\"rating\"] == rating].copy().reset_index(drop=True)\n",
+        "        groups[gname] = gdf\n",
+        "        print(f\"  {gname:45s} → {len(gdf):5d} rows\")\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",
+        "print(f\"\\nTotal groups: {len(groups)}\")\n",
         "\n",
-        "    if idx == total:\n",
-        "        forward = f'[\"fusion-t2i-{name}-{idx}\"]'\n",
-        "    else:\n",
-        "        forward = f'[\"fusion-t2i-{name}-{idx+1}\"]'\n",
+        "# ============================================================\n",
+        "# Load T5 encoder\n",
+        "# ============================================================\n",
+        "print(f\"\\nLoading {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):\n",
+        "    all_embs = []\n",
+        "    for i in tqdm(range(0, len(texts), batch_size), desc=\"Encoding\", leave=False):\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_tokens,\n",
+        "        ).to(device)\n",
+        "\n",
+        "        with torch.no_grad():\n",
+        "            outputs = model.encoder(**inputs)\n",
+        "            last_hidden = outputs.last_hidden_state\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\n",
+        "            all_embs.append(mean_pooled.cpu().numpy())\n",
+        "    return np.vstack(all_embs)\n",
+        "\n",
+        "# ============================================================\n",
+        "# Helper: write one JS file\n",
+        "# ============================================================\n",
+        "def write_js_file(cluster_dir, gname, folder_id, part_idx, chunk):\n",
+        "    dataset_str = \"{\" + \"|\".join(chunk) + \"}\"\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",
+        "group = \"{gname}\"\n",
+        "folder_id = \"{folder_id}\"\n",
+        "file_index = {part_idx + 1}\n",
+        "name = \"booru_essence\"\n",
+        "emoji = \"🏖️\"\n",
+        "showComments = true\n",
+        "showDemo = true\n",
+        "\n",
+        "pageTitle = [emoji] fusion-t2i-[name]-[group]-[folder_id]-[file_index]\n",
+        "pageDescription = Captioned works from booru parquet – {gname} – {folder_id}\n",
         "\n",
         "tagBlackListRaw = [\"\"]\n",
-        "tagBlackList= [tagBlackListRaw.replaceText(' ' , ',')]\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",
+        "backward = []\n",
+        "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",
+        "image_url = [\"https://www.iguides.ru/upload/iblock/ccf/ccf3e83b95a8b350d5089424687fc133.jpg\"]\n",
+        "image_description = [\"placeholder\"]\n",
+        "optional_image_caption = [\"placeholder\"]\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",
+        "  title = [emoji] [name] [group] [folder_id] [file_index]\n",
+        "  description = Subset of {gname} – {folder_id} – part {part_idx+1}\n",
+        "  image = https://i.imgur.com/TPHIzaa.jpeg\n",
         "$output\n",
         "  [dataset]\n",
         "\n",
-        "\n",
         "data = [(($output.selectMany(document.numItems).join(\" \")+' '))]\n",
         "\n",
         "dataset\n",
@@ -399,109 +515,124 @@
         "//----//\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",
+        "    filename = f\"fusion-t2i-booru_essence-{gname}-{folder_id}-part{part_idx+1:02d}.txt\"\n",
+        "    with open(cluster_dir / filename, \"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",
+        "# Process every group (Goals 3–10 + merge small files)\n",
         "# ============================================================\n",
-        "zip_path = \"/content/output/js_files.zip\"\n",
+        "for gname, group in groups.items():\n",
+        "    print(f\"\\n{'='*70}\")\n",
+        "    print(f\"Processing: {gname}\")\n",
+        "    print(f\"{'='*70}\")\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",
+        "    group = group.copy()\n",
+        "    group[\"cleaned_text\"] = group.apply(combine_and_clean, axis=1)\n",
+        "    group = group[group[\"cleaned_text\"].str.len() > 10].reset_index(drop=True)\n",
+        "    print(f\"  After cleaning: {len(group)} usable rows\")\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",
+        "    if len(group) < 2:\n",
+        "        print(\"  → Skipping (too few samples)\")\n",
+        "        continue\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",
+        "    texts = group[\"cleaned_text\"].tolist()\n",
         "\n",
-        "# ============================================================\n",
-        "# Process every file\n",
-        "# ============================================================\n",
-        "cleaned_count = 0\n",
+        "    # Goal 8: T5 embeddings\n",
+        "    embeddings = get_t5_embeddings(texts)\n",
+        "    print(f\"  Embeddings shape: {embeddings.shape}\")\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",
+        "    # Goal 9: K-Means\n",
+        "    k = min(max_clusters_per_group, max(2, len(group) // 8))\n",
+        "    k = min(k, len(group))\n",
+        "    print(f\"  Using k = {k}\")\n",
         "\n",
-        "    if cleaned != original:\n",
-        "        txt_path.write_text(cleaned, encoding=\"utf-8\")\n",
-        "        cleaned_count += 1\n",
+        "    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)\n",
+        "    labels = kmeans.fit_predict(embeddings)\n",
+        "    group[\"cluster\"] = labels\n",
         "\n",
-        "print(f\"\\n✅ Cleaned {cleaned_count} files (others already clean)\")\n",
+        "    # Collect texts per cluster\n",
+        "    cluster_texts_list = []\n",
+        "    for c in range(k):\n",
+        "        cluster_texts = group.loc[group[\"cluster\"] == c, \"cleaned_text\"].tolist()\n",
+        "        if cluster_texts:\n",
+        "            cluster_texts_list.append(cluster_texts)\n",
+        "\n",
+        "    # ----------------------------------------------------------\n",
+        "    # NEW: Separate large (≥300) and small (<300) clusters\n",
+        "    # ----------------------------------------------------------\n",
+        "    large_clusters = []\n",
+        "    small_pool = []\n",
+        "\n",
+        "    for texts in cluster_texts_list:\n",
+        "        if len(texts) >= min_texts_per_file:\n",
+        "            large_clusters.append(texts)\n",
+        "        else:\n",
+        "            small_pool.extend(texts)\n",
+        "\n",
+        "    print(f\"  Large clusters (≥{min_texts_per_file}): {len(large_clusters)}\")\n",
+        "    print(f\"  Texts moved to small pool: {len(small_pool)}\")\n",
+        "\n",
+        "    # Re-pack the small pool into chunks of size [min_texts_per_file .. max_texts_per_file]\n",
+        "    merged_small_clusters = []\n",
+        "    if small_pool:\n",
+        "        for start in range(0, len(small_pool), max_texts_per_file):\n",
+        "            chunk = small_pool[start : start + max_texts_per_file]\n",
+        "            # If the last chunk is still tiny and we have previous merged chunks,\n",
+        "            # try to attach it to the previous one (if it doesn't exceed max)\n",
+        "            if (len(chunk) < min_texts_per_file and merged_small_clusters\n",
+        "                    and len(merged_small_clusters[-1]) + len(chunk) <= max_texts_per_file):\n",
+        "                merged_small_clusters[-1].extend(chunk)\n",
+        "            else:\n",
+        "                merged_small_clusters.append(chunk)\n",
+        "\n",
+        "    # Final list of folders to write\n",
+        "    final_folders = large_clusters + merged_small_clusters\n",
+        "    print(f\"  Final folders after merging: {len(final_folders)}\")\n",
+        "\n",
+        "    # Create group directory\n",
+        "    group_dir = js_root / gname\n",
+        "    os.makedirs(group_dir, exist_ok=True)\n",
+        "\n",
+        "    for folder_idx, folder_texts in enumerate(final_folders):\n",
+        "        folder_id = f\"cluster_{folder_idx:03d}\"\n",
+        "        cluster_dir = group_dir / folder_id\n",
+        "        os.makedirs(cluster_dir, exist_ok=True)\n",
+        "\n",
+        "        # Split this folder into files of ≤ 1000 (already mostly handled, but keep safe)\n",
+        "        for part_idx, start in enumerate(range(0, len(folder_texts), max_texts_per_file)):\n",
+        "            chunk = folder_texts[start : start + max_texts_per_file]\n",
+        "            write_js_file(cluster_dir, gname, folder_id, part_idx, chunk)\n",
+        "\n",
+        "    print(f\"  → Saved under {group_dir}\")\n",
         "\n",
         "# ============================================================\n",
-        "# Re-create the ZIP with the cleaned files → saved to /content/\n",
+        "# Goal 11: Create ZIP with correct hierarchical structure\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",
+        "zip_path = \"/content/output/booru_essence_js_files.zip\"\n",
         "\n",
-        "print(f\"✅ Updated ZIP created: {zip_path}\")\n",
-        "print(f\"   Contains {len(list(txt_dir.glob('fusion-t2i-*.txt')))} files\")"
+        "with zipfile.ZipFile(zip_path, \"w\", zipfile.ZIP_DEFLATED) as zipf:\n",
+        "    for root, dirs, files in os.walk(js_root):\n",
+        "        for file in files:\n",
+        "            if file.endswith(\".txt\"):\n",
+        "                full = os.path.join(root, file)\n",
+        "                arcname = os.path.relpath(full, js_root)\n",
+        "                zipf.write(full, arcname=arcname)\n",
+        "\n",
+        "print(\"\\n\" + \"=\"*70)\n",
+        "print(\"✅ ALL DONE\")\n",
+        "print(f\"ZIP file: {zip_path}\")\n",
+        "print(\"Structure inside ZIP:\")\n",
+        "print(\"  solo_true__multi_false__explicit/\")\n",
+        "print(\"    cluster_000/\")\n",
+        "print(\"      fusion-t2i-....txt\")\n",
+        "print(\"    ...\")\n",
+        "print(\"  ... (all groups including *.__sensitive)\")\n",
+        "print(\"=\"*70)\n",
+        "print(\"Download the ZIP from the Colab file browser (left panel).\")"
       ],
       "metadata": {
-        "id": "gtoiWXwEBHP4"
+        "id": "SYVWeJZUf6SC"
       },
       "execution_count": null,
       "outputs": []