panopticml 0.0.2__tar.gz

panopticml-0.0.2/.github/workflows/hatch-build-and-publish.yml

@@ -0,0 +1,140 @@
+name: Hatch Build and Publish
+run-name: HATCH to PyPI by @${{ github.actor }}
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - 'v*.*.*'
+
+permissions:
+  contents: write
+  packages: write
+  id-token: write
+
+jobs:
+  get-ref:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get current branch
+        id: check_step
+        run: |
+          raw=$(git branch -r --contains ${{ github.ref }})
+          if [[ -z "$raw" ]]; then
+            raw=$(git branch -r --contains ${{ github.sha }})
+          fi
+          if [[ -z "$raw" ]]; then
+            echo "No branch found for ${{ github.ref }} or ${{ github.sha }}."
+            echo "This is probably a tag push without a branch."
+            exit 1
+          fi
+          BRANCH=${raw##*/}
+          BRANCH=$(echo $BRANCH | base64 -w 0)
+          echo "BRANCH=$BRANCH" >> $GITHUB_OUTPUT
+          echo "Branch is $BRANCH."
+
+    outputs:
+      branch-name: ${{ steps.check_step.outputs.BRANCH }}
+
+  get-tag:
+    runs-on: ubuntu-latest
+    needs: get-ref
+    steps:
+      - name: Decode ref
+        id: decode_ref
+        run: |
+          name=${{ needs.get-ref.outputs.branch-name }}
+          name=$(echo $name | base64 -d)
+          echo "NAME=$name" >> $GITHUB_ENV
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+            ref: ${{ env.NAME }}
+            fetch-depth: 0
+
+      - name: Set env
+        id: set-env
+        run: |
+          if [[ "${{ github.event_name }}" == "push" ]]; then
+            TAG=$(echo $GITHUB_REF | cut -d / -f 3)
+            echo "TAG=$TAG" >> $GITHUB_ENV
+          fi
+
+    outputs:
+      tag: ${{ env.TAG }}
+
+  deploy:
+    runs-on: ubuntu-latest
+    environment: release
+    needs:
+        - get-ref
+        - get-tag
+    steps:
+      - name: Decode ref
+        id: decode_ref
+        run: |
+          name=${{ needs.get-ref.outputs.branch-name }}
+          echo "Encoded ref is $name"
+          name=$(echo $name | base64 -d)
+          echo "Decoded ref is $name"
+          echo "REF=$name" >> $GITHUB_ENV
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ env.REF }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+          cache: 'pip'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip 
+          pip install hatch
+
+      - name: Version bump
+        if : ${{ github.event_name != 'push' }}
+        run: |
+          hatch version fix
+          echo "Version bumped"
+
+      - name: Version from tag
+        if : ${{ github.event_name == 'push' }}
+        run: |
+          TAG=${{ needs.get-tag.outputs.tag }}
+          echo "TAG=$TAG"
+          hatch version $TAG 
+          # && echo "Version set to $TAG" || echo "Version already exists" && exit 1
+
+      - name: Build package
+        run: hatch build
+
+      - name: Publish package
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }} # PYPI_API_TOKEN
+#          repository-url: https://test.pypi.org/legacy/ # uncomment for test.pypi.org
+
+      - name: Update the about.py file
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "Update about.py file"
+          file_pattern: "version.py"
+          status_options: '--untracked-files=no'
+
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ env.REF }}

panopticml-0.0.2/.github/workflows/workflow.yaml

@@ -0,0 +1,38 @@
+name: Tests Multi-Plateformes
+
+# Déclenchement manuel uniquement
+on:
+  workflow_dispatch:
+
+jobs:
+  test:
+    name: "Tests sur ${{ matrix.os }} : ${{ matrix.python-version }}"
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      # Continue même si un OS échoue
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ['3.10', '3.11', '3.12']
+
+    steps:
+    - name: Checkout du code
+      uses: actions/checkout@v4
+
+    - name: Configuration de Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Mise à jour de pip
+      run: python -m pip install --upgrade pip
+
+    - name: Installation des dépendances
+      run: |
+        pip install pytest
+        pip install panoptic
+        pip install -r requirements.txt
+
+    - name: Lancement des tests avec pytest
+      run: pytest -v

panopticml-0.0.2/.gitignore

@@ -0,0 +1,201 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+.DS_Store
+dist
+dist-ssr
+coverage
+*.local
+
+/cypress/videos/
+/cypress/screenshots/
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+*/__pycache__/
+
+/panoptic_back/test.json
+# /panoptic_back/*.db
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.vscode
+
+mini/
+
+*.pkl
+

