Upload CLIP_cluster.ipynb

CLIP_cluster.ipynb

@@ -1 +1 @@
-{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyNM2wFTbivtxP/G63GyRF0F"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"G9yAxL_ViF7y","executionInfo":{"status":"ok","timestamp":1760358446963,"user_tz":-120,"elapsed":24861,"user":{"displayName":"No Name","userId":"10578412414437288386"}},"outputId":"6ded074a-06d9-4ee1-f1b8-32d32876bdb8"},"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]}],"source":["from google.colab import drive\n","drive.mount('/content/drive')"]},{"cell_type":"markdown","source":["Install Required Libraries\n","Run this cell to install the necessary packages. CLIP requires PyTorch, and we'll use scikit-learn for clustering, along with Pillow for image loading and matplotlib for visualization."],"metadata":{"id":"ji2qFha2icZi"}},{"cell_type":"code","source":["!pip install ftfy regex tqdm\n","!pip install git+https://github.com/openai/CLIP.git\n","!pip install scikit-learn matplotlib pillow umap-learn  # UMAP is optional for 2D visualization"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"WncaEzzGiaO2","executionInfo":{"status":"ok","timestamp":1760358774006,"user_tz":-120,"elapsed":17248,"user":{"displayName":"No Name","userId":"10578412414437288386"}},"outputId":"b52bb03e-9f37-4e31-f9c5-a8f3333df365"},"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["Collecting ftfy\n","  Downloading ftfy-6.3.1-py3-none-any.whl.metadata (7.3 kB)\n","Requirement already satisfied: regex in /usr/local/lib/python3.12/dist-packages (2024.11.6)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.12/dist-packages (4.67.1)\n","Requirement already satisfied: wcwidth in /usr/local/lib/python3.12/dist-packages (from ftfy) (0.2.14)\n","Downloading ftfy-6.3.1-py3-none-any.whl (44 kB)\n","\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/44.8 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.8/44.8 kB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n","\u001b[?25hInstalling collected packages: ftfy\n","Successfully installed ftfy-6.3.1\n","Collecting git+https://github.com/openai/CLIP.git\n","  Cloning https://github.com/openai/CLIP.git to /tmp/pip-req-build-ndgp4kdw\n","  Running command git clone --filter=blob:none --quiet https://github.com/openai/CLIP.git /tmp/pip-req-build-ndgp4kdw\n","  Resolved https://github.com/openai/CLIP.git to commit dcba3cb2e2827b402d2701e7e1c7d9fed8a20ef1\n","  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n","Requirement already satisfied: ftfy in /usr/local/lib/python3.12/dist-packages (from clip==1.0) (6.3.1)\n","Requirement already satisfied: packaging in /usr/local/lib/python3.12/dist-packages (from clip==1.0) (25.0)\n","Requirement already satisfied: regex in /usr/local/lib/python3.12/dist-packages (from clip==1.0) (2024.11.6)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.12/dist-packages (from clip==1.0) (4.67.1)\n","Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (from clip==1.0) (2.8.0+cu126)\n","Requirement already satisfied: torchvision in /usr/local/lib/python3.12/dist-packages (from clip==1.0) (0.23.0+cu126)\n","Requirement already satisfied: wcwidth in /usr/local/lib/python3.12/dist-packages (from ftfy->clip==1.0) (0.2.14)\n","Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (3.20.0)\n","Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (4.15.0)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (75.2.0)\n","Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (1.13.3)\n","Requirement already satisfied: networkx in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (3.5)\n","Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (3.1.6)\n","Requirement already satisfied: fsspec in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (2025.3.0)\n","Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (12.6.77)\n","Requirement already satisfied: nvidia-cuda-runtime-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (12.6.77)\n","Requirement already satisfied: nvidia-cuda-cupti-cu12==12.6.80 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (12.6.80)\n","Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (9.10.2.21)\n","Requirement already satisfied: nvidia-cublas-cu12==12.6.4.1 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (12.6.4.1)\n","Requirement already satisfied: nvidia-cufft-cu12==11.3.0.4 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (11.3.0.4)\n","Requirement already satisfied: nvidia-curand-cu12==10.3.7.77 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (10.3.7.77)\n","Requirement already satisfied: nvidia-cusolver-cu12==11.7.1.2 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (11.7.1.2)\n","Requirement already satisfied: nvidia-cusparse-cu12==12.5.4.2 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (12.5.4.2)\n","Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (0.7.1)\n","Requirement already satisfied: nvidia-nccl-cu12==2.27.3 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (2.27.3)\n","Requirement already satisfied: nvidia-nvtx-cu12==12.6.77 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (12.6.77)\n","Requirement already satisfied: nvidia-nvjitlink-cu12==12.6.85 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (12.6.85)\n","Requirement already satisfied: nvidia-cufile-cu12==1.11.1.6 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (1.11.1.6)\n","Requirement already satisfied: triton==3.4.0 in /usr/local/lib/python3.12/dist-packages (from torch->clip==1.0) (3.4.0)\n","Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from torchvision->clip==1.0) (2.0.2)\n","Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.12/dist-packages (from torchvision->clip==1.0) (11.3.0)\n","Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch->clip==1.0) (1.3.0)\n","Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch->clip==1.0) (3.0.3)\n","Building wheels for collected packages: clip\n","  Building wheel for clip (setup.py) ... \u001b[?25l\u001b[?25hdone\n","  Created wheel for clip: filename=clip-1.0-py3-none-any.whl size=1369490 sha256=870bb3264c62c61cbf9216fc996650d209184437f984e7371c66f5e0a0a23e92\n","  Stored in directory: /tmp/pip-ephem-wheel-cache-ipm8lt_a/wheels/35/3e/df/3d24cbfb3b6a06f17a2bfd7d1138900d4365d9028aa8f6e92f\n","Successfully built clip\n","Installing collected packages: clip\n","Successfully installed clip-1.0\n","Requirement already satisfied: scikit-learn in /usr/local/lib/python3.12/dist-packages (1.6.1)\n","Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.12/dist-packages (11.3.0)\n","Requirement already satisfied: umap-learn in /usr/local/lib/python3.12/dist-packages (0.5.9.post2)\n","Requirement already satisfied: numpy>=1.19.5 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (2.0.2)\n","Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.16.2)\n","Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.5.2)\n","Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (3.6.0)\n","Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n","Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n","Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.60.1)\n","Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.4.9)\n","Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (25.0)\n","Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.2.5)\n","Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (2.9.0.post0)\n","Requirement already satisfied: numba>=0.51.2 in /usr/local/lib/python3.12/dist-packages (from umap-learn) (0.60.0)\n","Requirement already satisfied: pynndescent>=0.5 in /usr/local/lib/python3.12/dist-packages (from umap-learn) (0.5.13)\n","Requirement already satisfied: tqdm in /usr/local/lib/python3.12/dist-packages (from umap-learn) (4.67.1)\n","Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.12/dist-packages (from numba>=0.51.2->umap-learn) (0.43.0)\n","Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n"]}]},{"cell_type":"markdown","source":["Load Images and Extract CLIP Embeddings\n","Replace `/path/to/your/images` with your image directory (e.g., `/content/uploaded_images` for uploaded files or `/content/drive/MyDrive/images` for Drive).\n","\n","This code loads all images (supports JPG, PNG, etc.), preprocesses them, and extracts 512-dimensional embeddings using the ViT-B/32 CLIP model."],"metadata":{"id":"EnqyKHcOilVA"}},{"cell_type":"code","source":["import os\n","import numpy as np\n","import torch\n","import clip\n","from PIL import Image\n","import matplotlib.pyplot as plt\n","from sklearn.cluster import KMeans\n","from sklearn.metrics import silhouette_score\n","import warnings\n","warnings.filterwarnings('ignore')\n","\n","# Configuration\n","image_dir = '/content/'  # Update this path\n","device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n","model_name = \"ViT-B/32\"  # You can use \"RN50\" for a different model\n","\n","# Load CLIP model\n","model, preprocess = clip.load(model_name, device=device)\n","\n","# Load images and extract embeddings\n","image_paths = []\n","embeddings = []\n","image_names = []\n","\n","for filename in os.listdir(image_dir):\n","    if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp')):\n","        img_path = os.path.join(image_dir, filename)\n","        try:\n","            image = preprocess(Image.open(img_path)).unsqueeze(0).to(device)\n","            with torch.no_grad():\n","                embedding = model.encode_image(image)\n","            embeddings.append(embedding.cpu().numpy().flatten())\n","            image_paths.append(img_path)\n","            image_names.append(filename)\n","            print(f\"Processed: {filename}\")\n","        except Exception as e:\n","            print(f\"Error processing {filename}: {e}\")\n","\n","embeddings = np.array(embeddings)\n","print(f\"Extracted embeddings for {len(embeddings)} images. Shape: {embeddings.shape}\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"RdhFcrT6ikh6","executionInfo":{"status":"ok","timestamp":1760358860027,"user_tz":-120,"elapsed":42782,"user":{"displayName":"No Name","userId":"10578412414437288386"}},"outputId":"d5c6ad5f-0eb2-46df-c9c5-5a57528c1e05"},"execution_count":3,"outputs":[{"output_type":"stream","name":"stderr","text":["100%|███████████████████████████████████████| 338M/338M [00:05<00:00, 61.4MiB/s]\n"]},{"output_type":"stream","name":"stdout","text":["Processed: IMG_7555.jpeg\n","Processed: IMG_7588.jpeg\n","Processed: IMG_7538.jpeg\n","Processed: IMG_7587.jpeg\n","Processed: IMG_7569.jpeg\n","Processed: IMG_7602.jpeg\n","Processed: IMG_7608.jpeg\n","Processed: IMG_7627.jpeg\n","Processed: IMG_7575.jpeg\n","Processed: IMG_7552.jpeg\n","Processed: IMG_7537.jpeg\n","Processed: IMG_7578.jpeg\n","Processed: IMG_7589.jpeg\n","Processed: IMG_7533.jpeg\n","Processed: IMG_7629.png\n","Processed: IMG_7618.jpeg\n","Processed: IMG_7623.jpeg\n","Processed: IMG_7594.jpeg\n","Processed: IMG_7556.jpeg\n","Processed: IMG_7577.jpeg\n","Processed: IMG_7630.png\n","Processed: IMG_7564.jpeg\n","Processed: IMG_7604.jpeg\n","Processed: IMG_7560.jpeg\n","Processed: IMG_7550.jpeg\n","Processed: IMG_7531.jpeg\n","Processed: IMG_7522.jpeg\n","Processed: IMG_7567.jpeg\n","Processed: IMG_7526.jpeg\n","Processed: IMG_7542.jpeg\n","Processed: IMG_7584.jpeg\n","Processed: IMG_7583.jpeg\n","Processed: IMG_7539.jpeg\n","Processed: IMG_7571.jpeg\n","Processed: IMG_7611.jpeg\n","Processed: IMG_7576.jpeg\n","Processed: IMG_7626.jpeg\n","Processed: IMG_7607.jpeg\n","Processed: IMG_7568.jpeg\n","Processed: IMG_7530.jpeg\n","Processed: IMG_7585.jpeg\n","Processed: IMG_7553.jpeg\n","Processed: IMG_7565.jpeg\n","Processed: IMG_7557.jpeg\n","Processed: IMG_7597.jpeg\n","Processed: IMG_7566.jpeg\n","Processed: IMG_7528.jpeg\n","Processed: IMG_7546.jpeg\n","Processed: IMG_7615.jpeg\n","Processed: IMG_7590.jpeg\n","Processed: IMG_7554.jpeg\n","Processed: IMG_7606.jpeg\n","Processed: IMG_7561.jpeg\n","Processed: IMG_7614.jpeg\n","Processed: IMG_7579.jpeg\n","Processed: IMG_7541.jpeg\n","Processed: IMG_7551.jpeg\n","Processed: IMG_7598.jpeg\n","Processed: IMG_7563.jpeg\n","Processed: IMG_7591.jpeg\n","Processed: IMG_7613.jpeg\n","Processed: IMG_7616.jpeg\n","Processed: IMG_7609.jpeg\n","Processed: IMG_7617.jpeg\n","Processed: IMG_7549.jpeg\n","Processed: IMG_7525.jpeg\n","Processed: IMG_7535.jpeg\n","Processed: IMG_7621.jpeg\n","Processed: IMG_7620.jpeg\n","Processed: IMG_7543.jpeg\n","Processed: IMG_7622.jpeg\n","Processed: IMG_7595.jpeg\n","Processed: IMG_7628.jpeg\n","Processed: IMG_7524.jpeg\n","Processed: IMG_7600.jpeg\n","Processed: IMG_7625.jpeg\n","Processed: IMG_7540.jpeg\n","Processed: IMG_7544.jpeg\n","Processed: IMG_7581.jpeg\n","Processed: IMG_7593.jpeg\n","Processed: IMG_7603.jpeg\n","Processed: IMG_7580.jpeg\n","Processed: IMG_7572.jpeg\n","Processed: IMG_7612.jpeg\n","Processed: IMG_7547.jpeg\n","Processed: IMG_7599.jpeg\n","Processed: IMG_7521.jpeg\n","Processed: IMG_7527.jpeg\n","Processed: IMG_7582.jpeg\n","Processed: IMG_7574.jpeg\n","Processed: IMG_7523.jpeg\n","Processed: IMG_7586.jpeg\n","Processed: IMG_7548.jpeg\n","Processed: IMG_7601.jpeg\n","Processed: IMG_7529.jpeg\n","Processed: IMG_7605.jpeg\n","Processed: IMG_7592.jpeg\n","Processed: IMG_7573.jpeg\n","Processed: IMG_7624.jpeg\n","Processed: IMG_7610.jpeg\n","Extracted embeddings for 100 images. Shape: (100, 512)\n"]}]},{"cell_type":"markdown","source":["Perform Clustering\n","We'll use K-Means clustering on the embeddings. You can choose the number of clusters (`n_clusters`) based on your dataset size (e.g., try 5-10). We'll also compute the silhouette score to evaluate cluster quality (higher is better).\n","\n","For visualization, we'll optionally reduce dimensions to 2D using UMAP."],"metadata":{"id":"HQsc2r-ii6cK"}},{"cell_type":"code","source":["from umap import UMAP  # For 2D projection (optional)\n","\n","# Choose number of clusters (experiment with this)\n","n_clusters = 5  # Adjust based on your data\n","\n","# Perform K-Means clustering\n","kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)\n","cluster_labels = kmeans.fit_predict(embeddings)\n","\n","# Evaluate clustering quality\n","sil_score = silhouette_score(embeddings, cluster_labels)\n","print(f\"Silhouette Score: {sil_score:.3f} (closer to 1 is better)\")\n","\n","# Optional: 2D visualization with UMAP\n","reducer = UMAP(random_state=42, n_components=2)\n","embed_2d = reducer.fit_transform(embeddings)\n","\n","plt.figure(figsize=(10, 8))\n","scatter = plt.scatter(embed_2d[:, 0], embed_2d[:, 1], c=cluster_labels, cmap='tab10', s=50)\n","plt.colorbar(scatter)\n","plt.title(f'2D UMAP Projection of CLIP Embeddings (K={n_clusters} Clusters)')\n","plt.xlabel('UMAP 1')\n","plt.ylabel('UMAP 2')\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":305},"id":"WM9wug70jCtR","executionInfo":{"status":"ok","timestamp":1760358888422,"user_tz":-120,"elapsed":20513,"user":{"displayName":"No Name","userId":"10578412414437288386"}},"outputId":"e4da9611-98bd-449e-9c3f-bb8cde2e59c5"},"execution_count":4,"outputs":[{"output_type":"stream","name":"stdout","text":["Silhouette Score: 0.080 (closer to 1 is better)\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1000x800 with 2 Axes>"],"image/png":"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\n"},"metadata":{}}]},{"cell_type":"markdown","source":["Sort Images into Clusters\n","This creates subdirectories for each cluster and moves/copies the images there. Set `move_files=True` to move (or False to copy)."],"metadata":{"id":"aWSOgPj5jLLI"}},{"cell_type":"code","source":["import shutil\n","\n","# Create cluster directories\n","output_dir = '/content/clusters'  # Output base directory (change if needed)\n","os.makedirs(output_dir, exist_ok=True)\n","\n","move_files = False  # Set to True to move files, False to copy\n","\n","for i in range(n_clusters):\n","    cluster_dir = os.path.join(output_dir, f'cluster_{i}')\n","    os.makedirs(cluster_dir, exist_ok=True)\n","\n","# Assign and sort images\n","for idx, label in enumerate(cluster_labels):\n","    src_path = image_paths[idx]\n","    dst_path = os.path.join(output_dir, f'cluster_{label}', image_names[idx])\n","    if move_files:\n","        shutil.move(src_path, dst_path)\n","    else:\n","        shutil.copy2(src_path, dst_path)\n","    print(f\"Assigned {image_names[idx]} to cluster_{label}\")\n","\n","print(f\"Images sorted into {n_clusters} clusters in '{output_dir}'\")"],"metadata":{"id":"93e1ba60jQw2"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Visualize Sample Images per Cluster\n","Display a few sample images from each cluster to inspect the results."],"metadata":{"id":"Tg_q68KnjUb5"}},{"cell_type":"code","source":["def display_cluster_samples(cluster_dir, n_samples=3):\n","    images = [f for f in os.listdir(cluster_dir) if f.lower().endswith(('.png', '.jpg', '.jpeg'))][:n_samples]\n","    if not images:\n","        print(f\"No images in {cluster_dir}\")\n","        return\n","\n","    fig, axs = plt.subplots(1, len(images), figsize=(5 * len(images), 5))\n","    if len(images) == 1:\n","        axs = [axs]\n","    for j, img_file in enumerate(images):\n","        img_path = os.path.join(cluster_dir, img_file)\n","        img = Image.open(img_path)\n","        axs[j].imshow(img)\n","        axs[j].set_title(img_file)\n","        axs[j].axis('off')\n","    plt.show()\n","\n","# Display samples from each cluster\n","for i in range(n_clusters):\n","    cluster_dir = os.path.join(output_dir, f'cluster_{i}')\n","    print(f\"\\nSamples from Cluster {i}:\")\n","    display_cluster_samples(cluster_dir)"],"metadata":{"id":"uByZnmR5ja8T"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Tips and Next Steps\n","- **Choosing `n_clusters`**: Run the clustering cell multiple times with different values and pick the one with the highest silhouette score. Alternatively, use elbow method or silhouette analysis for more advanced selection.\n","- **Alternative Clustering**: For density-based clustering (handles varying cluster sizes better), replace K-Means with HDBSCAN: `!pip install hdbscan` and use `from hdbscan import HDBSCAN; clusterer = HDBSCAN(min_cluster_size=5); cluster_labels = clusterer.fit_predict(embeddings)`.\n","- **Larger Datasets**: If you have thousands of images, batch the embedding extraction to avoid memory issues.\n","- **Custom Prompts**: CLIP is multimodal— you could refine clusters by comparing image embeddings to text prompts (e.g., `model.encode_text(clip.tokenize([\"a photo of a dog\", \"a photo of a car\"]))`).\n","- **Download Results**: Right-click the `/content/clusters` folder in the Colab file browser and download as ZIP."],"metadata":{"id":"YHzdjp6sjeUH"}}]}
+{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyNM2wFTbivtxP/G63GyRF0F"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","execution_count":null,"metadata":{"id":"G9yAxL_ViF7y"},"outputs":[],"source":["from google.colab import drive\n","drive.mount('/content/drive')"]},{"cell_type":"markdown","source":["Install Required Libraries\n","Run this cell to install the necessary packages. CLIP requires PyTorch, and we'll use scikit-learn for clustering, along with Pillow for image loading and matplotlib for visualization."],"metadata":{"id":"ji2qFha2icZi"}},{"cell_type":"code","source":["!pip install ftfy regex tqdm\n","!pip install git+https://github.com/openai/CLIP.git\n","!pip install scikit-learn matplotlib pillow umap-learn  # UMAP is optional for 2D visualization"],"metadata":{"id":"WncaEzzGiaO2"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Load Images and Extract CLIP Embeddings\n","Replace `/path/to/your/images` with your image directory (e.g., `/content/uploaded_images` for uploaded files or `/content/drive/MyDrive/images` for Drive).\n","\n","This code loads all images (supports JPG, PNG, etc.), preprocesses them, and extracts 512-dimensional embeddings using the ViT-B/32 CLIP model."],"metadata":{"id":"EnqyKHcOilVA"}},{"cell_type":"code","source":["import os\n","import numpy as np\n","import torch\n","import clip\n","from PIL import Image\n","import matplotlib.pyplot as plt\n","from sklearn.cluster import KMeans\n","from sklearn.metrics import silhouette_score\n","import warnings\n","warnings.filterwarnings('ignore')\n","\n","# Configuration\n","image_dir = '/content/'  # Update this path\n","device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n","model_name = \"ViT-B/32\"  # You can use \"RN50\" for a different model\n","\n","# Load CLIP model\n","model, preprocess = clip.load(model_name, device=device)\n","\n","# Load images and extract embeddings\n","image_paths = []\n","embeddings = []\n","image_names = []\n","\n","for filename in os.listdir(image_dir):\n","    if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp')):\n","        img_path = os.path.join(image_dir, filename)\n","        try:\n","            image = preprocess(Image.open(img_path)).unsqueeze(0).to(device)\n","            with torch.no_grad():\n","                embedding = model.encode_image(image)\n","            embeddings.append(embedding.cpu().numpy().flatten())\n","            image_paths.append(img_path)\n","            image_names.append(filename)\n","            print(f\"Processed: {filename}\")\n","        except Exception as e:\n","            print(f\"Error processing {filename}: {e}\")\n","\n","embeddings = np.array(embeddings)\n","print(f\"Extracted embeddings for {len(embeddings)} images. Shape: {embeddings.shape}\")"],"metadata":{"id":"RdhFcrT6ikh6"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Perform Clustering\n","We'll use K-Means clustering on the embeddings. You can choose the number of clusters (`n_clusters`) based on your dataset size (e.g., try 5-10). We'll also compute the silhouette score to evaluate cluster quality (higher is better).\n","\n","For visualization, we'll optionally reduce dimensions to 2D using UMAP."],"metadata":{"id":"HQsc2r-ii6cK"}},{"cell_type":"code","source":["from umap import UMAP  # For 2D projection (optional)\n","\n","# Choose number of clusters (experiment with this)\n","n_clusters = 5  # Adjust based on your data\n","\n","# Perform K-Means clustering\n","kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)\n","cluster_labels = kmeans.fit_predict(embeddings)\n","\n","# Evaluate clustering quality\n","sil_score = silhouette_score(embeddings, cluster_labels)\n","print(f\"Silhouette Score: {sil_score:.3f} (closer to 1 is better)\")\n","\n","# Optional: 2D visualization with UMAP\n","reducer = UMAP(random_state=42, n_components=2)\n","embed_2d = reducer.fit_transform(embeddings)\n","\n","plt.figure(figsize=(10, 8))\n","scatter = plt.scatter(embed_2d[:, 0], embed_2d[:, 1], c=cluster_labels, cmap='tab10', s=50)\n","plt.colorbar(scatter)\n","plt.title(f'2D UMAP Projection of CLIP Embeddings (K={n_clusters} Clusters)')\n","plt.xlabel('UMAP 1')\n","plt.ylabel('UMAP 2')\n","plt.show()"],"metadata":{"id":"WM9wug70jCtR"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Sort Images into Clusters\n","This creates subdirectories for each cluster and moves/copies the images there. Set `move_files=True` to move (or False to copy)."],"metadata":{"id":"aWSOgPj5jLLI"}},{"cell_type":"code","source":["import shutil\n","\n","# Create cluster directories\n","output_dir = '/content/clusters'  # Output base directory (change if needed)\n","os.makedirs(output_dir, exist_ok=True)\n","\n","move_files = False  # Set to True to move files, False to copy\n","\n","for i in range(n_clusters):\n","    cluster_dir = os.path.join(output_dir, f'cluster_{i}')\n","    os.makedirs(cluster_dir, exist_ok=True)\n","\n","# Assign and sort images\n","for idx, label in enumerate(cluster_labels):\n","    src_path = image_paths[idx]\n","    dst_path = os.path.join(output_dir, f'cluster_{label}', image_names[idx])\n","    if move_files:\n","        shutil.move(src_path, dst_path)\n","    else:\n","        shutil.copy2(src_path, dst_path)\n","    print(f\"Assigned {image_names[idx]} to cluster_{label}\")\n","\n","print(f\"Images sorted into {n_clusters} clusters in '{output_dir}'\")"],"metadata":{"id":"93e1ba60jQw2"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Visualize Sample Images per Cluster\n","Display a few sample images from each cluster to inspect the results."],"metadata":{"id":"Tg_q68KnjUb5"}},{"cell_type":"code","source":["def display_cluster_samples(cluster_dir, n_samples=3):\n","    images = [f for f in os.listdir(cluster_dir) if f.lower().endswith(('.png', '.jpg', '.jpeg'))][:n_samples]\n","    if not images:\n","        print(f\"No images in {cluster_dir}\")\n","        return\n","\n","    fig, axs = plt.subplots(1, len(images), figsize=(5 * len(images), 5))\n","    if len(images) == 1:\n","        axs = [axs]\n","    for j, img_file in enumerate(images):\n","        img_path = os.path.join(cluster_dir, img_file)\n","        img = Image.open(img_path)\n","        axs[j].imshow(img)\n","        axs[j].set_title(img_file)\n","        axs[j].axis('off')\n","    plt.show()\n","\n","# Display samples from each cluster\n","for i in range(n_clusters):\n","    cluster_dir = os.path.join(output_dir, f'cluster_{i}')\n","    print(f\"\\nSamples from Cluster {i}:\")\n","    display_cluster_samples(cluster_dir)"],"metadata":{"id":"uByZnmR5ja8T"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Tips and Next Steps\n","- **Choosing `n_clusters`**: Run the clustering cell multiple times with different values and pick the one with the highest silhouette score. Alternatively, use elbow method or silhouette analysis for more advanced selection.\n","- **Alternative Clustering**: For density-based clustering (handles varying cluster sizes better), replace K-Means with HDBSCAN: `!pip install hdbscan` and use `from hdbscan import HDBSCAN; clusterer = HDBSCAN(min_cluster_size=5); cluster_labels = clusterer.fit_predict(embeddings)`.\n","- **Larger Datasets**: If you have thousands of images, batch the embedding extraction to avoid memory issues.\n","- **Custom Prompts**: CLIP is multimodal— you could refine clusters by comparing image embeddings to text prompts (e.g., `model.encode_text(clip.tokenize([\"a photo of a dog\", \"a photo of a car\"]))`).\n","- **Download Results**: Right-click the `/content/clusters` folder in the Colab file browser and download as ZIP."],"metadata":{"id":"YHzdjp6sjeUH"}}]}