panopticml-0.0.2/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: panopticml
+Version: 0.0.2
+Summary: A package for Panoptic ML
+Project-URL: Homepage, https://github.com/CERES-Sorbonne/PanopticML
+Project-URL: Bug Tracker, https://github.com/CERES-Sorbonne/PanopticML/issues
+Author-email: Félix Alié <felix.alie@sorbonne-universite.fr>
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: faiss-cpu<1.11.0
+Requires-Dist: hdbscan
+Requires-Dist: mistralai
+Requires-Dist: numpy; platform_system != 'Darwin'
+Requires-Dist: numpy<=1.26.0; platform_system == 'Darwin'
+Requires-Dist: scikit-learn; platform_system != 'Darwin'
+Requires-Dist: scikit-learn==1.5.0; platform_system == 'Darwin'
+Requires-Dist: scipy
+Requires-Dist: torch; platform_system != 'Darwin'
+Requires-Dist: torch==2.1.0; platform_system == 'Darwin'
+Requires-Dist: torchvision
+Requires-Dist: transformers<4.52.0
+Description-Content-Type: text/markdown
+
+# PanopticML
+
+Default plugin for panoptic, provides all machine learning functionalities such as:
+- image embeddings using OpenAI CLIP
+- images clustering using FAISS Kmeans or HDBScan
+- images to images similarity using FAISS Index L2
+- text to images similarity using FAISS Index L2 + CLIP
+
+## Available models
+
+Several models are available in this plugin to compute the embeddings: 
+- [google mobilenet](https://huggingface.co/google/mobilenet_v2_1.4_224): a really light model with lower performances but made to run on bad devices, no support for text similarity
+- [openAI CLIP](https://huggingface.co/openai/clip-vit-large-patch14): default model for panoptic, good performances, runs well on most computers with a decent CPU, support text similarity and has a good understanding of semantics
+- [meta dinosV2](https://huggingface.co/docs/transformers/en/model_doc/dinov2): model that will have better performances than CLIP on pure visual similarities but less understanding of themes and semantics, no support for text similarity, runs well on CPU
+- [google SIGLIP2](https://huggingface.co/docs/transformers/main/model_doc/siglip2): computing heavy model, NVDIA GPU recommended but works also on CPU (it will take a long time to compute embeddings), way better results than CLIP on text similarity and semantics, and pretty good visual features
+- auto transformers: want to tryout any huggingface multimodal model ? you can just provide its id to panopticML and should be able to use it directly
+
+## Clustering functions
+- Kmeans: specify a number of clusters, really fast
+- HDBScan: automatic number of clusters, a bit slower and excludes a lot of images
+- Images to text: considering several texts, create a cluster per text and put each image to the text it is the closest to
+- Find duplicates: create clusters with only images sharing a lot of similarity together, good to find duplicates or near duplicates

panopticml-0.0.2/README.md

@@ -0,0 +1,22 @@
+# PanopticML
+
+Default plugin for panoptic, provides all machine learning functionalities such as:
+- image embeddings using OpenAI CLIP
+- images clustering using FAISS Kmeans or HDBScan
+- images to images similarity using FAISS Index L2
+- text to images similarity using FAISS Index L2 + CLIP
+
+## Available models
+
+Several models are available in this plugin to compute the embeddings: 
+- [google mobilenet](https://huggingface.co/google/mobilenet_v2_1.4_224): a really light model with lower performances but made to run on bad devices, no support for text similarity
+- [openAI CLIP](https://huggingface.co/openai/clip-vit-large-patch14): default model for panoptic, good performances, runs well on most computers with a decent CPU, support text similarity and has a good understanding of semantics
+- [meta dinosV2](https://huggingface.co/docs/transformers/en/model_doc/dinov2): model that will have better performances than CLIP on pure visual similarities but less understanding of themes and semantics, no support for text similarity, runs well on CPU
+- [google SIGLIP2](https://huggingface.co/docs/transformers/main/model_doc/siglip2): computing heavy model, NVDIA GPU recommended but works also on CPU (it will take a long time to compute embeddings), way better results than CLIP on text similarity and semantics, and pretty good visual features
+- auto transformers: want to tryout any huggingface multimodal model ? you can just provide its id to panopticML and should be able to use it directly
+
+## Clustering functions
+- Kmeans: specify a number of clusters, really fast
+- HDBScan: automatic number of clusters, a bit slower and excludes a lot of images
+- Images to text: considering several texts, create a cluster per text and put each image to the text it is the closest to
+- Find duplicates: create clusters with only images sharing a lot of similarity together, good to find duplicates or near duplicates

panopticml-0.0.2/__init__.py

@@ -0,0 +1,3 @@
+from .panopticml.panoptic_ml import PanopticML
+
+plugin_class = PanopticML

panopticml-0.0.2/mistral_test.py

@@ -0,0 +1,104 @@
+import json
+
+from PIL import Image
+import base64
+from io import BytesIO
+from mistralai import Mistral
+import os
+
+model = "pixtral-12b-2409"
+api_key = os.getenv("MISTRAL_KEY")
+client = Mistral(api_key=api_key)
+
+
+def create_batch(liste, batch_size):
+    return [liste[i:i + batch_size] for i in range(0, len(liste), batch_size)]
+
+
+def create_labels_from_group(groups_images):
+    all_labels = []
+    for batch in create_batch(groups_images, 8):
+        invalid = True
+        while invalid:
+            labels = create_labels_from_batch(batch)
+            try:
+                res = json.loads(labels)
+                invalid = False
+            except json.JSONDecodeError:
+                print("Invalid JSON")
+        all_labels.extend(res)
+    return all_labels
+
+
+def create_labels_from_batch(groups_images):
+    messages = [
+        {
+            "role": "user",
+            "content": []
+        },
+        {
+            "role": "assistant",
+            "content": [{
+                "type": "text",
+                "text": """[[
+                """
+            }],
+            "prefix": "true"
+        }
+    ]
+
+    for base64_image in groups_images:
+        messages[0]['content'].append({
+                    "type": "image_url",
+                    "image_url": f"data:image/jpeg;base64,{base64_image}"
+        })
+    messages[0]['content'].append({
+                    "type": "text",
+                    "text": """\
+                    Chaque image est une mosaïque du contenu d'un cluster d'images.
+                    Donne CINQ (5) mots-clés (par mosaïque) et UNIQUEMENT ces mots-clés, sans aucun autre texte 
+                    sous forme de liste de listes qui devra être un JSON valide, exemple [[mot_cle1, mot_cle2, mot_cle3, mot_cle4, mot_cle5],[...]]."""  # , séparez ces mots par des virgules.
+                    # Essayez d'inclure des mots-clés généraux qui pourraient décrire le contenu de nombreuses images à la fois.
+                    # Veuillez séparer les mots-clés pour chaque mosaïque avec un point-virgule et NE PAS INCLURE de texte supplémentaire.
+                    f"""Assure toi de ne répondre qu'en français tu me donneras EXACTEMENT {len(groups_images)} LISTES (soit une par image) et fais bien attention à respecter L'ORDRE des images !.
+                    """
+                })
+    # Get the chat response
+    chat_response = client.chat.complete(
+        model=model,
+        messages=messages
+    )
+
+    # Print the content of the response
+    return chat_response.choices[0].message.content
+
+
+def generate_group_image(images_paths, cluster_n):
+    # Définir la taille des images dans la mosaïque
+    cols, rows = 5, 4
+    thumb_width, thumb_height = 200, 200  # Taille des miniatures
+
+    # Créer une image blanche pour la mosaïque
+    mosaic = Image.new('RGB', (cols * thumb_width, rows * thumb_height), (255, 255, 255))
+
+    for index, img_path in enumerate(images_paths):
+        if index >= cols * rows:
+            break  # S'assure de ne traiter que 20 images
+
+        img = Image.open(img_path)
+        img = img.resize((thumb_width, thumb_height))
+
+        # Calcul des coordonnées de placement
+        x_offset = (index % cols) * thumb_width
+        y_offset = (index // cols) * thumb_height
+
+        mosaic.paste(img, (x_offset, y_offset))
+
+    # Convertir en base64
+    buffered = BytesIO()
+    mosaic.save(buffered, format="JPEG")
+    with open(f'clusters/cluster_{cluster_n}.jpg', 'wb') as f:
+        mosaic.save(f)
+    encoded_image = base64.b64encode(buffered.getvalue()).decode('utf-8')
+
+    return encoded_image

panopticml-0.0.2/panopticml/compute/__init__.py

@@ -0,0 +1 @@
+from .clustering import make_clusters

panopticml-0.0.2/panopticml/compute/clustering.py

@@ -0,0 +1,122 @@
+import faiss
+import numpy as np
+import torch
+
+from panoptic.models import Vector
+from panoptic.models.results import ScoreList, Score, Group
+from ..utils import similarity_matrix
+
+
+def make_clusters(vectors: list[Vector], **kwargs) -> (list[list[str]], list[int]):
+    res_clusters = []
+    res_distances = []
+    vectors, sha1 = zip(*[(i.data, i.sha1) for i in vectors])
+    sha1 = np.asarray(sha1)
+    clusters: np.ndarray
+
+    clusters, distances = _make_clusters_faiss(vectors, **kwargs)
+
+    for cluster in list(set(clusters)):
+        sha1_cluster = sha1[clusters == cluster]
+        current_cluster_distances = distances[clusters == cluster]
+        if distances is not None:
+            res_distances.append(np.mean(current_cluster_distances))
+        res_clusters.append(list(sha1_cluster))
+    # sort clusters by distances
+    sorted_clusters = [cluster for _, cluster in sorted(zip(res_distances, res_clusters))]
+    return sorted_clusters, sorted(res_distances)
+
+
+def _make_clusters_faiss(vectors, nb_clusters=6, **kwargs) -> (np.ndarray, np.ndarray):
+    def _make_single_kmean(vectors, nb_clusters):
+        kmean = faiss.Kmeans(vectors.shape[1], nb_clusters, niter=20, verbose=False)
+        kmean.train(vectors)
+        return kmean.index.search(vectors, 1)
+
+    vectors = np.asarray(vectors)
+    if nb_clusters == -1:
+        import hdbscan
+        clusterer = hdbscan.HDBSCAN(min_cluster_size=5, gen_min_span_tree=True)
+        clusterer.fit(vectors)
+        indices = clusterer.labels_
+        probabilities = clusterer.probabilities_
+        distances = np.zeros_like(probabilities, dtype=np.float32)
+        unique_clusters = np.unique(indices)
+        # compute distances just like the one returned by kmeans to have consistent metrics
+        for cluster_id in unique_clusters:
+            if cluster_id == -1:
+                distances[indices == -1] = 100.0
+                continue
+            cluster_mask = (indices == cluster_id)
+            cluster_vectors = vectors[cluster_mask]
+            cluster_probabilities = probabilities[cluster_mask]
+            center_local_index = np.argmax(cluster_probabilities)
+            center_vector = cluster_vectors[center_local_index].reshape(1, -1)
+            dists = faiss.pairwise_distances(center_vector, cluster_vectors)[0]
+            distances[cluster_mask] = dists
+    else:
+        distances, indices = _make_single_kmean(vectors, nb_clusters)
+    return indices.flatten(), distances.flatten()
+
+
+def cluster_by_text(image_vectors: list[Vector], text_vectors: list[np.array], text_labels: list[str]) -> list[Group]:
+    vectors, sha1s = zip(*[(i.data, i.sha1) for i in image_vectors])
+    sha1s_array = np.asarray(sha1s)
+
+    similarities, closest_text_indices = similarity_matrix(vectors, text_vectors)
+
+    clusters = []
+    distances = []
+    clusters_text = []
+    cluster_sims = []
+
+    for text_index in closest_text_indices.unique():
+        clusters_text.append(text_labels[text_index])
+        cluster = sha1s_array[closest_text_indices == text_index]
+
+        # similarities of each image inside the cluster and the text
+        cluster_sim = similarities[closest_text_indices == text_index]
+        sorted_sim = cluster_sim.sort(descending=True).values
+        cluster_sims.append([round(x, 2) for x in sorted_sim.tolist()])
+
+        # sort cluster by descending similarity
+        sorting_index = cluster_sim.argsort(descending=True)
+        sorted_cluster = cluster[sorting_index]
+        if type(sorted_cluster) is not np.ndarray:
+            sorted_cluster = np.array([sorted_cluster])
+        clusters.append(sorted_cluster)
+
+        # compute mean distance of the images
+        distance = float((1 - torch.mean(cluster_sim)) * 100)
+        distances.append(distance)
+
+    groups = []
+    for cluster, distance, name, cluster_sim in zip(clusters, distances, clusters_text, cluster_sims):
+        similarities = ScoreList(min=0, max=1, max_is_best=True, values=cluster_sim)
+        group = Group(score=Score(distance, min=0, max=200, max_is_best=False,
+                                  description="Mean distance between the images of this cluster and the queried text"),
+                      scores=similarities)
+        group.sha1s = list(cluster)
+        group.name = f"Cluster {name}"
+        groups.append(group)
+
+    return groups
+
+def custom_range(min_i, max_i, steps, increments):
+    """
+    Generate a range of values from min_i to max_i with a variable increment for each step
+    :param min_i: first value
+    :param max_i: last value
+    :param steps: values for which increment should change
+    :param increments: increments values
+    :return:
+    """
+    i = min_i
+    current_step = 0
+    current_incr = 1
+    while i < max_i:
+        yield i
+        if i >= steps[current_step] and current_step < len(steps) - 1:
+            current_incr = increments[current_step]
+            current_step += 1
+        i += current_incr