Add files using upload-large-folder tool

grounding-dino/.eval_venv/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

grounding-dino/.eval_venv/bin/activate

@@ -0,0 +1,63 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past commands. Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV=/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/"bin":$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1='(.eval_venv) '"${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT='(.eval_venv) '
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

grounding-dino/.eval_venv/bin/activate.csh

@@ -0,0 +1,26 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV /mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = '(.eval_venv) '"$prompt"
+    setenv VIRTUAL_ENV_PROMPT '(.eval_venv) '
+endif
+
+alias pydoc python -m pydoc
+
+rehash

grounding-dino/.eval_venv/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV /mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/"bin $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) '(.eval_venv) ' (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT '(.eval_venv) '
+end

grounding-dino/.eval_venv/bin/cygdb

@@ -0,0 +1,6 @@
+#!/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv/bin/python
+import sys
+from Cython.Debugger.Cygdb import main
+if __name__ == '__main__':
+    sys.argv[0] = sys.argv[0].removesuffix('.exe')
+    sys.exit(main())

grounding-dino/.eval_venv/bin/cython

@@ -0,0 +1,6 @@
+#!/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv/bin/python
+import sys
+from Cython.Compiler.Main import setuptools_main
+if __name__ == '__main__':
+    sys.argv[0] = sys.argv[0].removesuffix('.exe')
+    sys.exit(setuptools_main())

grounding-dino/.eval_venv/bin/cythonize

@@ -0,0 +1,6 @@
+#!/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv/bin/python
+import sys
+from Cython.Build.Cythonize import main
+if __name__ == '__main__':
+    sys.argv[0] = sys.argv[0].removesuffix('.exe')
+    sys.exit(main())

grounding-dino/.eval_venv/bin/f2py

@@ -0,0 +1,6 @@
+#!/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv/bin/python
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = sys.argv[0].removesuffix('.exe')
+    sys.exit(main())

grounding-dino/.eval_venv/bin/pip

@@ -0,0 +1,8 @@
+#!/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

grounding-dino/.eval_venv/bin/pip3

@@ -0,0 +1,8 @@
+#!/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

grounding-dino/.eval_venv/bin/pip3.11

@@ -0,0 +1,8 @@
+#!/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

grounding-dino/.eval_venv/bin/wgit

@@ -0,0 +1,6 @@
+#!/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv/bin/python
+import sys
+from fairscale.experimental.wgit.__main__ import main
+if __name__ == '__main__':
+    sys.argv[0] = sys.argv[0].removesuffix('.exe')
+    sys.exit(main())

grounding-dino/.eval_venv/lib/python3.11/site-packages/__editable___mmdet_3_3_0_finder.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+import sys
+from importlib.machinery import ModuleSpec, PathFinder
+from importlib.machinery import all_suffixes as module_suffixes
+from importlib.util import spec_from_file_location
+from itertools import chain
+from pathlib import Path
+
+MAPPING: dict[str, str] = {'mmdet': '/mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/mmdetection/mmdet'}
+NAMESPACES: dict[str, list[str]] = {}
+PATH_PLACEHOLDER = '__editable__.mmdet-3.3.0.finder' + ".__path_hook__"
+
+
+class _EditableFinder:  # MetaPathFinder
+    @classmethod
+    def find_spec(cls, fullname: str, path=None, target=None) -> ModuleSpec | None:  # type: ignore
+        # Top-level packages and modules (we know these exist in the FS)
+        if fullname in MAPPING:
+            pkg_path = MAPPING[fullname]
+            return cls._find_spec(fullname, Path(pkg_path))
+
+        # Handle immediate children modules (required for namespaces to work)
+        # To avoid problems with case sensitivity in the file system we delegate
+        # to the importlib.machinery implementation.
+        parent, _, child = fullname.rpartition(".")
+        if parent and parent in MAPPING:
+            return PathFinder.find_spec(fullname, path=[MAPPING[parent]])
+
+        # Other levels of nesting should be handled automatically by importlib
+        # using the parent path.
+        return None
+
+    @classmethod
+    def _find_spec(cls, fullname: str, candidate_path: Path) -> ModuleSpec | None:
+        init = candidate_path / "__init__.py"
+        candidates = (candidate_path.with_suffix(x) for x in module_suffixes())
+        for candidate in chain([init], candidates):
+            if candidate.exists():
+                return spec_from_file_location(fullname, candidate)
+        return None
+
+
+class _EditableNamespaceFinder:  # PathEntryFinder
+    @classmethod
+    def _path_hook(cls, path) -> type[_EditableNamespaceFinder]:
+        if path == PATH_PLACEHOLDER:
+            return cls
+        raise ImportError
+
+    @classmethod
+    def _paths(cls, fullname: str) -> list[str]:
+        paths = NAMESPACES[fullname]
+        if not paths and fullname in MAPPING:
+            paths = [MAPPING[fullname]]
+        # Always add placeholder, for 2 reasons:
+        # 1. __path__ cannot be empty for the spec to be considered namespace.
+        # 2. In the case of nested namespaces, we need to force
+        #    import machinery to query _EditableNamespaceFinder again.
+        return [*paths, PATH_PLACEHOLDER]
+
+    @classmethod
+    def find_spec(cls, fullname: str, target=None) -> ModuleSpec | None:  # type: ignore
+        if fullname in NAMESPACES:
+            spec = ModuleSpec(fullname, None, is_package=True)
+            spec.submodule_search_locations = cls._paths(fullname)
+            return spec
+        return None
+
+    @classmethod
+    def find_module(cls, _fullname) -> None:
+        return None
+
+
+def install():
+    if not any(finder == _EditableFinder for finder in sys.meta_path):
+        sys.meta_path.append(_EditableFinder)
+
+    if not NAMESPACES:
+        return
+
+    if not any(hook == _EditableNamespaceFinder._path_hook for hook in sys.path_hooks):
+        # PathEntryFinder is needed to create NamespaceSpec without private APIS
+        sys.path_hooks.append(_EditableNamespaceFinder._path_hook)
+    if PATH_PLACEHOLDER not in sys.path:
+        sys.path.append(PATH_PLACEHOLDER)  # Used just to trigger the path hook

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/datasets/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/datasets/mnist.py

@@ -0,0 +1,38 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import logging
+from pathlib import Path
+import shutil
+import tempfile
+
+from torchvision.datasets import MNIST
+
+TEMPDIR = tempfile.gettempdir()
+
+
+def setup_cached_mnist():
+    done, tentatives = False, 0
+    while not done and tentatives < 5:
+        # Monkey patch the resource URLs to work around a possible blacklist
+        MNIST.mirrors = ["https://github.com/blefaudeux/mnist_dataset/raw/main/"] + MNIST.mirrors
+
+        # This will automatically skip the download if the dataset is already there, and check the checksum
+        try:
+            _ = MNIST(transform=None, download=True, root=TEMPDIR)
+            done = True
+        except RuntimeError as e:
+            logging.warning(e)
+            mnist_root = Path(TEMPDIR + "/MNIST")
+            # Corrupted data, erase and restart
+            shutil.rmtree(str(mnist_root))
+
+        tentatives += 1
+
+    if done is False:
+        logging.error("Could not download MNIST dataset")
+        exit(-1)
+    else:
+        logging.info("Dataset downloaded")

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/datasets/wikitext2_data.py

@@ -0,0 +1,107 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+from collections import namedtuple
+from distutils.version import LooseVersion
+import io
+import operator
+import tempfile
+
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+import torchtext
+from torchtext.data.utils import get_tokenizer
+from torchtext.utils import download_from_url, extract_archive
+
+if operator.ge(torchtext.__version__, LooseVersion("0.10.0")):
+    from torchtext.legacy.vocab import build_vocab_from_iterator
+else:
+    from torchtext.vocab import build_vocab_from_iterator
+
+
+def _batchify(data, batch_size):
+    data = torch.tensor(data)
+    # Divide the dataset into bsz parts.
+    nbatch = data.size(0) // batch_size
+    # Trim off any extra elements that wouldn't cleanly fit (remainders).
+    data = data.narrow(0, 0, nbatch * batch_size)
+    # Evenly divide the data across the bsz batches.
+    data = data.view(batch_size, -1).t().contiguous()
+    return data
+
+
+def _get_total_batch_size(benchmark_config, model_specs):
+    return model_specs["seq_len"] * benchmark_config["batch_size"]
+
+
+DatasetsInfo = namedtuple("DataSetsInfo", ["ntokens", "train_dataset", "valid_dataset", "test_dataset"])
+
+
+def get_real_datasets():
+    url = "https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-2-v1.zip"
+    tmpdir = tempfile.TemporaryDirectory()
+    test_filepath, valid_filepath, train_filepath = extract_archive(download_from_url(url, root=tmpdir.name))
+    tokenizer = get_tokenizer("basic_english")
+
+    def data_process(raw_text_iter):
+        data = [torch.tensor([vocab[token] for token in tokenizer(item)], dtype=torch.long) for item in raw_text_iter]
+        return torch.cat(tuple(filter(lambda t: t.numel() > 0, data)))
+
+    vocab = build_vocab_from_iterator(map(tokenizer, iter(io.open(train_filepath, encoding="utf8"))))
+
+    train_dataset = data_process(iter(io.open(train_filepath, encoding="utf8")))
+    valid_dataset = data_process(iter(io.open(valid_filepath, encoding="utf8")))
+    test_dataset = data_process(iter(io.open(test_filepath, encoding="utf8")))
+    return DatasetsInfo(len(vocab.stoi), train_dataset, valid_dataset, test_dataset)
+
+
+def get_dataloaders(datasets_info, benchmark_config, model_specs, num_replicas=1, rank=0):
+    ntokens, train_dataset, valid_dataset, test_dataset = datasets_info
+
+    def batchify(data):
+        batch_size = benchmark_config["batch_size"]
+        return _batchify(data, batch_size)
+
+    total_batch_size = _get_total_batch_size(benchmark_config, model_specs)
+    train_dataloader = DataLoader(
+        train_dataset,
+        sampler=DistributedSampler(train_dataset, num_replicas=num_replicas, rank=rank),
+        batch_size=total_batch_size,
+        collate_fn=batchify,
+    )
+    valid_dataloader = DataLoader(
+        valid_dataset,
+        sampler=DistributedSampler(valid_dataset, num_replicas=num_replicas, rank=rank),
+        batch_size=total_batch_size,
+        collate_fn=batchify,
+    )
+    test_dataloader = DataLoader(
+        test_dataset,
+        sampler=DistributedSampler(test_dataset, num_replicas=num_replicas, rank=rank),
+        batch_size=total_batch_size,
+        collate_fn=batchify,
+    )
+    return train_dataloader, valid_dataloader, test_dataloader
+
+
+def get_real_dataloaders(args, benchmark_config, model_specs, num_replicas=1, rank=0):
+    """Return real dataloaders for training, testing and validation."""
+    dataset_info = get_real_datasets()
+    train_dataloader, valid_dataloader, test_dataloader = get_dataloaders(
+        dataset_info, benchmark_config, model_specs, num_replicas, rank
+    )
+    return dataset_info.ntokens, train_dataloader, valid_dataloder, test_dataloader
+
+
+def get_synthetic_datasets():
+    # vocab_size is 10000 and length of the real data is 2049990.
+    lm_dataset = torch.randint(1, 10000, (2049990,))
+    return DatasetsInfo(10000, lm_dataset, lm_dataset, lm_dataset)
+
+
+def get_synthetic_dataloaders(args, benchmark_config, model_specs, num_replicas=1, rank=0):
+    """Return synthetic dataloaders for training, testing and validation."""
+    return get_dataloaders(get_synthetic_datasets(), benchmark_config, model_specs, num_replicas, rank)

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/fsdp.py

@@ -0,0 +1,404 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import argparse
+from collections import defaultdict
+from functools import reduce
+import gc
+import logging
+import math
+import operator
+import time
+
+from datasets.wikitext2_data import get_real_dataloaders as get_real_wikitext2_dataloaders
+from datasets.wikitext2_data import get_synthetic_dataloaders as get_synthetic_wikitext2_dataloaders
+from models import transformer_lm
+import numpy as np
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.optim import Adam
+
+from benchmarks.golden_configs.lm_wikitext2 import FSDP as lm_wikitext2
+from fairscale.nn import auto_wrap, default_auto_wrap_policy, enable_wrap
+from fairscale.nn.data_parallel import FullyShardedDataParallel as FSDP
+
+RPC_PORT = 29501
+
+
+def verify_peak_memory(rank, golden_config, std_dev):
+    logging.debug(
+        "Peak allocated bytes on cuda:0: {:1d}".format(torch.cuda.memory_stats(rank)["allocated_bytes.all.peak"])
+    )
+    current_device_usage = torch.cuda.memory_stats(rank)["allocated_bytes.all.peak"]
+    golden_ref = golden_config["peak_mem_usage"][rank]
+    if not current_device_usage < golden_ref * std_dev:
+        raise RuntimeError(
+            "Peak memory usage for cuda device {:d} is {:d} which"
+            "is less than golden reference value of {:d}".format(rank, current_device_usage, golden_ref)
+        )
+
+
+def verify_lm_run(wps, golden_config, args):
+    """Verify that words per second for a given benchmark run matches the golden data."""
+
+    if torch.distributed.get_rank() == 0:
+        # Assert that words per second is within 3 standard deviations of the average
+        # of five golden runs
+        logging.info("Throughput(wps) is {:.2f}.".format(wps))
+        if not wps > (golden_config["avg_wps"] - (3 * golden_config["std_dev_wps"])):
+            raise RuntimeError(
+                "Throughput(wps):{:.2f} is below the golden threshold of an "
+                "average value of {:.2f} and standard dev of {:.2f}.".format(
+                    wps, golden_config["avg_wps"], golden_config["std_dev_wps"]
+                )
+            )
+
+    for i in range(torch.cuda.device_count()):
+        verify_peak_memory(i, golden_config, 1.1)
+
+
+def init_random_seed(seed: int):
+
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    np.random.seed(seed)
+
+
+def get_model_and_optimizer(args, device, benchmark_config, model_config):
+    """Return instantiated model and optimizer function."""
+
+    if args.model_name == "lm":
+        model = get_lm_model(args, device, model_config)
+
+    lr = benchmark_config["lr"]
+
+    def make_adam(params):
+        return Adam(params, lr=lr)
+
+    optimizer = make_adam
+    return model, optimizer
+
+
+def get_lm_model(args, device, config):
+    """Get language model(based on GPT-2) used for sequence prediction."""
+
+    ninp = config["ninp"]
+    nhead = config["nhead"]
+    initrange = config["initrange"]
+    dropout = config["dropout"]
+    vocab_size = config["vocab_size"]
+    nhid = config["nhid"]
+    ndecoder = config["num_decoder_layers"]
+
+    return transformer_lm.TransformerLM(vocab_size, ninp, nhead, nhid, dropout, initrange, ndecoder).to(device)
+
+
+def get_tensors_by_size_bucket():
+
+    size_buckets = defaultdict(int)
+    for obj in gc.get_objects():
+        if not isinstance(obj, torch.Tensor):
+            continue
+        if obj.device.type == "cuda":
+            size_buckets[(*obj.size(),) + (obj.element_size(),)] += 1
+
+    return size_buckets
+
+
+def log_number_of_parameters(model):
+
+    num_params = reduce(operator.add, (reduce(operator.mul, x.size()) for x in model.parameters()))
+    if hasattr(model, "group"):
+        total = torch.Tensor([num_params])
+        if torch.cuda.is_available():
+            total = total.cuda()
+        torch.distributed.all_reduce(total, group=model.group)
+        print(
+            f"training model, #params = {num_params/10**6}M, group: {model.group.rank()}, grank:"
+            f" {torch.distributed.get_rank()}, sizes {model.group.size()}"
+        )
+        torch.distributed.barrier()
+        if model.group.rank() == 0:
+            print(f"total #prams = {total.item()}")
+    else:
+        print(f"training model, #params = {num_params/10**6}M")
+
+
+def get_device(model, index):
+    if isinstance(model, DDP):
+        model = model.module
+
+    if not torch.cuda.is_available():
+        return torch.device("cpu")
+    if hasattr(model, "devices"):
+        return model.devices[index]
+    else:
+        return torch.cuda.current_device()
+
+
+def get_fake_dataloader(lm_dataloader_len, args):
+    fake_input = {"input": torch.zeros(args.batch_size)}
+
+    class FakeDataset:
+        def __getitem__(self, index):
+            return fake_input
+
+        def __len__(self):
+            return lm_dataloader_len
+
+    return FakeDataset()
+
+
+def train(model_config, model, benchmark_config, model_specs, args):
+    lm_dataloader, _, _ = model_config["data"]
+    criterion = benchmark_config["criterion"]
+    vocab_size = model_specs["vocab_size"]
+    optimizer = model_config["optimizer"]
+
+    if not args.benchmark_eval:
+        model.train()
+    log_number_of_parameters(model)
+
+    total_loss = 0.0
+    word_counter = 0
+
+    optimizer = optimizer(model.parameters())
+
+    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+
+    total_tokens = 0
+    total_tokens_per_log_interval = 0
+    bptt = 2
+    start_time = time.time()
+    epoch_start_time = 0.0
+
+    def get_batch(source):
+        seq_len = len(source) - 1
+        data = source[0:seq_len]
+        target = source[1 : 1 + seq_len]
+        return data, target
+
+    for i, batch in enumerate(lm_dataloader):
+        if i == 1:
+            epoch_start_time = time.time()
+
+        source, target = get_batch(batch)
+        if args.full_fp16:
+            # source = source.half()
+            target = target.half()
+        if args.max_batch and i > args.max_batch:
+            break
+
+        if i > 0:
+            total_tokens += source.numel()
+
+        if args.benchmark_eval:
+            input = source.cuda()
+            target = target.cuda()
+            output = model(input)
+            print(f"output.dtype {output.dtype}, target.dtype {target.dtype}")
+            loss = torch.nn.CrossEntropyLoss()(output.view(-1, vocab_size), target.view(-1))
+        else:
+            optimizer.zero_grad()
+            input = source.cuda()
+            target = target.cuda()
+            output = model(input)
+
+            loss = criterion(output.view(-1, vocab_size), target.view(-1))
+            loss.backward()
+
+            torch.nn.utils.clip_grad_value_(model.parameters(), model_specs["clip_value"])
+            optimizer.step()
+
+        total_loss += loss.item()
+
+        log_interval = 1
+        total_tokens_per_log_interval += source.numel()
+        if i % log_interval == 0 and i > 0:
+            cur_loss = total_loss / log_interval
+            elapsed = time.time() - start_time
+            if dist.get_rank() == 0:
+                print(
+                    "| batch {:5d} | wps {:5.2f} | loss {:5.2f} | ppl {:8.2f}".format(
+                        i, total_tokens_per_log_interval / elapsed, cur_loss, math.exp(cur_loss)
+                    )
+                )
+            total_tokens_per_log_interval = 0
+            total_loss = 0
+            start_time = time.time()
+
+    if epoch_start_time != 0:
+        torch.cuda.synchronize()
+        wps = total_tokens / (time.time() - epoch_start_time)
+    else:
+        raise RuntimeError(
+            "Unable to benchmark on a single batch. Increase the size " " of the dataset and rerun the benchmark."
+        )
+    return wps, loss.item()
+
+
+def get_number_of_words(data):
+    return data.size()[0] * data.size()[1]
+
+
+def benchmark_language_model(model_config, model, benchmark_config, model_specs, args):
+    golden_config = get_golden_config(args.model_name, args)
+    epoch = benchmark_config["epochs"]
+    start_time = time.time()
+    if dist.get_rank() == 0:
+        print("-" * 110)
+        print("| start of epoch {:1d}".format(epoch))
+        print("-" * 110)
+    wps, loss = train(model_config, model, benchmark_config, model_specs, args)
+    elapsed_time = time.time() - start_time
+    if dist.get_rank() == 0:
+        print("-" * 110)
+        print("| end of epoch {:1d} | time: {:5.2f}s | train loss {:5.2f} ".format(epoch, elapsed_time, loss))
+        print("-" * 110)
+        print("Throughput(wps) is {:.2f}.".format(wps))
+    print(
+        "Peak allocated bytes on cuda:{}: {:4f}GB".format(
+            dist.get_rank(), torch.cuda.memory_stats(dist.get_rank())["allocated_bytes.all.peak"] / 2**30
+        )
+    )
+
+    verify_lm_run(wps, golden_config, args)
+
+
+def get_synthetic_dataloaders(args, device, benchmark_config, model_specs):
+    """Returns dataloader for synthetic data."""
+
+    if args.model_name == "lm":
+        return get_synthetic_wikitext2_dataloaders(args, benchmark_config, model_specs)
+    else:
+        raise RuntimeError("Unrecognized args.model_mame " % args.model_name)
+
+
+def get_real_dataloaders(args, device, benchmark_config, model_specs):
+    """Returns dataloaders for real data."""
+
+    if args.model_name == "lm":
+        data = get_real_wikitext2_dataloaders(args, benchmark_config, model_specs)
+        ntokens, train_dataloader, valid_dataloader, test_dataloader = data
+        model_specs["vocab_size"] = ntokens
+        return train_dataloader, valid_dataloader, test_dataloader
+    else:
+        raise RuntimeError("Unrecognized args.model_mame " % args.model_name)
+
+
+def create_model_config(args, benchmark_config=None, model_specs=None):
+    """Return a dict with the given model, dataset and optimizer."""
+
+    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+
+    if args.use_synthetic_data:
+        dataloader_fn = get_synthetic_dataloaders
+    else:
+        dataloader_fn = get_real_dataloaders
+
+    data = dataloader_fn(args, device, benchmark_config, model_specs)
+    model, optimizer = get_model_and_optimizer(args, device, benchmark_config, model_specs)
+    return {
+        "model": model,
+        "optimizer": optimizer,
+        "data": data,
+    }
+
+
+def create_benchmark_config(model_name):
+    """Return a dict with configurations required for benchmarking `model_name` model."""
+
+    if model_name == "lm":
+        return lm_wikitext2.get_benchmark_config()
+    else:
+        raise RuntimeError("Unrecognized args.model_mame " % args.model_name)
+
+
+def get_model_specs(model_name):
+    """Return a dict with configurations required for configuring `model_name` model."""
+
+    if model_name == "lm":
+        return lm_wikitext2.get_model_config()
+    else:
+        raise RuntimeError("Unrecognized args.model_mame " % args.model_name)
+
+
+def get_golden_config(model_name, args):
+    """Return a dict with the golden data for throughput and memory usage."""
+
+    if model_name == "lm":
+        return lm_wikitext2.get_golden_synthetic_stats()
+    else:
+        raise RuntimeError("Unrecognized args.model_mame " % args.model_name)
+
+
+def benchmark_fsdp(rank, args, world_size):
+    """Benchmark a given model using a single process and multiple devices."""
+
+    init_method_pgroup = "tcp://localhost:{}".format(RPC_PORT)
+    torch.distributed.init_process_group(
+        backend="nccl", rank=rank, world_size=world_size, init_method=init_method_pgroup
+    )
+
+    torch.cuda.set_device(rank)
+    init_random_seed(0)
+    logging.basicConfig(level=logging.DEBUG)
+
+    benchmark_config = create_benchmark_config(args.model_name)
+    model_specs = get_model_specs(args.model_name)
+    model_config = create_model_config(args, benchmark_config=benchmark_config, model_specs=model_specs)
+    model = model_config["model"]
+    config = {}
+
+    if args.full_fp16:
+        config["compute_dtype"] = torch.float16
+        config["mixed_precision"] = False
+
+    if args.enable_auto_wrap:
+        with enable_wrap(wrapper_cls=FSDP, **config):
+            fsdp_model = auto_wrap(model, auto_wrap_policy=default_auto_wrap_policy)
+            fsdp_model = FSDP(fsdp_model, **config)
+    else:
+        fsdp_model = FSDP(model, **config)
+
+    if args.full_fp16:
+        fsdp_model = fsdp_model.half()
+    print(f"param dtype {[p.dtype for p in fsdp_model.parameters()]}")
+    if args.dry_run:
+        train(model_config, fsdp_model, benchmark_config, model_specs, args)
+    else:
+        benchmark_language_model(model_config, fsdp_model, benchmark_config, model_specs, args)
+
+
+parser = argparse.ArgumentParser(description="benchmark")
+parser.add_argument("--max_batch", type=int, default=4, help="Max number of batches")
+parser.add_argument("--use_synthetic_data", action="store_true", help="Uses synthetic data for running benchmarks.")
+parser.add_argument("--dry_run", action="store_true", help="Run a sample training run without regression testing.")
+parser.add_argument(
+    "--model_name",
+    default="lm",
+    help="Language Model(LM) used to benchmark FSDP.",
+)
+parser.add_argument("--debug", action="store_true", default=False, help="Display additional debug information")
+parser.add_argument("--enable_auto_wrap", action="store_true", default=False, help="Use auto_wrap with FSDP")
+parser.add_argument("--benchmark_eval", action="store_true", default=False, help="Benchmark evaluation workflow.")
+parser.add_argument("--full_fp16", action="store_true", default=False, help="Benchmark in full fp16 mode.")
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.DEBUG)
+
+    print(f"Running FSDP benchmark with args: {args}")
+    num_devices = torch.cuda.device_count() if torch.cuda.is_available() else 1
+    assert num_devices > 0
+
+    mp.spawn(
+        benchmark_fsdp,
+        args=(args, num_devices),
+        nprocs=num_devices,
+        join=True,
+    )

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/golden_configs/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/golden_configs/lm_wikitext2.py

@@ -0,0 +1,163 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch.nn as nn
+
+from fairscale.optim import GradScaler
+
+
+class Offload_Transformer:
+    def get_model_config():
+        return {
+            "vocab_size": 10000,
+            "ninp": 2048,  # embedding dimension
+            "nhid": 2048,  # the dimension of the feedforward network model in nn.TransformerEncoder
+            "nhead": 32,  # the number of heads in the multiheadattention models
+            "dropout": 0,
+            "initrange": 0.1,
+            "scaler": GradScaler(),
+            "clip_value": 0.05,
+            "num_decoder_layers": 10,
+            "seq_len": 32,
+        }
+
+    def get_benchmark_config(checkpoint_activation=True):
+
+        return {
+            "epochs": 1,
+            "lr": 0.001,  # learning rate
+            "batch_size": 8,
+            "criterion": nn.CrossEntropyLoss(),
+            "checkpoint_activation": checkpoint_activation,
+            "num_microbatches": 1,
+            "slices": 3,
+        }
+
+    def get_golden_real_stats():
+        return {
+            "avg_wps": 192.105,
+            "std_dev_wps": 39.56,
+            "peak_mem_usage": 1180848128,
+        }
+
+
+class Offload_Sequential:
+    def get_model_config():
+        return {
+            "inputs": 100,
+            "outputs": 5,
+            "hidden": 1000,
+            "layers": 100,
+            "clip_value": 0.05,
+        }
+
+    def get_benchmark_config():
+
+        return {
+            "epochs": 1,
+            "lr": 0.001,  # learning rate
+            "batch_size": 8,
+            "criterion": nn.CrossEntropyLoss(),
+            "slices": 3,
+            "checkpoint_activation": True,
+            "num_microbatches": 1,
+        }
+
+
+class FSDP:
+    def get_model_config():
+        return {
+            "vocab_size": 10000,
+            "ninp": 2048,  # embedding dimension
+            "nhid": 2048,  # the dimension of the feedforward network model in nn.TransformerEncoder
+            "nhead": 32,  # the number of heads in the multiheadattention models
+            "dropout": 0,
+            "initrange": 0.1,
+            "scaler": GradScaler(),
+            "clip_value": 0.05,
+            "num_decoder_layers": 10,
+            "seq_len": 32,
+        }
+
+    def get_benchmark_config():
+
+        return {
+            "epochs": 1,
+            "lr": 0.001,  # learning rate
+            "batch_size": 8,
+            "criterion": nn.CrossEntropyLoss(),
+        }
+
+    def get_golden_real_stats():
+        raise NotImplementedError("Synthetic data benchmarks are not supported.")
+
+    def get_golden_synthetic_stats():
+        return {
+            "avg_wps": 486.303,
+            "std_dev_wps": 71.307,
+            "peak_mem_usage": [5.5055 * 2**30, 5.5055 * 2**30, 5.5055 * 2**30, 5.5055 * 2**30],
+        }
+
+
+class Pipe:
+    def get_model_config():
+        return {
+            "vocab_size": 10000,
+            "ninp": 2048,  # embedding dimension
+            "nhid": 2048,  # the dimension of the feedforward network model in nn.TransformerEncoder
+            "nhead": 32,  # the number of heads in the multiheadattention models
+            "dropout": 0,
+            "initrange": 0.1,
+            "scaler": GradScaler(),
+            "clip_value": 0.05,
+            "num_decoder_layers": 10,
+            "seq_len": 32,
+        }
+
+    def get_benchmark_config():
+
+        return {
+            "epochs": 1,
+            "lr": 0.001,  # learning rate
+            "batch_size": 8,
+            "criterion": nn.CrossEntropyLoss(),
+        }
+
+    def get_golden_real_stats():
+        return {
+            "avg_wps": 703.778,
+            "std_dev_wps": 5.732,
+            "peak_mem_usage": [2320996352, 1396742144, 1396742144, 2340010496],
+        }
+
+    def get_golden_synthetic_stats():
+        # TODO(anj-s): Add support for synthetic regression benchmarks
+        raise NotImplementedError("Synthetic data benchmarks are not supported.")
+
+
+class MOE:
+    def get_model_config():
+        return {
+            "vocab_size": 10000,
+            "ninp": 1024,  # embedding dimension
+            "nhid": 4096,  # the dimension of the feedforward network model in nn.TransformerEncoder
+            "nhead": 32,  # the number of heads in the multiheadattention models
+            "dropout": 0,
+            "initrange": 0.1,
+            "scaler": GradScaler(),
+            "clip_value": 0.05,
+            "num_decoder_layers": 20,
+            "seq_len": 33,  # (seq_len - 1) needs to be divisible by num_local_experts
+            "is_moe": True,
+            "num_local_experts": 2,
+        }
+
+    def get_benchmark_config():
+        return {
+            "epochs": 1,
+            "lr": 0.001,  # learning rate
+            "batch_size": 32,
+            "criterion": nn.CrossEntropyLoss(),
+        }

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/golden_configs/oss_mnist.py

@@ -0,0 +1,18 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+def get_golden_real_stats():
+
+    return {
+        "reference_speed": 578,
+        "reference_memory": 945,
+        "reference_loss": 0.026,
+    }
+
+
+def get_golden_synthetic_stats():
+    # TODO(anj-s): Add support for synthetic regression benchmarks
+    raise NotImplementedError("Synthetic data benchmarks are not supported.")

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/models/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/moe.py

@@ -0,0 +1,130 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import logging
+import math
+import time
+
+from golden_configs.lm_wikitext2 import MOE as MOEConfig
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from torch.nn.parallel import DistributedDataParallel as DDP
+import utils
+
+MPI_PORT = 29500
+
+
+def benchmark_single_process(config_class, args):
+    """Benchmark a given model using a single process and multiple devices."""
+
+    world_size = torch.cuda.device_count() if torch.cuda.is_available() else 1
+    assert world_size > 0
+    benchmark_config = utils.create_benchmark_config(args.model_name, config_class)
+    model_specs = utils.get_model_specs(args.model_name, config_class)
+
+    mp.spawn(train, args=(world_size, benchmark_config, model_specs, args), nprocs=world_size, join=True)
+
+
+def train(rank, world_size, benchmark_config, model_specs, args):
+    logger = mp.log_to_stderr()
+    logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
+    utils.init_random_seed(rank)
+
+    init_method_pgroup = "tcp://localhost:{}".format(MPI_PORT)
+    torch.distributed.init_process_group(
+        backend="nccl", rank=rank, world_size=world_size, init_method=init_method_pgroup
+    )
+    logger.info("train, rank={}".format(rank))
+    device = torch.device("cuda", rank) if torch.cuda.is_available() else torch.device("cpu")
+
+    criterion = benchmark_config["criterion"]
+
+    model_config = utils.create_model_config(
+        args, benchmark_config=benchmark_config, model_specs=model_specs, device=device
+    )
+    # vocab_size may change in create_model_config() due to input data
+    vocab_size = model_specs["vocab_size"]
+    model = model_config["model"]
+    model.train()
+    optimizer = model_config["optimizer"]
+    optimizer = optimizer(model.parameters())
+    group = model.group if hasattr(model, "group") else None
+    utils.log_number_of_parameters(model, logger)
+
+    total_loss = 0.0
+    word_counter = 0
+    total_tokens = 0
+    total_tokens_per_log_interval = 0
+    bptt = 2
+
+    total_elapsed = 0.0
+
+    model = DDP(model, device_ids=[rank], output_device=rank, broadcast_buffers=False)
+    lm_dataloader, _, _ = utils.get_data_loader(
+        model_config["dataset_info"], args, benchmark_config, model_specs, num_replicas=world_size, rank=rank
+    )
+
+    def get_batch(source):
+        seq_len = len(source) - 1
+        data = source[0:seq_len]
+        target = source[1 : 1 + seq_len]
+        return data, target
+
+    for i, batch in enumerate(lm_dataloader):
+        if i == 1:
+            epoch_start_time = time.time()
+
+        if args.max_batch and i > args.max_batch:
+            break
+
+        if i > 0:
+            total_tokens += batch.numel()
+
+        start_time = time.time()
+        optimizer.zero_grad()
+        source, target = get_batch(batch)
+        source = source.to(device)
+        target = target.to(device)
+        try:
+            output = model(source.to(device))
+            loss = criterion(output.view(-1, vocab_size), target.view(-1))
+            total_loss += loss.item()
+            loss.backward()
+            torch.nn.utils.clip_grad_value_(model.parameters(), model_specs["clip_value"])
+            optimizer.step()
+        except Exception as e:
+            raise RuntimeError(f"training failed on {torch.distributed.get_rank()}") from e
+
+        elapsed = time.time() - start_time
+        total_elapsed += elapsed
+        log_interval = 1
+        total_tokens_per_log_interval += batch.numel()
+        if i % log_interval == 0 and i > 0:
+            cur_loss = total_loss / log_interval
+            logger.debug(
+                "| batch {:5d} | wps {:5.2f} | loss {:5.2f} | ppl {:8.2f}".format(
+                    i, total_tokens_per_log_interval / elapsed, cur_loss, math.exp(cur_loss)
+                )
+            )
+            total_tokens_per_log_interval = 0
+            total_loss = 0
+
+    wps = total_tokens / total_elapsed
+
+    logger.debug("rank {}, wps: {}".format(rank, wps))
+    logger.debug(
+        "Peak allocated bytes on cuda:{}: {:1d}".format(
+            dist.get_rank(), torch.cuda.memory_stats(dist.get_rank())["allocated_bytes.all.peak"]
+        )
+    )
+
+
+if __name__ == "__main__":
+    args = utils.init_args()
+    logging.basicConfig(level=logging.INFO if not args.debug else logging.DEBUG)
+
+    logging.info(f"Running single process benchmark with args: {args}")
+    benchmark_single_process(MOEConfig, args)

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/oss.py

@@ -0,0 +1,350 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import argparse
+from enum import Enum
+import importlib
+import logging
+import tempfile
+import time
+from typing import Any, List, Optional, cast
+
+from golden_configs import oss_mnist
+import numpy as np
+import torch
+import torch.autograd.profiler as profiler
+from torch.cuda.amp import GradScaler as TorchGradScaler
+import torch.distributed as dist
+import torch.multiprocessing as mp
+import torch.nn as nn
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import BatchSampler, DataLoader, Sampler
+from torch.utils.data.distributed import DistributedSampler
+from torchvision.datasets import MNIST
+from torchvision.transforms import Compose, Resize, ToTensor
+
+from benchmarks.datasets.mnist import setup_cached_mnist
+from fairscale.nn.data_parallel import ShardedDataParallel as ShardedDDP
+from fairscale.optim import OSS
+from fairscale.optim.grad_scaler import ShardedGradScaler
+
+TEMPDIR = tempfile.gettempdir()
+
+
+def dist_init(rank, world_size, backend):
+    logging.info(f"Using backend: {backend}")
+    dist.init_process_group(backend=backend, init_method="tcp://localhost:29501", rank=rank, world_size=world_size)
+
+
+def get_problem(rank, world_size, batch_size, device, model_name: str):
+    # Select the desired model on the fly
+    logging.info(f"Using {model_name} for benchmarking")
+
+    try:
+        model = getattr(importlib.import_module("torchvision.models"), model_name)(pretrained=False).to(device)
+    except AttributeError:
+        model = getattr(importlib.import_module("timm.models"), model_name)(pretrained=False).to(device)
+
+    # Data setup, duplicate the grey channels to get pseudo color
+    def collate(inputs: List[Any]):
+        return {
+            "inputs": torch.stack([i[0] for i in inputs]).repeat(1, 3, 1, 1).to(device),
+            "label": torch.tensor([i[1] for i in inputs]).to(device),
+        }
+
+    # Transforms
+    transforms = []
+    if model_name.startswith("vit"):
+        # ViT models are fixed size. Add a ad-hoc transform to resize the pictures accordingly
+        pic_size = int(model_name.split("_")[-1])
+        transforms.append(Resize(pic_size))
+
+    transforms.append(ToTensor())
+
+    dataset = MNIST(transform=Compose(transforms), download=False, root=TEMPDIR)
+    sampler: Sampler = DistributedSampler(dataset, num_replicas=world_size, rank=rank)
+    batch_sampler = BatchSampler(sampler, batch_size, drop_last=True)
+    dataloader = DataLoader(dataset=dataset, batch_sampler=batch_sampler, collate_fn=collate)
+
+    loss_fn = nn.CrossEntropyLoss()
+    return model, dataloader, loss_fn
+
+
+class OptimType(str, Enum):
+    vanilla = "pytorch"
+    oss_ddp = "oss_ddp"
+    oss_sharded_ddp = "oss_sharded_ddp"
+    everyone = "everyone"
+
+
+def validate_benchmark(measurements, final_loss, args, check_regression):
+    """Validate the measurments against the golden benchmark config."""
+
+    golden_data = oss_mnist.get_golden_real_stats()
+
+    max_memory = -1.0
+    rank = dist.get_rank()
+    if not args.cpu:
+        # TODO(anj-s): Check if we need to synchronize before we caculate total training time.
+        torch.cuda.synchronize(rank)
+        max_memory = torch.cuda.max_memory_allocated(rank) / 2**20
+        logging.info(f"[{rank}] : Peak memory {max_memory:.1f}MiB")
+
+    measurements.sort()
+    median = measurements[len(measurements) // 2]
+    # Compute the median and median of absolute differences img per second.
+    abs_diff = list(map(lambda x: abs(x - median), measurements))
+    abs_diff.sort()
+    mad = abs_diff[len(measurements) // 2] if args.epochs > 2 else -1
+
+    # TODO(anj-s): Add a debug flag to perform the above calculation only when required.
+    logging.info(f"[{rank}] : Median speed: {median:.2f} +/- {mad:.2f}")
+
+    if check_regression and rank == 0:
+        assert median + 8.0 * mad > golden_data["reference_speed"], (
+            f"Speed regression detected: " f"{median + 8.0 * mad} vs.  {golden_data['reference_speed']}"
+        )
+        assert max_memory < 1.05 * golden_data["reference_memory"], (
+            f"Memory use regression detected: " f"{max_memory} vs. {1.05* golden_data['reference_memory']}"
+        )
+        # any min_loss < than golden + epsilon is OK.
+        assert cast(float, final_loss) - golden_data["reference_loss"] < 1e-2, (
+            f"Loss regression detected: " f"{final_loss} vs. {golden_data['reference_loss']}"
+        )
+        logging.info("[Regression Test] VALID")
+
+
+def train(
+    rank: int,
+    args: argparse.Namespace,
+    backend: str = "gloo",
+    optim_type: OptimType = OptimType.vanilla,
+    check_regression: bool = True,
+):
+    logging.basicConfig(level=logging.INFO if not args.debug else logging.DEBUG)
+
+    use_multi_tensor = args.multi_tensor_optim and hasattr(torch.optim, "_multi_tensor")
+    OPTIM = torch.optim._multi_tensor.RMSprop if use_multi_tensor else torch.optim.RMSprop  # type: ignore  # attr is  checked but mypy misses that
+    logging.info("Multi tensor optimizer: {}".format(use_multi_tensor))
+
+    # DDP
+    dist_init(rank=rank, world_size=args.world_size, backend=backend)
+
+    # Setup
+    if not args.cpu:
+        torch.cuda.set_device(rank)
+        torch.cuda.manual_seed(0)
+    torch.manual_seed(0)  # also sets the cuda seed
+    np.random.seed(0)
+
+    if backend == "nccl":
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+    device = torch.device("cpu") if args.cpu else torch.device(rank)
+    model, dataloader, loss_fn = get_problem(rank, args.world_size, args.batch_size, device, args.model)
+
+    # Shard the optimizer
+    optimizer: Optional[torch.optim.Optimizer] = None
+    model = cast(nn.Module, model)
+    scaler = (TorchGradScaler() if args.optim_type == OptimType.vanilla else ShardedGradScaler()) if args.amp else None
+
+    if optim_type == OptimType.oss_sharded_ddp:
+        optimizer = OSS(params=model.parameters(), optim=OPTIM, lr=1e-4, momentum=0.9)
+        # Single node run typically, no need for reduce buckets
+        model = ShardedDDP(model, optimizer, reduce_buffer_size=0)
+    else:
+        device_ids = None if args.cpu else [rank]
+        model = DDP(model, device_ids=device_ids, find_unused_parameters=False)  # type: ignore
+        optimizer = (
+            OSS(params=model.parameters(), optim=OPTIM, lr=1e-4, momentum=0.9)
+            if optim_type == OptimType.oss_ddp
+            else OPTIM(model.parameters(), lr=1e-4, momentum=0.9)
+        )
+    optimizer = cast(torch.optim.Optimizer, optimizer)
+
+    # Reset the memory use counter
+    if not args.cpu:
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats(rank)
+        torch.cuda.synchronize(rank)
+
+    # Standard training loop
+    training_start = time.monotonic()
+    model.train()
+
+    measurements = []
+    final_loss: Optional[float] = -1.0
+    min_loss = 100.0
+    need_profiling = args.profile
+
+    for epoch in range(args.epochs):
+        n_items = 0
+        epoch_runtime = 0.0
+
+        for batch in dataloader:
+            if not args.cpu:
+                torch.cuda.synchronize(rank)
+            batch_start = time.monotonic()
+
+            def closure(data=batch, grad_scaler=None):
+                model.zero_grad()
+                if args.debug and rank == 0 and next(model.parameters()).grad is not None:
+                    logging.debug(
+                        "\nbefore:  param {} -- grad {}".format(
+                            next(model.parameters()).norm().item(), next(model.parameters()).grad.norm().item()
+                        )
+                    )
+                if grad_scaler is not None:
+                    # Automatically computes the FW pass in half precision
+                    with torch.cuda.amp.autocast():
+                        outputs = model(data["inputs"])
+                        loss = loss_fn(outputs, data["label"])
+
+                        # Accumulates scaled gradients.
+                        grad_scaler.scale(loss).backward()
+                else:
+                    outputs = model(data["inputs"])
+                    loss = loss_fn(outputs, data["label"])
+                    loss.backward()
+
+                if args.debug and rank == 0 and next(model.parameters()).grad is not None:
+                    logging.debug(
+                        "after BW: param {} -- grad {}".format(
+                            next(model.parameters()).norm().item(), next(model.parameters()).grad.norm().item()
+                        )
+                    )
+                return loss
+
+            def run_closure(closure, scaler, optimizer):
+                if scaler is not None:
+                    final_loss = closure(grad_scaler=scaler)  # AMP scaler.step does not support closures
+                    scaler.step(optimizer)
+                    scaler.update()
+                    return final_loss
+                else:
+                    return optimizer.step(closure)
+
+            if need_profiling and not args.cpu:
+                logging.info("Profiling the run")
+                with profiler.profile(use_cuda=True, record_shapes=True, profile_memory=True) as prof:  # type: ignore
+                    with profiler.record_function("batch"):
+                        final_loss = run_closure(closure, scaler, optimizer)
+
+                prof.export_chrome_trace(f"{optim_type}_trace_rank_{rank}.json")
+                need_profiling = False  # only profile once
+
+            else:
+                final_loss = run_closure(closure, scaler, optimizer)
+
+            if args.debug and rank == 0:
+                logging.debug("buffer: {}".format(next(model.buffers()).norm().item()))
+                logging.debug(
+                    "after update: param {} -- grad {}".format(
+                        next(model.parameters()).norm().item(), next(model.parameters()).grad.norm().item()
+                    )
+                )
+
+            n_items += args.batch_size
+
+            if not args.cpu:
+                # make sure that the cuda kernels are finished before taking a timestamp
+                torch.cuda.synchronize(rank)
+
+            batch_end = time.monotonic()
+            epoch_runtime += batch_end - batch_start
+
+        if optim_type == OptimType.oss_ddp or optim_type == OptimType.oss_sharded_ddp:
+            # Check the checkpointing in the case of the OSS optimizer
+            # Memory usage could spill over from there
+            optimizer = cast(OSS, optimizer)
+            optimizer.consolidate_state_dict()
+            if dist.get_rank() == 0:
+                _ = optimizer.state_dict()
+                logging.info("... State dict collected")
+
+        measurements.append(n_items / epoch_runtime)
+        min_loss = min(min_loss, final_loss)
+        if dist.get_rank() == 0:
+            logging.info(
+                f"Epoch {epoch} - processed {measurements[-1]:.2f} img per sec. "
+                f"Loss {final_loss:.3f} min loss {min_loss:.3f}"
+            )
+
+    training_stop = time.monotonic()
+    img_per_sec = n_items / (training_stop - training_start) * args.epochs
+    logging.info(f"[{dist.get_rank()}] : Training done. {img_per_sec:.2f} img per sec inc. checkpoint")
+
+    # Use min_loss to check instead of final_loss since the final_loss is a bit random.
+    # If the training min_loss reaches certain number, we can be reasonably certain the
+    # training process was correct.
+    validate_benchmark(measurements, min_loss, args, check_regression)
+
+    dist.destroy_process_group()  # type: ignore
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Benchmark the optimizer state sharding, on a typical computer vision workload"
+    )
+    parser.add_argument("--world_size", action="store", default=2, type=int)
+    parser.add_argument("--epochs", action="store", default=10, type=int)
+    parser.add_argument("--batch_size", action="store", default=256, type=int)
+    parser.add_argument("--check_regression", action="store_true", default=False)
+    parser.add_argument(
+        "--optim_type", type=OptimType, choices=[o.value for o in OptimType], default=OptimType.everyone
+    )
+    parser.add_argument("--gloo", action="store_true", default=False)
+    parser.add_argument("--profile", action="store_true", default=False)
+    parser.add_argument("--cpu", action="store_true", default=False)
+    parser.add_argument("--model", type=str, help="Any torchvision or timm model name (str)", default="resnet101")
+    parser.add_argument("--debug", action="store_true", default=False, help="Display additional debug information")
+    parser.add_argument("--amp", action="store_true", default=False, help="Activate torch AMP")
+    parser.add_argument(
+        "--multi_tensor_optim", action="store_true", default=False, help="Use the faster multi-tensor optimizers"
+    )
+
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO if not args.debug else logging.DEBUG)
+    logging.info("Benchmark arguments: %s" % args)
+
+    BACKEND = "nccl" if (not args.gloo or not torch.cuda.is_available()) and not args.cpu else "gloo"
+
+    # Download dataset once for all processes
+    setup_cached_mnist()
+
+    # Benchmark the different configurations, via multiple processes
+    if args.optim_type == OptimType.vanilla or args.optim_type == OptimType.everyone:
+        logging.info("\n*** Benchmark vanilla optimizer")
+        mp.spawn(
+            train,  # type: ignore
+            args=(args, BACKEND, OptimType.vanilla, False),  # no regression check
+            nprocs=args.world_size,
+            join=True,
+        )
+
+    if args.optim_type == OptimType.oss_ddp or args.optim_type == OptimType.everyone:
+        logging.info("\n*** Benchmark OSS with DDP")
+        mp.spawn(
+            train,
+            args=(args, BACKEND, OptimType.oss_ddp, args.check_regression),
+            nprocs=args.world_size,
+            join=True,  # type: ignore
+        )
+
+    if args.optim_type == OptimType.oss_sharded_ddp or args.optim_type == OptimType.everyone:
+        logging.info("\n*** Benchmark OSS with ShardedDDP")
+        mp.spawn(
+            train,  # type: ignore
+            args=(
+                args,
+                BACKEND,
+                OptimType.oss_sharded_ddp,
+                args.check_regression,
+            ),
+            nprocs=args.world_size,
+            join=True,
+        )

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/pipe.py

@@ -0,0 +1,314 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+from collections import defaultdict
+import gc
+import logging
+import math
+import time
+
+import torch
+import torch.distributed as dist
+from torch.distributed import rpc
+from torch.nn.parallel import DistributedDataParallel as DDP
+import utils
+
+from benchmarks.golden_configs.lm_wikitext2 import Pipe as lm_wikitext2
+from fairscale.fair_dev.testing.testing import dist_init
+from fairscale.nn import Pipe
+from fairscale.nn.model_parallel import initialize_model_parallel
+
+MPI_PORT = 29500
+RPC_PORT = 29501
+
+
+def get_tensors_by_size_bucket():
+
+    size_buckets = defaultdict(int)
+    for obj in gc.get_objects():
+        if not isinstance(obj, torch.Tensor):
+            continue
+        if obj.device.type == "cuda":
+            size_buckets[(*obj.size(),) + (obj.element_size(),)] += 1
+
+    return size_buckets
+
+
+def get_device(model, index):
+    if isinstance(model, DDP):
+        model = model.module
+
+    if not torch.cuda.is_available():
+        return torch.device("cpu")
+    if hasattr(model, "devices"):
+        return model.devices[index]
+    else:
+        return torch.cuda.current_device()
+
+
+def get_fake_dataloader(lm_dataloader_len, args):
+    fake_input = {"input": torch.zeros(args.batch_size)}
+
+    class FakeDataset:
+        def __getitem__(self, index):
+            return fake_input
+
+        def __len__(self):
+            return lm_dataloader_len
+
+    return FakeDataset()
+
+
+def train(model_config, model, benchmark_config, model_specs, args):
+    lm_dataloader, _, _ = utils.get_data_loader(model_config["dataset_info"], args, benchmark_config, model_specs)
+    criterion = benchmark_config["criterion"]
+    vocab_size = model_specs["vocab_size"]
+    optimizer = model_config["optimizer"]
+
+    model.train()
+    utils.log_number_of_parameters(model)
+
+    total_loss = 0.0
+    word_counter = 0
+
+    optimizer = optimizer(model.parameters())
+
+    pipe_group = model.group if hasattr(model, "group") else None
+
+    # TODO(anj-s): Avoid sending fake data to all replicas except the first and last one.
+    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+    if pipe_group and pipe_group.rank() != 0 and pipe_group.rank() != (pipe_group.size() - 1):
+        lm_dataloader, _, _ = get_synthetic_dataloaders(args, benchmark_config, model_specs)
+
+    total_tokens = 0
+    total_tokens_per_log_interval = 0
+    bptt = 2
+    start_time = time.time()
+    epoch_start_time = 0.0
+
+    def get_batch(source):
+        seq_len = len(source) - 1
+        data = source[0:seq_len]
+        target = source[1 : 1 + seq_len]
+        return data, target
+
+    for i, batch in enumerate(lm_dataloader):
+        if i == 1:
+            epoch_start_time = time.time()
+
+        source, target = get_batch(batch)
+        if args.max_batch and i > args.max_batch:
+            break
+
+        if i > 0:
+            total_tokens += source.numel()
+
+        optimizer.zero_grad()
+        try:
+            if pipe_group is None or pipe_group.rank() == 0:
+                tmp = source.to(get_device(model, 0))
+                output = model(tmp)
+            else:
+                output = model(source)
+        except Exception as e:
+            raise RuntimeError(f"training failed on {torch.distributed.get_rank()}") from e
+
+        if pipe_group is None or pipe_group.rank() == pipe_group.size() - 1:
+            target = target.to(get_device(model, -1))
+            output = output.to(target.device)
+            loss = criterion(output.view(-1, vocab_size), target.view(-1))
+            loss.backward()
+            del target
+        else:
+            model.back_helper(output)
+
+        del output
+
+        torch.nn.utils.clip_grad_value_(model.parameters(), model_specs["clip_value"])
+        optimizer.step()
+
+        if pipe_group is None or pipe_group.rank() == pipe_group.size() - 1:
+            total_loss += loss.item()
+            log_interval = 1
+            total_tokens_per_log_interval += source.numel()
+            if i % log_interval == 0 and i > 0:
+                cur_loss = total_loss / log_interval
+                elapsed = time.time() - start_time
+                if dist.get_rank() == dist.get_world_size() - 1:
+                    logging.debug(
+                        "| batch {:5d} | wps {:5.2f} | loss {:5.2f} | ppl {:8.2f}".format(
+                            i, total_tokens_per_log_interval / elapsed, cur_loss, math.exp(cur_loss)
+                        )
+                    )
+                total_tokens_per_log_interval = 0
+                total_loss = 0
+                start_time = time.time()
+
+    if epoch_start_time != 0:
+        wps = total_tokens / (time.time() - epoch_start_time)
+    else:
+        raise RuntimeError(
+            "Unable to benchmark on a single batch. Increase the size " " of the dataset and rerun the benchmark."
+        )
+    if dist.get_rank() == dist.get_world_size() - 1:
+        return wps, loss.item()
+    else:
+        return 0.0, 0.0
+
+
+# TODO(anj-s): Add an option for users to be able to benchmark evaluate.
+def evaluate(eval_model, data_source, criterion, ntokens):
+    eval_model.eval()
+    total_loss = 0.0
+    # TODO(anj-s): Move this to the benchmark config if we want to benchmark evaluation.
+    bptt = 35
+
+    def get_batch(source, i, bptt):
+        seq_len = min(bptt, len(source) - 1 - i)
+        data = source[i : i + seq_len]
+        target = source[i + 1 : i + 1 + seq_len].view(-1)
+        return data, target
+
+    with torch.no_grad():
+        for i in range(0, data_source.size(0) - 1, bptt):
+            data, targets = get_batch(data_source, i, bptt)
+            output = eval_model(data)
+            output = output.to(targets.device)
+            output_flat = output.view(-1, ntokens)
+            total_loss += len(data) * criterion(output_flat, targets).item()
+    return total_loss / (len(data_source) - 1)
+
+
+def get_number_of_words(data):
+    return data.size()[0] * data.size()[1]
+
+
+def verify_peak_memory(rank, golden_config, std_dev):
+    logging.debug(
+        "Peak allocated bytes on cuda:0: {:1d}".format(torch.cuda.memory_stats(rank)["allocated_bytes.all.peak"])
+    )
+    current_device_usage = torch.cuda.memory_stats(rank)["allocated_bytes.all.peak"]
+    golden_ref = golden_config["peak_mem_usage"][rank]
+    if not current_device_usage < golden_ref * std_dev:
+        raise RuntimeError(
+            "Peak memory usage for cuda device {:d} is {:d} which"
+            "is less than golden reference value of {:d}".format(rank, current_device_usage, golden_ref)
+        )
+
+
+def verify_lm_run(wps, golden_config, args):
+    """Verify that words per second for a given benchmark run matches the golden data."""
+
+    if dist.get_rank() == dist.get_world_size() - 1:
+        # Assert that words per second is within 3 standard deviations of the average
+        # of five golden runs
+        logging.info("Throughput(wps) is {:.2f}.".format(wps))
+        if not wps > (golden_config["avg_wps"] - (3 * golden_config["std_dev_wps"])):
+            raise RuntimeError(
+                "Throughput(wps):{:.2f} is below the golden threshold of an "
+                "average value of {:.2f} and standard dev of {:.2f}.".format(
+                    wps, golden_config["avg_wps"], golden_config["std_dev_wps"]
+                )
+            )
+
+    for i in range(4):
+        verify_peak_memory(i, golden_config, 1.1)
+
+
+def benchmark_language_model(model_config, model, benchmark_config, model_specs, config_class, args):
+    golden_config = get_golden_config(args.model_name, config_class, args)
+    epoch = benchmark_config["epochs"]
+    start_time = time.time()
+    if dist.get_rank() == dist.get_world_size() - 1:
+        logging.debug("-" * 110)
+        logging.debug("| start of epoch {:1d}".format(epoch))
+        logging.debug("-" * 110)
+    wps, loss = train(model_config, model, benchmark_config, model_specs, args)
+    elapsed_time = time.time() - start_time
+    if dist.get_rank() == dist.get_world_size() - 1:
+        logging.debug("-" * 110)
+        logging.debug("| end of epoch {:1d} | time: {:5.2f}s | train loss {:5.2f} ".format(epoch, elapsed_time, loss))
+        logging.debug("-" * 110)
+        logging.debug("Throughput(wps) is {:.2f}.".format(wps))
+    logging.debug(
+        "Peak allocated bytes on cuda:{}: {:1d}".format(
+            dist.get_rank(), torch.cuda.memory_stats(dist.get_rank())["allocated_bytes.all.peak"]
+        )
+    )
+
+    if len(model.balance) == 4:
+        if args.model_name == "lm":
+            verify_lm_run(wps, golden_config, args)
+        else:
+            raise RuntimeError("Unrecognized args.model_name " % args.model_name)
+
+
+def generate_balance(num_devices, num_layers):
+    balance = []
+    layers_assigned = 0
+    for i in range(num_devices):
+        x = (num_layers - layers_assigned) / (num_devices - i)
+        if x.is_integer():
+            balance.append(int(x))
+            layers_assigned += x
+        else:
+            balance.append(math.ceil(x))
+            layers_assigned += math.ceil(x)
+    return balance
+
+
+def get_golden_config(model_name, config_class, args):
+    """Return a dict with the golden data for throughput and memory usage."""
+
+    if model_name == "lm":
+        return config_class.get_golden_real_stats()
+    else:
+        raise RuntimeError("Unrecognized args.model_mame " % args.model_name)
+
+
+def benchmark_single_process(config_class, args):
+    """Benchmark a given model using a single process and multiple devices."""
+
+    init_method_pgroup = "tcp://localhost:{}".format(MPI_PORT)
+    torch.distributed.init_process_group(backend="gloo", rank=0, world_size=1, init_method=init_method_pgroup)
+
+    num_devices = torch.cuda.device_count() if torch.cuda.is_available() else 1
+    assert num_devices > 0
+    utils.init_random_seed(0)
+
+    benchmark_config = utils.create_benchmark_config(args.model_name, config_class)
+    model_specs = utils.get_model_specs(args.model_name, config_class)
+    model_config = utils.create_model_config(args, benchmark_config=benchmark_config, model_specs=model_specs)
+    model = model_config["model"]
+
+    balance = generate_balance(min(num_devices, 4), len(model))
+    pipe_model = Pipe(model, balance, chunks=args.chunks, checkpoint=args.checkpoint)
+    del model
+    del model_config["model"]
+
+    if args.dry_run:
+        train(model_config, pipe_model, benchmark_config, model_specs, args)
+    else:
+        benchmark_language_model(model_config, pipe_model, benchmark_config, model_specs, config_class, args)
+
+
+def run_worker(rank, world_size, args):
+    if args.world_size != 0:
+        world_size = args.world_size
+    dist_init(rank + args.rank_base, world_size, hostname=args.host)
+    initialize_model_parallel(1, world_size)
+    utils.init_random_seed(0)
+    run_mp_worker(args, world_size)
+
+    rpc.shutdown()
+    torch.distributed.destroy_process_group()
+
+
+if __name__ == "__main__":
+    args = utils.init_args()
+    logging.basicConfig(level=logging.INFO if not args.debug else logging.DEBUG)
+
+    logging.info(f"Running single process benchmark with args: {args}")
+    benchmark_single_process(lm_wikitext2, args)

grounding-dino/.eval_venv/lib/python3.11/site-packages/benchmarks/utils.py

@@ -0,0 +1,167 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import argparse
+from functools import reduce
+import logging
+import operator
+
+import datasets.wikitext2_data as wikitext2_data
+from models import transformer_lm
+import numpy as np
+import torch
+from torch.optim import Adam
+
+
+def init_random_seed(seed: int):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    np.random.seed(seed)
+
+
+def init_args():
+    parser = argparse.ArgumentParser(description="benchmark")
+    parser.add_argument("--host", "-o", type=str, default="localhost", help="hostname")
+    parser.add_argument("--chunks", type=int, default=1, help="number of microbatches per batch")
+    parser.add_argument("--batch-size", type=int, default=8, help="size of a batch")
+    parser.add_argument(
+        "--checkpoint",
+        default="never",
+        choices=["always", "except_last", "never"],
+        help="Checkpointing strategy for pipe",
+    )
+    parser.add_argument(
+        "--lazy-construction", action="store_true", default=False, help="Number of decoder layers in the model"
+    )
+    parser.add_argument("--max-batch", type=int, default=4, help="Max number of batches")
+    parser.add_argument("--use_synthetic_data", action="store_true", help="Uses synthetic data for running benchmarks.")
+    parser.add_argument("--dry_run", action="store_true", help="Run a sample training run without regression testing.")
+    parser.add_argument(
+        # TODO(anj-s): In the process of adding more models and hence the requirement for a flag.
+        "--model_name",
+        default="lm",
+        help="Language Model(LM) used to benchmark nn.pipe.",
+    )
+    parser.add_argument("--debug", action="store_true", default=False, help="Display additional debug information")
+    args = parser.parse_args()
+    return args
+
+
+def create_benchmark_config(model_name, config_class):
+    """Return a dict with configurations required for benchmarking `model_name` model."""
+
+    if model_name == "lm":
+        return config_class.get_benchmark_config()
+    else:
+        raise RuntimeError("Unrecognized args.model_mame " % args.model_name)
+
+
+def get_model_specs(model_name, config_class):
+    """Return a dict with configurations required for configuring `model_name` model."""
+
+    if model_name == "lm":
+        return config_class.get_model_config()
+    else:
+        raise RuntimeError("Unrecognized args.model_mame " % model_name)
+
+
+def create_model_config(args, benchmark_config=None, model_specs=None, device=None):
+    """Return a dict with the given model, dataset and optimizer."""
+
+    if not device:
+        device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+    dataset_info = get_dataset_info(args)
+    assert model_specs is not None
+    model_specs["vocab_size"] = dataset_info.ntokens
+    model, optimizer = get_model_and_optimizer(args, device, benchmark_config, model_specs)
+    return {
+        "model": model,
+        "optimizer": optimizer,
+        "dataset_info": dataset_info,
+    }
+
+
+def get_model_and_optimizer(args, device, benchmark_config, model_config):
+    """Return instantiated model and optimizer function."""
+
+    if args.model_name == "lm":
+        model = get_lm_model(args, device, model_config)
+
+    lr = benchmark_config["lr"]
+
+    def make_adam(params):
+        return Adam(params, lr=lr)
+
+    optimizer = make_adam
+    return model, optimizer
+
+
+def get_lm_model(args, device, config):
+    """Get language model(based on GPT-2) used for sequence prediction."""
+
+    ninp = config["ninp"]
+    nhead = config["nhead"]
+    initrange = config["initrange"]
+    dropout = config["dropout"]
+    vocab_size = config["vocab_size"]
+    nhid = config["nhid"]
+    ndecoder = config["num_decoder_layers"]
+    is_moe = config.get("is_moe", False)
+    num_local_experts = config.get("num_local_experts", 1)
+
+    if args.lazy_construction:
+        layers = [
+            LazyModule(lambda: transformer_lm.EmbeddingLayer(vocab_size, ninp, initrange)),
+            LazyModule(lambda: transformer_lm.PositionalEncodingLayer(ninp, dropout)),
+        ]
+        for _ in range(ndecoder):
+            layers.append(
+                LazyModule(
+                    lambda: transformer_lm.TransformerDecoderLayer(
+                        ninp, nhead, nhid, dropout, is_moe, num_local_experts
+                    )
+                )
+            )
+
+        layers.append(LazyModule(lambda: transformer_lm.LinearLayer(ninp, vocab_size, initrange)))
+        model = layers
+    else:
+        model = transformer_lm.TransformerLM(
+            vocab_size, ninp, nhead, nhid, dropout, initrange, ndecoder, is_moe, num_local_experts
+        ).to(device)
+
+    return model
+
+
+def log_number_of_parameters(model, logger=None):
+    if not logger:
+        logger = logging
+    num_params = reduce(operator.add, (reduce(operator.mul, x.size()) for x in model.parameters()))
+    if hasattr(model, "group"):
+        total = torch.Tensor([num_params])
+        if torch.cuda.is_available():
+            total = total.cuda()
+        torch.distributed.all_reduce(total, group=model.group)
+        logger.debug(
+            f"training model, #params = {num_params}, group: {model.group.rank()}, grank:"
+            f" {torch.distributed.get_rank()}, sizes {model.group.size()}"
+        )
+        torch.distributed.barrier()
+        if model.group.rank() == 0:
+            logger.debug(f"total #prams = {total.item()}")
+    else:
+        logger.debug(f"training model, #params = {num_params}")
+
+
+def get_dataset_info(args):
+    assert args.model_name == "lm"
+    if args.use_synthetic_data:
+        return wikitext2_data.get_synthetic_datasets()
+    else:
+        return wikitext2_data.get_real_datasets()
+
+
+def get_data_loader(dataset_info, args, benchmark_config, model_specs, num_replicas=1, rank=0):
+    return wikitext2_data.get_dataloaders(dataset_info, benchmark_config, model_specs, num_replicas, rank)

grounding-dino/.eval_venv/lib/python3.11/site-packages/cython.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+#
+#   Cython -- Main Program, generic
+#
+
+try:
+    from typing import TYPE_CHECKING
+except ImportError:
+    TYPE_CHECKING = False
+
+if not TYPE_CHECKING and __name__ == '__main__':
+
+    import os
+    import sys
+
+    # Make sure we import the right Cython
+    cythonpath, _ = os.path.split(os.path.realpath(__file__))
+    sys.path.insert(0, cythonpath)
+
+    from Cython.Compiler.Main import main
+    main(command_line = 1)
+
+else:
+    # Void cython.* directives.
+    from Cython.Shadow import *
+    ## and bring in the __version__
+    from Cython import __version__
+    from Cython import load_ipython_extension

grounding-dino/.eval_venv/pyvenv.cfg

@@ -0,0 +1,5 @@
+home = /mnt/afs_agents/pangcong/miniconda3/envs/llamafac311/bin
+include-system-site-packages = true
+version = 3.11.14
+executable = /mnt/afs_agents/pangcong/miniconda3/envs/llamafac311/bin/python3.11
+command = /mnt/afs_agents/pangcong/miniconda3/envs/llamafac311/bin/python -m venv --system-site-packages /mnt/afs_agents/pangcong/workspace/fengxuyu_workspace/obj_det_val/grounding-dino/.eval_venv

grounding-dino/compute_recall_f1.py

@@ -0,0 +1,229 @@
+"""
+基于 mmdet test.py 输出的 pkl 文件，计算每个类别的 Precision / Recall / F1
+以及 Overall 的指标 (micro-average)。
+
+用法:
+    python compute_recall_f1.py \
+        --config <config.py> \
+        --pkl <predictions.pkl> \
+        --score-thr 0.3 \
+        --iou-thr 0.5 \
+        --output metrics_report.txt
+"""
+import argparse
+import numpy as np
+import mmengine
+from mmengine.config import Config
+from mmengine.registry import init_default_scope
+from mmdet.registry import DATASETS
+
+
+def compute_iou_matrix(pred_bboxes, gt_bboxes):
+    """计算 pred 和 gt 之间的 IoU 矩阵 [N_pred, N_gt]"""
+    if len(pred_bboxes) == 0 or len(gt_bboxes) == 0:
+        return np.zeros((len(pred_bboxes), len(gt_bboxes)))
+
+    pred = np.array(pred_bboxes)
+    gt = np.array(gt_bboxes)
+
+    x1 = np.maximum(pred[:, 0:1], gt[:, 0:1].T)
+    y1 = np.maximum(pred[:, 1:2], gt[:, 1:2].T)
+    x2 = np.minimum(pred[:, 2:3], gt[:, 2:3].T)
+    y2 = np.minimum(pred[:, 3:4], gt[:, 3:4].T)
+
+    inter = np.maximum(x2 - x1, 0) * np.maximum(y2 - y1, 0)
+
+    area_pred = (pred[:, 2] - pred[:, 0]) * (pred[:, 3] - pred[:, 1])
+    area_gt = (gt[:, 2] - gt[:, 0]) * (gt[:, 3] - gt[:, 1])
+
+    union = area_pred[:, None] + area_gt[None, :] - inter
+    iou = inter / np.maximum(union, 1e-6)
+    return iou
+
+
+def match_predictions(pred_bboxes, pred_labels, pred_scores,
+                      gt_bboxes, gt_labels, iou_thr=0.5, score_thr=0.3):
+    """
+    对单张图进行匹配, 返回每个类别的 TP / FP / FN 数量
+    """
+    # 过滤低分预测
+    keep = pred_scores >= score_thr
+    pred_bboxes = pred_bboxes[keep]
+    pred_labels = pred_labels[keep]
+    pred_scores = pred_scores[keep]
+
+    # 按分数降序排列
+    order = np.argsort(-pred_scores)
+    pred_bboxes = pred_bboxes[order]
+    pred_labels = pred_labels[order]
+
+    gt_matched = np.zeros(len(gt_bboxes), dtype=bool)
+
+    tp = 0
+    fp = 0
+
+    per_class_tp = {}
+    per_class_fp = {}
+    per_class_fn = {}
+
+    # 计算 IoU 矩阵
+    if len(pred_bboxes) > 0 and len(gt_bboxes) > 0:
+        iou_matrix = compute_iou_matrix(pred_bboxes, gt_bboxes)
+    else:
+        iou_matrix = np.zeros((len(pred_bboxes), len(gt_bboxes)))
+
+    pred_matched = np.zeros(len(pred_bboxes), dtype=bool)
+
+    for i in range(len(pred_bboxes)):
+        pred_label = pred_labels[i]
+        # 找到同类别且未匹配的 GT
+        candidate_gt = np.where((gt_labels == pred_label) & (~gt_matched))[0]
+
+        if len(candidate_gt) == 0:
+            pred_matched[i] = False
+            continue
+
+        ious = iou_matrix[i, candidate_gt]
+        best_idx = np.argmax(ious)
+
+        if ious[best_idx] >= iou_thr:
+            pred_matched[i] = True
+            gt_matched[candidate_gt[best_idx]] = True
+        else:
+            pred_matched[i] = False
+
+    # 统计每个类别
+    all_classes = set(pred_labels.tolist()) | set(gt_labels.tolist())
+    for cls in all_classes:
+        cls = int(cls)
+        cls_pred_mask = pred_labels == cls
+        cls_tp = int((cls_pred_mask & pred_matched).sum())
+        cls_fp = int((cls_pred_mask & ~pred_matched).sum())
+        cls_fn = int(((gt_labels == cls) & ~gt_matched).sum())
+
+        per_class_tp[cls] = per_class_tp.get(cls, 0) + cls_tp
+        per_class_fp[cls] = per_class_fp.get(cls, 0) + cls_fp
+        per_class_fn[cls] = per_class_fn.get(cls, 0) + cls_fn
+
+    return per_class_tp, per_class_fp, per_class_fn
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config', required=True, help='Config file path')
+    parser.add_argument('--pkl', required=True, help='Prediction pkl file')
+    parser.add_argument('--score-thr', type=float, default=0.3)
+    parser.add_argument('--iou-thr', type=float, default=0.5)
+    parser.add_argument('--output', default=None, help='Output report file')
+    args = parser.parse_args()
+
+    cfg = Config.fromfile(args.config)
+    init_default_scope(cfg.get('default_scope', 'mmdet'))
+
+    # 构建数据集获取 GT
+    dataset = DATASETS.build(cfg.test_dataloader.dataset)
+    predictions = mmengine.load(args.pkl)
+
+    class_names = dataset.metainfo['classes']
+    num_classes = len(class_names)
+
+    # 累计统计
+    total_tp = {i: 0 for i in range(num_classes)}
+    total_fp = {i: 0 for i in range(num_classes)}
+    total_fn = {i: 0 for i in range(num_classes)}
+
+    print(f'>>> 评估参数: score_thr={args.score_thr}, iou_thr={args.iou_thr}')
+    print(f'>>> 共 {len(predictions)} 张图片')
+
+    for idx in range(len(predictions)):
+        pred = predictions[idx]
+
+        # 获取预测
+        pred_bboxes = pred['pred_instances']['bboxes'].cpu().numpy() \
+            if hasattr(pred['pred_instances']['bboxes'], 'cpu') \
+            else np.array(pred['pred_instances']['bboxes'])
+        pred_labels = pred['pred_instances']['labels'].cpu().numpy() \
+            if hasattr(pred['pred_instances']['labels'], 'cpu') \
+            else np.array(pred['pred_instances']['labels'])
+        pred_scores = pred['pred_instances']['scores'].cpu().numpy() \
+            if hasattr(pred['pred_instances']['scores'], 'cpu') \
+            else np.array(pred['pred_instances']['scores'])
+
+        # 获取 GT
+        data_info = dataset.get_data_info(idx)
+        gt_instances = data_info['instances']
+        if len(gt_instances) > 0:
+            gt_bboxes = np.array([inst['bbox'] for inst in gt_instances])
+            gt_labels = np.array([inst['bbox_label'] for inst in gt_instances])
+            # COCO 格式 bbox 是 [x,y,w,h]，需转换为 [x1,y1,x2,y2]
+            if gt_bboxes.shape[1] == 4:
+                # 检查是否是 xywh 格式 (如果 w, h 值远小于 x2, y2 通常说明是 xyxy)
+                # mmdet CocoDataset 已经转换为 xyxy 了
+                pass
+        else:
+            gt_bboxes = np.zeros((0, 4))
+            gt_labels = np.array([], dtype=np.int64)
+
+        # 匹配
+        per_cls_tp, per_cls_fp, per_cls_fn = match_predictions(
+            pred_bboxes, pred_labels, pred_scores,
+            gt_bboxes, gt_labels,
+            iou_thr=args.iou_thr, score_thr=args.score_thr)
+
+        for cls in per_cls_tp:
+            if cls < num_classes:
+                total_tp[cls] += per_cls_tp[cls]
+        for cls in per_cls_fp:
+            if cls < num_classes:
+                total_fp[cls] += per_cls_fp[cls]
+        for cls in per_cls_fn:
+            if cls < num_classes:
+                total_fn[cls] += per_cls_fn[cls]
+
+    # 计算指标
+    lines = []
+    lines.append('=' * 80)
+    lines.append(f'Grounding DINO 评估报告  (score_thr={args.score_thr}, iou_thr={args.iou_thr})')
+    lines.append('=' * 80)
+    lines.append(f'{"类别":<20} {"TP":>6} {"FP":>6} {"FN":>6} {"Precision":>10} {"Recall":>10} {"F1":>10}')
+    lines.append('-' * 80)
+
+    all_tp = 0
+    all_fp = 0
+    all_fn = 0
+
+    for i in range(num_classes):
+        tp = total_tp[i]
+        fp = total_fp[i]
+        fn = total_fn[i]
+
+        precision = tp / max(tp + fp, 1)
+        recall = tp / max(tp + fn, 1)
+        f1 = 2 * precision * recall / max(precision + recall, 1e-6)
+
+        lines.append(f'{class_names[i]:<20} {tp:>6} {fp:>6} {fn:>6} {precision:>10.4f} {recall:>10.4f} {f1:>10.4f}')
+
+        all_tp += tp
+        all_fp += fp
+        all_fn += fn
+
+    # Overall (micro-average)
+    overall_precision = all_tp / max(all_tp + all_fp, 1)
+    overall_recall = all_tp / max(all_tp + all_fn, 1)
+    overall_f1 = 2 * overall_precision * overall_recall / max(overall_precision + overall_recall, 1e-6)
+
+    lines.append('-' * 80)
+    lines.append(f'{"Overall (micro)"::<20} {all_tp:>6} {all_fp:>6} {all_fn:>6} {overall_precision:>10.4f} {overall_recall:>10.4f} {overall_f1:>10.4f}')
+    lines.append('=' * 80)
+
+    report = '\n'.join(lines)
+    print(report)
+
+    if args.output:
+        with open(args.output, 'w') as f:
+            f.write(report)
+        print(f'\n>>> 报告已保存到: {args.output}')
+
+
+if __name__ == '__main__':
+    main()

grounding-dino/convert_pkl_to_answer_jsonl.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""Convert MMDetection prediction pkl to answer.jsonl-like format."""
+
+import argparse
+import json
+import math
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Iterable, List, Sequence
+
+import numpy as np
+
+
+_BASE_DIR = Path(__file__).resolve().parent
+DEFAULT_CONFIG = str(
+    _BASE_DIR
+    / "work_dirs"
+    / "mm_grounding_dino_traffic"
+    / "grounding_dino_swin-t_finetune_traffic.py"
+)
+DEFAULT_PKL = str(_BASE_DIR / "eval_output" / "predictions.pkl")
+DEFAULT_OUTPUT = str(_BASE_DIR / "eval_output" / "predictions_answer.jsonl")
+
+
+def _load_local_modules():
+    repo_root = Path(__file__).resolve().parent / "mmdetection"
+    if str(repo_root) not in sys.path:
+        sys.path.insert(0, str(repo_root))
+
+    import mmengine  # type: ignore
+    from mmengine.config import Config  # type: ignore
+    from mmengine.registry import init_default_scope  # type: ignore
+    from mmdet.registry import DATASETS  # type: ignore
+
+    return mmengine, Config, init_default_scope, DATASETS
+
+
+def _to_numpy(data):
+    if data is None:
+        return None
+    if hasattr(data, "detach"):
+        data = data.detach()
+    if hasattr(data, "cpu"):
+        data = data.cpu()
+    if hasattr(data, "numpy"):
+        return data.numpy()
+    return np.asarray(data)
+
+
+def _get_field(obj, key):
+    if obj is None:
+        return None
+    if isinstance(obj, dict):
+        return obj.get(key)
+    if hasattr(obj, key):
+        return getattr(obj, key)
+    try:
+        return obj[key]
+    except Exception:
+        return None
+
+
+def _extract_pred_arrays(pred):
+    pred_instances = _get_field(pred, "pred_instances")
+    bboxes = _to_numpy(_get_field(pred_instances, "bboxes"))
+    labels = _to_numpy(_get_field(pred_instances, "labels"))
+    scores = _to_numpy(_get_field(pred_instances, "scores"))
+
+    if bboxes is None or labels is None or scores is None:
+        return (
+            np.zeros((0, 4), dtype=np.float32),
+            np.zeros((0,), dtype=np.int64),
+            np.zeros((0,), dtype=np.float32),
+        )
+
+    return (
+        np.asarray(bboxes, dtype=np.float32),
+        np.asarray(labels, dtype=np.int64),
+        np.asarray(scores, dtype=np.float32),
+    )
+
+
+def _resolve_image_path(data_info):
+    for key in ("img_path", "image_path", "file_name", "filename"):
+        value = data_info.get(key)
+        if value:
+            return str(value)
+    return ""
+
+
+def _to_xyxy(box):
+    if box is None or len(box) < 4:
+        return None
+    return [float(box[0]), float(box[1]), float(box[2]), float(box[3])]
+
+
+def _resolve_image_size(data_info):
+    if "ori_shape" in data_info and data_info["ori_shape"] is not None:
+        ori_shape = data_info["ori_shape"]
+        if len(ori_shape) >= 2:
+            return int(ori_shape[1]), int(ori_shape[0])
+    if "width" in data_info and "height" in data_info:
+        return int(data_info["width"]), int(data_info["height"])
+    return None, None
+
+
+def _build_question(class_names: Sequence[str]) -> str:
+    categories = ", ".join(class_names)
+    return (
+        f"Detect {categories}. If an object is present, output its bounding box "
+        "in [x0, y0, x1, y1] format. If a category is not present, output None."
+    )
+
+
+def _coord_to_bin(value: float, size: int) -> int:
+    if size <= 1:
+        return 0
+    value = max(0.0, min(float(value), float(size)))
+    if value == size:
+        value = size - 1e-6
+    return int(round(value / size * 999.0))
+
+
+def _boxes_to_raw_segment(category: str, boxes: List[List[float]], width: int, height: int) -> str:
+    if not boxes:
+        body = " None "
+    else:
+        encoded_boxes = []
+        for box in boxes:
+            x0, y0, x1, y1 = box[:4]
+            encoded_boxes.append(
+                " <{}> <{}> <{}> <{}> ".format(
+                    _coord_to_bin(x0, width),
+                    _coord_to_bin(y0, height),
+                    _coord_to_bin(x1, width),
+                    _coord_to_bin(y1, height),
+                )
+            )
+        body = " , ".join(encoded_boxes)
+    return (
+        f"<|object_ref_start|>  {category}  <|object_ref_end|>   "
+        f"<|box_start|> {body} <|box_end|>"
+    )
+
+
+def _build_raw_response(pred_dict: Dict[str, List[List[float]]], class_names: Sequence[str], width: int, height: int) -> str:
+    hit_categories = [name for name in class_names if pred_dict.get(name)]
+    total_objects = sum(len(pred_dict.get(name, [])) for name in class_names)
+
+    summary_parts = [
+        "I have carefully scanned the entire image for all target categories.",
+        f"I found {total_objects} objects across {len(hit_categories)} categories.",
+    ]
+    for name in class_names:
+        count = len(pred_dict.get(name, []))
+        if count > 0:
+            summary_parts.append(f"Detected {count} {name}(s).")
+
+    raw_segments = [
+        _boxes_to_raw_segment(name, pred_dict.get(name, []), width, height)
+        for name in class_names
+    ]
+    return "<think> " + " ".join(summary_parts) + " </think>\n\n " + " ,  ".join(raw_segments)
+
+
+def _build_gt_dict(data_info: dict, class_names: Sequence[str]) -> Dict[str, List[List[float]]]:
+    gt_dict = {class_name: [] for class_name in class_names}
+    for inst in data_info.get("instances", []):
+        label = inst.get("bbox_label")
+        if label is None:
+            label = inst.get("label")
+        if label is None:
+            continue
+
+        label = int(label)
+        if label < 0 or label >= len(class_names):
+            continue
+
+        bbox = _to_xyxy(inst.get("bbox"))
+        if bbox is None:
+            continue
+        gt_dict[class_names[label]].append(bbox)
+    return gt_dict
+
+
+def _build_pred_dict(pred, class_names: Sequence[str], score_thr: float) -> Dict[str, List[List[float]]]:
+    pred_dict = {class_name: [] for class_name in class_names}
+    bboxes, labels, scores = _extract_pred_arrays(pred)
+    if scores.size == 0:
+        return pred_dict
+
+    order = np.argsort(-scores)
+    for idx in order.tolist():
+        score = float(scores[idx])
+        if score < score_thr:
+            break
+        label = int(labels[idx])
+        if label < 0 or label >= len(class_names):
+            continue
+        bbox = _to_xyxy(bboxes[idx])
+        if bbox is None:
+            continue
+        pred_dict[class_names[label]].append(bbox)
+    return pred_dict
+
+
+def _build_rows(dataset, predictions, class_names: Sequence[str], score_thr: float, dataset_name: str) -> List[dict]:
+    rows = []
+    question = _build_question(class_names)
+    sample_count = min(len(dataset), len(predictions))
+    if len(dataset) != len(predictions):
+        print(
+            f"[Warn] dataset size ({len(dataset)}) != predictions size ({len(predictions)}), "
+            f"using first {sample_count} samples."
+        )
+
+    for idx in range(sample_count):
+        data_info = dataset.get_data_info(idx)
+        image_path = _resolve_image_path(data_info)
+        width, height = _resolve_image_size(data_info)
+        if width is None or height is None:
+            raise ValueError(f"Cannot resolve image size for sample {idx}: {image_path}")
+
+        pred_dict = _build_pred_dict(predictions[idx], class_names, score_thr)
+        gt_dict = _build_gt_dict(data_info, class_names)
+        raw_response = _build_raw_response(pred_dict, class_names, width, height)
+
+        rows.append(
+            {
+                "image_path": image_path,
+                "extracted_predictions": pred_dict,
+                "gt": gt_dict,
+                "question": question,
+                "dataset_name": dataset_name,
+                "raw_response": raw_response,
+                "task_name": "common_object_detection",
+            }
+        )
+    return rows
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Convert MMDetection predictions.pkl to answer.jsonl-like format."
+    )
+    parser.add_argument("--config", default=DEFAULT_CONFIG, help="MMDetection config path")
+    parser.add_argument("--pkl", default=DEFAULT_PKL, help="MMDetection prediction pkl path")
+    parser.add_argument("--output-jsonl", default=DEFAULT_OUTPUT, help="Output answer-style jsonl")
+    parser.add_argument("--score-thr", type=float, default=0.3, help="Prediction score threshold")
+    parser.add_argument(
+        "--dataset-name",
+        default="Traffic_Dataset",
+        help="dataset_name field in the output jsonl",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    output_dir = os.path.dirname(args.output_jsonl)
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+
+    mmengine, Config, init_default_scope, DATASETS = _load_local_modules()
+
+    print(f"[Info] Loading config: {args.config}")
+    cfg = Config.fromfile(args.config)
+    init_default_scope(cfg.get("default_scope", "mmdet"))
+
+    print("[Info] Building test dataset...")
+    dataset = DATASETS.build(cfg.test_dataloader.dataset)
+    class_names = tuple(dataset.metainfo["classes"])
+    print(f"[Info] Classes ({len(class_names)}): {class_names}")
+
+    print(f"[Info] Loading predictions: {args.pkl}")
+    predictions = mmengine.load(args.pkl)
+
+    print("[Info] Converting to answer.jsonl-like rows...")
+    rows = _build_rows(
+        dataset=dataset,
+        predictions=predictions,
+        class_names=class_names,
+        score_thr=args.score_thr,
+        dataset_name=args.dataset_name,
+    )
+
+    with open(args.output_jsonl, "w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+    print(f"[Info] Saved {len(rows)} rows to: {args.output_jsonl}")
+
+
+if __name__ == "__main__":
+    main()

grounding-dino/data_precess_train.py

@@ -0,0 +1,167 @@
+import json
+import os
+import cv2
+from pathlib import Path
+
+# ================= 配置区域 =================
+BASE_DIR = Path(__file__).resolve().parent
+WORKSPACE_DIR = BASE_DIR.parent.parent
+jsonl_file = str(WORKSPACE_DIR / 'rex_data' / 'data' / 'rex-omni-data' / 'train' / 'merged_shuffled_no_rect_from_wuhan_plus_replenish_mixed_vis_temp_empty_gt.jsonl')  # 你的原始数据路径
+output_dir = str(BASE_DIR / 'dataset')            # 输出文件夹名
+json_name = 'train_traffic_data_2_25.json'       # 输出的 json 文件名
+# 统一图片根目录：新文件里有多个子目录（如 PanoImages_data_all / crops_scaled1p5 / crop_empty）
+img_root = str(WORKSPACE_DIR / 'rex_data' / 'data')
+# 当图片不在 img_root 下时，是否允许在 COCO 的 file_name 里写绝对路径
+allow_absolute_file_name = True
+
+# 类别映射 (MMDet 中 ID 建议从 1 开始，或者保持 0，CocoDataset默认兼容)
+# 这里的顺序非常重要，必须和后面 Config 里的 class_name 顺序一致
+categories = [
+    {"id": 0, "name": "traffic sign"},
+    {"id": 1, "name": "street light"},
+    {"id": 2, "name": "traffic light"},
+    {"id": 3, "name": "surveillance camera"},
+    {"id": 4, "name": "ball bollard"},
+    {"id": 5, "name": "fire hydrant"},
+    {"id": 6, "name": "trash bin"},
+    {"id": 7, "name": "manhole"},
+    {"id": 8, "name": "traffic cone"},
+    {"id": 9, "name": "bollard"}
+]
+# ===========================================
+
+def resolve_image_path(raw_path):
+    """支持绝对路径和相对路径（相对 jsonl 或相对 img_root）。"""
+    if not raw_path:
+        return None
+    raw_path = os.path.expanduser(str(raw_path))
+    if os.path.isabs(raw_path):
+        return raw_path
+
+    candidates = [
+        os.path.join(os.path.dirname(jsonl_file), raw_path),
+        os.path.join(img_root, raw_path)
+    ]
+    for p in candidates:
+        if os.path.exists(p):
+            return os.path.abspath(p)
+    return os.path.abspath(candidates[0])
+
+
+def build_file_name(img_path):
+    """优先写相对 img_root 的路径；不在 img_root 下时可回退到绝对路径。"""
+    rel_path = os.path.relpath(img_path, img_root)
+    if not rel_path.startswith('..'):
+        return rel_path.replace('\\', '/')
+    if allow_absolute_file_name:
+        return os.path.abspath(img_path).replace('\\', '/')
+    return None
+
+def main():
+    os.makedirs(output_dir, exist_ok=True)
+    dst_img_dir = os.path.join(output_dir, 'images')
+    os.makedirs(dst_img_dir, exist_ok=True)
+    
+    images = []
+    annotations = []
+    
+    # 建立名字到ID的映射
+    cat_map = {cat['name']: cat['id'] for cat in categories}
+    
+    print(f"Reading {jsonl_file}...")
+    
+    data_lines = []
+    with open(jsonl_file, 'r', encoding='utf-8') as f:
+        for line in f:
+            if line.strip():
+                data_lines.append(json.loads(line))
+
+    print(f"Converting {len(data_lines)} images to COCO format...")
+    
+    ann_id = 0
+    img_id = 0
+    
+    for entry in data_lines:
+        raw_img_path = entry.get('image_name') or entry.get('image_path')
+        img_path = resolve_image_path(raw_img_path)
+        if not img_path:
+            continue
+        
+        # 1. 检查并读取图片 (需要宽高)
+        if not os.path.exists(img_path):
+            print(f"Skip: {img_path} not found")
+            continue
+            
+        img = cv2.imread(img_path)
+        if img is None: continue
+        h, w = img.shape[:2]
+        
+        file_name = build_file_name(img_path)
+        if file_name is None:
+            print(f"Skip: {img_path} is outside img_root={img_root}")
+            continue
+        
+        # 2. 这里的策略是：不复制图片，直接用软链接，或者在 config 里指定原图路径
+        # 为了方便，这里我们假设你不想复制几千张图，所以只生成 JSON
+        # Config 里的 data_prefix 需要指向原图所在的【父目录】
+        
+        images.append({
+            "id": img_id,
+            "file_name": file_name,  # 存相对 img_root 的路径，避免同名文件冲突
+            "height": h,
+            "width": w
+        })
+        
+        # 3. 处理标注
+        boxes = entry.get('annotation', {}).get('boxes', [])
+        for box_item in boxes:
+            phrase = box_item.get('phrase')
+            bbox = box_item.get('bbox') # [x1, y1, x2, y2]
+            
+            if phrase not in cat_map:
+                continue
+                
+            cat_id = cat_map[phrase]
+            
+            if not isinstance(bbox, (list, tuple)) or len(bbox) != 4:
+                continue
+
+            # 坐标转换: xyxy -> xywh
+            x1, y1, x2, y2 = map(float, bbox)
+            coco_w = x2 - x1
+            coco_h = y2 - y1
+            if coco_w <= 0 or coco_h <= 0:
+                continue
+            
+            annotations.append({
+                "id": ann_id,
+                "image_id": img_id,
+                "category_id": cat_id,
+                "bbox": [x1, y1, coco_w, coco_h],
+                "area": coco_w * coco_h,
+                "iscrowd": 0
+            })
+            ann_id += 1
+            
+        img_id += 1
+        
+        # 简单打印进度
+        if img_id % 500 == 0:
+            print(f"Processed {img_id}...")
+
+    # 构建最终字典
+    coco_output = {
+        "images": images,
+        "annotations": annotations,
+        "categories": categories
+    }
+    
+    save_path = os.path.join(output_dir, json_name)
+    with open(save_path, 'w') as f:
+        json.dump(coco_output, f)
+        
+    print(f"Done! Saved to {save_path}")
+    print(f"Total Images: {len(images)}, Total Annotations: {len(annotations)}")
+
+if __name__ == "__main__":
+    main()

grounding-dino/data_precess_val.py

@@ -0,0 +1,141 @@
+import json
+import os
+import cv2
+import numpy as np
+from pathlib import Path
+
+# ================= 配置区域 =================
+# 1. 你的验证集文件路径
+BASE_DIR = Path(__file__).resolve().parent
+WORKSPACE_DIR = BASE_DIR.parent.parent
+val_jsonl_path = str(WORKSPACE_DIR / 'rex_data' / 'data' / 'rex-omni-data' / 'train' / 'merged_all_rect_img_dir_plus_road_detection_eval_filtered_0.4.jsonl')
+
+# 2. 输出的 COCO 格式 json 路径
+output_json_path = str(BASE_DIR / 'dataset' / 'val_traffic_data_2_25.json')
+img_root = str(WORKSPACE_DIR / 'rex_data' / 'data' / 'PanoImages_data_all')  # 图片统一根目录
+
+# 3. 类别映射 (⚠️必须与训练时的 ID 严格一致！)
+# 如果你训练时 traffic light 是 0，这里也必须是 0
+categories_info = [
+    {"id": 0, "name": "traffic sign"},
+    {"id": 1, "name": "street light"},
+    {"id": 2, "name": "traffic light"},
+    {"id": 3, "name": "surveillance camera"},
+    {"id": 4, "name": "ball bollard"},
+    {"id": 5, "name": "fire hydrant"},
+    {"id": 6, "name": "trash bin"},
+    {"id": 7, "name": "manhole"},
+    {"id": 8, "name": "traffic cone"},
+    {"id": 9, "name": "bollard"}
+]
+# ===========================================
+
+def main():
+    # 准备 COCO 基础结构
+    coco_output = {
+        "images": [],
+        "annotations": [],
+        "categories": categories_info
+    }
+
+    # 建立 类别名 -> ID 的快速查询字典
+    cat_name_to_id = {cat['name']: cat['id'] for cat in categories_info}
+    
+    img_id_counter = 0
+    ann_id_counter = 0
+    
+    print(f"Reading validation data from {val_jsonl_path}...")
+    
+    with open(val_jsonl_path, 'r', encoding='utf-8') as f:
+        lines = f.readlines()
+
+    print(f"Processing {len(lines)} images...")
+
+    for line in lines:
+        if not line.strip():
+            continue
+            
+        entry = json.loads(line)
+        
+        # 1. 获取图片信息
+        img_path = entry.get('image_path')
+        if not img_path:
+            print(f"[Skip] Missing image_path in line")
+            continue
+            
+        # 验证图片是否存在 (需要读取宽高)
+        if not os.path.exists(img_path):
+            print(f"[Warn] Image not found: {img_path}")
+            continue
+            
+        img = cv2.imread(img_path)
+        if img is None:
+            print(f"[Warn] Cannot read image: {img_path}")
+            continue
+            
+        h, w = img.shape[:2]
+        rel_path = os.path.relpath(img_path, img_root)
+        if rel_path.startswith('..'):
+            print(f"[Skip] Image path outside img_root: {img_path}")
+            continue
+        file_name = rel_path.replace('\\', '/')
+        
+        # 添加图片信息
+        image_info = {
+            "id": img_id_counter,
+            "file_name": file_name,  # 存相对 img_root 的路径，避免同名文件冲突
+            "height": h,
+            "width": w
+        }
+        coco_output["images"].append(image_info)
+        
+        # 2. 处理标注 (解析 gt 字典)
+        # 格式: "gt": {"traffic light": [[x1, y1, x2, y2], ...], ...}
+        gt_dict = entry.get('gt', {})
+        
+        for class_name, bboxes in gt_dict.items():
+            # 过滤掉不需要的类别
+            if class_name not in cat_name_to_id:
+                continue
+                
+            cat_id = cat_name_to_id[class_name]
+            
+            for bbox in bboxes:
+                # 确保 bbox 格式正确
+                if len(bbox) != 4:
+                    continue
+                
+                x1, y1, x2, y2 = bbox
+                
+                # 转换: xyxy -> xywh
+                coco_w = x2 - x1
+                coco_h = y2 - y1
+                coco_x = x1
+                coco_y = y1
+                
+                # 添加标注信息
+                ann_info = {
+                    "id": ann_id_counter,
+                    "image_id": img_id_counter,
+                    "category_id": cat_id,
+                    "bbox": [coco_x, coco_y, coco_w, coco_h],
+                    "area": coco_w * coco_h,
+                    "iscrowd": 0
+                }
+                coco_output["annotations"].append(ann_info)
+                ann_id_counter += 1
+        
+        img_id_counter += 1
+        if img_id_counter % 100 == 0:
+            print(f"Processed {img_id_counter} images...")
+
+    # 保存结果
+    os.makedirs(os.path.dirname(output_json_path), exist_ok=True)
+    with open(output_json_path, 'w') as f:
+        json.dump(coco_output, f)
+        
+    print(f"Conversion Done! Saved to {output_json_path}")
+    print(f"Images: {len(coco_output['images'])}, Annotations: {len(coco_output['annotations'])}")
+
+if __name__ == "__main__":
+    main()

grounding-dino/evaluate_with_rex_omni.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+"""
+Convert MMDetection test pkl predictions to Rex-Omni evaluate.py jsonl format,
+then run Rex-Omni evaluation logic (large/small object split IoU evaluation).
+"""
+
+import argparse
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+
+import mmengine
+import numpy as np
+from mmengine.config import Config
+from mmengine.registry import init_default_scope
+
+
+_BASE_DIR = Path(__file__).resolve().parent
+DEFAULT_REX_EVAL_SCRIPT = str(
+    _BASE_DIR.parent.parent / "Rex-Omni_bxd" / "evaluation" / "evaluate.py"
+)
+
+
+def _to_numpy(data):
+    if data is None:
+        return None
+    if hasattr(data, "detach"):
+        data = data.detach()
+    if hasattr(data, "cpu"):
+        data = data.cpu()
+    if hasattr(data, "numpy"):
+        return data.numpy()
+    return np.asarray(data)
+
+
+def _get_field(obj, key):
+    if obj is None:
+        return None
+    if isinstance(obj, dict):
+        return obj.get(key)
+    if hasattr(obj, key):
+        return getattr(obj, key)
+    try:
+        return obj[key]
+    except Exception:
+        return None
+
+
+def _extract_pred_arrays(pred):
+    pred_instances = _get_field(pred, "pred_instances")
+    bboxes = _to_numpy(_get_field(pred_instances, "bboxes"))
+    labels = _to_numpy(_get_field(pred_instances, "labels"))
+    scores = _to_numpy(_get_field(pred_instances, "scores"))
+
+    if bboxes is None or labels is None or scores is None:
+        return (
+            np.zeros((0, 4), dtype=np.float32),
+            np.zeros((0,), dtype=np.int64),
+            np.zeros((0,), dtype=np.float32),
+        )
+
+    bboxes = np.asarray(bboxes, dtype=np.float32)
+    labels = np.asarray(labels, dtype=np.int64)
+    scores = np.asarray(scores, dtype=np.float32)
+    return bboxes, labels, scores
+
+
+def _resolve_image_path(data_info):
+    for key in ("img_path", "image_path", "file_name", "filename"):
+        value = data_info.get(key)
+        if value:
+            return str(value)
+    return ""
+
+
+def _to_xyxy(box):
+    if box is None or len(box) < 4:
+        return None
+    return [float(box[0]), float(box[1]), float(box[2]), float(box[3])]
+
+
+def _build_eval_rows(dataset, predictions, class_names, score_thr):
+    rows = []
+    sample_count = min(len(dataset), len(predictions))
+    if len(dataset) != len(predictions):
+        print(
+            f"[Warn] dataset size ({len(dataset)}) != predictions size ({len(predictions)}), "
+            f"using first {sample_count} samples."
+        )
+
+    for idx in range(sample_count):
+        pred_bboxes, pred_labels, pred_scores = _extract_pred_arrays(predictions[idx])
+        order = np.argsort(-pred_scores) if pred_scores.size > 0 else np.array([], dtype=np.int64)
+
+        pred_dict = {}
+        for rank in order.tolist():
+            if pred_scores[rank] < score_thr:
+                break
+
+            label = int(pred_labels[rank])
+            if label < 0 or label >= len(class_names):
+                continue
+            class_name = class_names[label]
+            box_xyxy = _to_xyxy(pred_bboxes[rank])
+            if box_xyxy is None:
+                continue
+
+            pred_dict.setdefault(class_name, []).append(box_xyxy)
+
+        data_info = dataset.get_data_info(idx)
+        image_path = _resolve_image_path(data_info)
+
+        gt_dict = {}
+        instances = data_info.get("instances", [])
+        for inst in instances:
+            label = inst.get("bbox_label")
+            if label is None:
+                label = inst.get("label")
+            if label is None:
+                continue
+
+            label = int(label)
+            if label < 0 or label >= len(class_names):
+                continue
+
+            box_xyxy = _to_xyxy(inst.get("bbox"))
+            if box_xyxy is None:
+                continue
+
+            class_name = class_names[label]
+            gt_dict.setdefault(class_name, []).append(box_xyxy)
+
+        categories = sorted(set(pred_dict.keys()) | set(gt_dict.keys()))
+        rows.append(
+            {
+                "image_path": image_path,
+                "categories": categories,
+                "extracted_predictions": pred_dict,
+                "gt": gt_dict,
+                "dataset_name": "GroundingDINO",
+                "task_name": "common_object_detection",
+            }
+        )
+
+    return rows
+
+
+def _load_rex_evaluate_fn(rex_eval_script):
+    eval_path = Path(rex_eval_script)
+    if not eval_path.exists():
+        raise FileNotFoundError(f"Rex evaluate.py not found: {eval_path}")
+
+    spec = importlib.util.spec_from_file_location("rex_omni_eval_module", str(eval_path))
+    module = importlib.util.module_from_spec(spec)
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+
+    if not hasattr(module, "evaluate_jsonl"):
+        raise AttributeError(f"evaluate_jsonl not found in: {eval_path}")
+    return module.evaluate_jsonl
+
+
+def _load_datasets_registry():
+    try:
+        from mmdet.registry import DATASETS  # type: ignore
+        return DATASETS
+    except ModuleNotFoundError:
+        local_mmdet_root = Path(__file__).resolve().parent / "mmdetection"
+        local_mmdet_pkg = local_mmdet_root / "mmdet"
+        if local_mmdet_pkg.exists():
+            sys.path.insert(0, str(local_mmdet_root))
+            from mmdet.registry import DATASETS  # type: ignore
+            return DATASETS
+        raise
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Run Grounding DINO predictions with Rex-Omni evaluation logic "
+            "(large/small object IoU split)."
+        )
+    )
+    parser.add_argument("--config", required=True, help="MMDetection config path")
+    parser.add_argument("--pkl", required=True, help="MMDetection test output pkl")
+    parser.add_argument(
+        "--output-jsonl",
+        default=None,
+        help="Converted jsonl for Rex evaluation (default: <pkl>_rex_eval.jsonl)",
+    )
+    parser.add_argument(
+        "--output-report",
+        default=None,
+        help="Rex-style txt report path (default: <output-jsonl>_results.txt)",
+    )
+    parser.add_argument(
+        "--rex-eval-script",
+        default=DEFAULT_REX_EVAL_SCRIPT,
+        help="Path to Rex-Omni evaluation/evaluate.py",
+    )
+    parser.add_argument(
+        "--score-thr",
+        type=float,
+        default=0.3,
+        help="Prediction score threshold before Rex evaluation",
+    )
+    parser.add_argument(
+        "--large-iou-thr",
+        type=float,
+        default=0.5,
+        help="IoU threshold for large objects in Rex evaluation",
+    )
+    parser.add_argument(
+        "--small-iou-thr",
+        type=float,
+        default=0.2,
+        help="IoU threshold for small objects in Rex evaluation",
+    )
+    parser.add_argument(
+        "--size-thr",
+        type=int,
+        default=50,
+        help="Size threshold to split large/small objects in Rex evaluation",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    output_jsonl = args.output_jsonl
+    if output_jsonl is None:
+        pkl_path = Path(args.pkl)
+        output_jsonl = str(pkl_path.with_suffix("")) + "_rex_eval.jsonl"
+
+    output_report = args.output_report
+    if output_report is None:
+        if output_jsonl.endswith(".jsonl"):
+            output_report = output_jsonl[:-6] + "_results.txt"
+        else:
+            output_report = output_jsonl + "_results.txt"
+
+    output_jsonl_dir = os.path.dirname(output_jsonl)
+    output_report_dir = os.path.dirname(output_report)
+    if output_jsonl_dir:
+        os.makedirs(output_jsonl_dir, exist_ok=True)
+    if output_report_dir:
+        os.makedirs(output_report_dir, exist_ok=True)
+
+    print(f"[Info] Loading config: {args.config}")
+    cfg = Config.fromfile(args.config)
+    init_default_scope(cfg.get("default_scope", "mmdet"))
+    DATASETS = _load_datasets_registry()
+
+    print("[Info] Building test dataset...")
+    dataset = DATASETS.build(cfg.test_dataloader.dataset)
+    class_names = dataset.metainfo["classes"]
+    print(f"[Info] Classes ({len(class_names)}): {class_names}")
+
+    print(f"[Info] Loading predictions: {args.pkl}")
+    predictions = mmengine.load(args.pkl)
+
+    print("[Info] Converting predictions to Rex jsonl format...")
+    rows = _build_eval_rows(dataset, predictions, class_names, args.score_thr)
+
+    with open(output_jsonl, "w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+    print(f"[Info] Converted jsonl saved to: {output_jsonl}")
+    print(f"[Info] Number of samples: {len(rows)}")
+
+    evaluate_jsonl = _load_rex_evaluate_fn(args.rex_eval_script)
+    print(f"[Info] Running Rex evaluate.py method from: {args.rex_eval_script}")
+    evaluate_jsonl(
+        output_jsonl,
+        large_iou_threshold=args.large_iou_thr,
+        small_iou_threshold=args.small_iou_thr,
+        size_threshold=args.size_thr,
+        output_file=output_report,
+    )
+    print(f"[Info] Rex-style report saved to: {output_report}")
+
+
+if __name__ == "__main__":
+    main()

grounding-dino/inference_crop_grounding_dino.py

@@ -0,0 +1,506 @@
+#!/usr/bin/env python3
+"""Run Grounding DINO on crop regions defined in a jsonl file.
+
+This script mirrors the crop-based inference flow used by
+`Rex-Omni_bxd/evaluation/inference_text_prompt_deny_crop.py`:
+1. Read per-image crop boxes from `extracted_predictions[crop_key]`.
+2. Run Grounding DINO on each crop region.
+3. Map crop-local detections back to the original image coordinate system.
+4. Optionally filter duplicate boxes across crops by IoU.
+5. Save jsonl rows that keep the original fields and append crop detections.
+"""
+
+import argparse
+import json
+import math
+import os
+import sys
+from collections import defaultdict
+from copy import deepcopy
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Tuple
+
+import cv2
+from tqdm import tqdm
+
+
+def patch_torch_load() -> None:
+    """Work around PyTorch 2.6+ weights_only default during checkpoint load."""
+    import torch
+
+    original_torch_load = torch.load
+
+    def patched_torch_load(*args, **kwargs):
+        if 'weights_only' not in kwargs:
+            kwargs['weights_only'] = False
+        return original_torch_load(*args, **kwargs)
+
+    torch.load = patched_torch_load
+
+
+def ensure_local_mmdet(mmdet_root: Path) -> None:
+    if str(mmdet_root) not in sys.path:
+        sys.path.insert(0, str(mmdet_root))
+
+
+def parse_args() -> argparse.Namespace:
+    base_dir = Path(__file__).resolve().parent
+    work_dir = base_dir / 'work_dirs' / 'mm_grounding_dino_traffic'
+
+    parser = argparse.ArgumentParser(
+        description='Grounding DINO crop-based inference on a jsonl dataset.')
+    parser.add_argument(
+        '--config',
+        default=str(work_dir / 'grounding_dino_swin-t_finetune_traffic.py'),
+        help='Grounding DINO config path.')
+    parser.add_argument(
+        '--checkpoint',
+        default='',
+        help='Checkpoint path. If empty, resolve from work_dir automatically.')
+    parser.add_argument(
+        '--test-jsonl-path',
+        default=str(
+            base_dir.parent.parent
+            / 'rex_data'
+            / 'data'
+            / 'filtered_low_precision_lt0.5_removed'
+            / '50_裁剪'
+            / 'answer.jsonl'
+        ),
+        help='Input jsonl with crop proposals.')
+    parser.add_argument(
+        '--image-root-dir',
+        default='',
+        help='Prefix for relative image paths. Absolute paths are used as-is.')
+    parser.add_argument(
+        '--save-path',
+        default=str(base_dir / 'eval_output' / 'crop_grounding_dino.jsonl'),
+        help='Output jsonl path.')
+    parser.add_argument(
+        '--crop-key',
+        default='crop',
+        help='Key inside extracted_predictions that stores crop boxes.')
+    parser.add_argument(
+        '--crop-expand',
+        type=int,
+        default=50,
+        help='Expand each crop by N pixels on all sides.')
+    parser.add_argument(
+        '--score-thr',
+        type=float,
+        default=0.7,
+        help='Grounding DINO score threshold.')
+    parser.add_argument(
+        '--iou-thr',
+        type=float,
+        default=0.5,
+        help='IoU threshold used to suppress duplicates across crops.')
+    parser.add_argument(
+        '--boundary-tolerance',
+        type=float,
+        default=-1.0,
+        help='Discard boxes touching crop boundary when >= 0; disable when < 0.')
+    parser.add_argument(
+        '--device',
+        default='cuda:0',
+        help='Inference device, e.g. cuda:0 or cpu.')
+    parser.add_argument(
+        '--start-idx',
+        type=int,
+        default=0,
+        help='Start index in jsonl.')
+    parser.add_argument(
+        '--end-idx',
+        type=int,
+        default=-1,
+        help='End index in jsonl, -1 means all.')
+    parser.add_argument(
+        '--texts',
+        default='',
+        help=(
+            'Custom text prompt entities. Example: '
+            '"traffic sign . street light . bollard ." '
+            'If empty, use config metainfo classes.'
+        ))
+    parser.add_argument(
+        '--mmdet-root',
+        default=str(base_dir / 'mmdetection'),
+        help='Local mmdetection repo root.')
+    return parser.parse_args()
+
+
+def resolve_checkpoint(requested_path: str, config_path: Path) -> Path:
+    if requested_path:
+        checkpoint = Path(requested_path)
+        if checkpoint.is_file():
+            return checkpoint
+        raise FileNotFoundError(f'Checkpoint not found: {checkpoint}')
+
+    work_dir = config_path.parent
+    best_paths = sorted(work_dir.glob('best*.pth'))
+    if best_paths:
+        return best_paths[-1]
+
+    last_checkpoint = work_dir / 'last_checkpoint'
+    if last_checkpoint.is_file():
+        path = Path(last_checkpoint.read_text(encoding='utf-8').strip())
+        if path.is_file():
+            return path
+
+    all_paths = sorted(work_dir.glob('*.pth'))
+    if all_paths:
+        return all_paths[-1]
+
+    raise FileNotFoundError(
+        f'No checkpoint found under work dir: {work_dir}')
+
+
+def load_jsonl(path: str) -> List[dict]:
+    rows = []
+    with open(path, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            rows.append(json.loads(line))
+    return rows
+
+
+def resolve_image_path(image_path: str, image_root_dir: str) -> str:
+    if not image_root_dir or os.path.isabs(image_path):
+        return image_path
+    return os.path.join(image_root_dir, image_path)
+
+
+def get_crop_boxes(extracted_predictions, crop_key: str) -> List[list]:
+    if not extracted_predictions:
+        return []
+    if isinstance(extracted_predictions, dict):
+        return extracted_predictions.get(crop_key, []) or []
+    if isinstance(extracted_predictions, list):
+        return extracted_predictions
+    return []
+
+
+def clamp_crop_box(
+    box: Sequence[float],
+    image_w: int,
+    image_h: int,
+    expand: int = 0,
+) -> Optional[List[int]]:
+    if not isinstance(box, (list, tuple)) or len(box) < 4:
+        return None
+    try:
+        x0, y0, x1, y1 = [float(v) for v in box[:4]]
+    except (TypeError, ValueError):
+        return None
+
+    expand = max(0, int(expand))
+    x0_i = max(0, int(math.floor(x0)) - expand)
+    y0_i = max(0, int(math.floor(y0)) - expand)
+    x1_i = min(image_w, int(math.ceil(x1)) + expand)
+    y1_i = min(image_h, int(math.ceil(y1)) + expand)
+
+    if x1_i <= x0_i or y1_i <= y0_i:
+        return None
+    return [x0_i, y0_i, x1_i, y1_i]
+
+
+def is_box_touching_boundary(
+    box: Sequence[float],
+    crop_w: int,
+    crop_h: int,
+    tolerance: float,
+) -> bool:
+    if tolerance < 0 or len(box) < 4:
+        return False
+    x0, y0, x1, y1 = box[:4]
+    return (
+        x0 <= tolerance
+        or y0 <= tolerance
+        or x1 >= crop_w - tolerance
+        or y1 >= crop_h - tolerance
+    )
+
+
+def calculate_iou(box1: Sequence[float], box2: Sequence[float]) -> float:
+    if len(box1) < 4 or len(box2) < 4:
+        return 0.0
+
+    x0 = max(box1[0], box2[0])
+    y0 = max(box1[1], box2[1])
+    x1 = min(box1[2], box2[2])
+    y1 = min(box1[3], box2[3])
+    if x1 <= x0 or y1 <= y0:
+        return 0.0
+
+    inter = (x1 - x0) * (y1 - y0)
+    area1 = max(0.0, box1[2] - box1[0]) * max(0.0, box1[3] - box1[1])
+    area2 = max(0.0, box2[2] - box2[0]) * max(0.0, box2[3] - box2[1])
+    union = area1 + area2 - inter
+    if union <= 0:
+        return 0.0
+    return inter / union
+
+
+def has_overlap_with_existing(
+    new_box: Sequence[float],
+    existing_boxes: Iterable[Sequence[float]],
+    iou_threshold: float,
+) -> bool:
+    return any(calculate_iou(new_box, box) > iou_threshold for box in existing_boxes)
+
+
+def normalize_entity_name(name: str) -> str:
+    return name.strip()
+
+
+def parse_text_entities(texts: str) -> List[str]:
+    entities = []
+    for item in texts.split('.'):
+        item = normalize_entity_name(item)
+        if item:
+            entities.append(item)
+    return entities
+
+
+def flatten_config_classes(cfg) -> List[str]:
+    classes = cfg.get('metainfo', {}).get('classes')
+    if classes:
+        return [str(x) for x in classes]
+    classes = cfg.get('class_name')
+    if classes:
+        return [str(x) for x in classes]
+    raise ValueError('Cannot find classes from config metainfo/class_name.')
+
+
+def group_predictions_by_label(
+    data_sample,
+    fallback_entities: Optional[Sequence[str]] = None,
+) -> Dict[str, List[List[float]]]:
+    grouped = defaultdict(list)
+    pred_instances = data_sample.pred_instances
+    bboxes = pred_instances.bboxes.detach().cpu().numpy()
+    label_names = list(getattr(pred_instances, 'label_names', []))
+    labels = []
+    if hasattr(pred_instances, 'labels'):
+        labels = pred_instances.labels.detach().cpu().tolist()
+
+    if not label_names and fallback_entities is not None:
+        for label in labels:
+            label = int(label)
+            if 0 <= label < len(fallback_entities):
+                label_names.append(str(fallback_entities[label]))
+            else:
+                label_names.append(str(label))
+
+    for bbox, label_name in zip(bboxes, label_names):
+        grouped[str(label_name)].append([float(v) for v in bbox.tolist()])
+    return dict(grouped)
+
+
+def adjust_predictions_to_global(
+    predictions: Dict[str, List[List[float]]],
+    offset_x: int,
+    offset_y: int,
+) -> Dict[str, List[List[float]]]:
+    adjusted = {}
+    for category, boxes in predictions.items():
+        adjusted[category] = []
+        for box in boxes:
+            if len(box) < 4:
+                continue
+            adjusted[category].append([
+                box[0] + offset_x,
+                box[1] + offset_y,
+                box[2] + offset_x,
+                box[3] + offset_y,
+            ])
+    return adjusted
+
+
+def filter_local_predictions(
+    predictions: Dict[str, List[List[float]]],
+    crop_w: int,
+    crop_h: int,
+    boundary_tolerance: float,
+) -> Dict[str, List[List[float]]]:
+    filtered = {}
+    for category, boxes in predictions.items():
+        keep = []
+        for box in boxes:
+            if is_box_touching_boundary(box, crop_w, crop_h, boundary_tolerance):
+                continue
+            keep.append(box)
+        filtered[category] = keep
+    return filtered
+
+
+def filter_global_predictions(
+    predictions: Dict[str, List[List[float]]],
+    existing_boxes_by_category: Dict[str, List[List[float]]],
+    iou_threshold: float,
+) -> Tuple[Dict[str, List[List[float]]], Dict[str, List[List[float]]]]:
+    filtered = {}
+    updated_existing = {
+        key: [list(box) for box in value]
+        for key, value in existing_boxes_by_category.items()
+    }
+
+    for category, boxes in predictions.items():
+        updated_existing.setdefault(category, [])
+        keep = []
+        for box in boxes:
+            if has_overlap_with_existing(box, updated_existing[category], iou_threshold):
+                continue
+            keep.append(box)
+            updated_existing[category].append(box)
+        filtered[category] = keep
+
+    return filtered, updated_existing
+
+
+def merge_prediction_dicts(dicts: Iterable[Dict[str, List[List[float]]]]) -> Dict[str, List[List[float]]]:
+    merged = defaultdict(list)
+    for pred in dicts:
+        for category, boxes in pred.items():
+            merged[category].extend(boxes)
+    return dict(merged)
+
+
+def main() -> None:
+    args = parse_args()
+    patch_torch_load()
+
+    config_path = Path(args.config).resolve()
+    checkpoint_path = resolve_checkpoint(args.checkpoint, config_path)
+    mmdet_root = Path(args.mmdet_root).resolve()
+
+    ensure_local_mmdet(mmdet_root)
+
+    from mmengine.config import Config
+    from mmengine.registry import init_default_scope
+    from mmdet.apis import inference_detector, init_detector
+
+    if args.crop_expand < 0:
+        raise ValueError('--crop_expand must be >= 0')
+    if args.end_idx != -1 and args.end_idx < args.start_idx:
+        raise ValueError('--end_idx must be -1 or >= --start_idx')
+
+    save_dir = os.path.dirname(args.save_path)
+    if save_dir:
+        os.makedirs(save_dir, exist_ok=True)
+
+    print(f'[Info] Loading config: {config_path}')
+    cfg = Config.fromfile(str(config_path))
+    init_default_scope(cfg.get('default_scope', 'mmdet'))
+
+    entities = parse_text_entities(args.texts) if args.texts else flatten_config_classes(cfg)
+    print(f'[Info] Using {len(entities)} entities: {entities}')
+
+    print(f'[Info] Loading checkpoint: {checkpoint_path}')
+    model = init_detector(str(config_path), str(checkpoint_path), device=args.device)
+
+    prompt_entities: Sequence[str] = tuple(entities)
+
+    print(f'[Info] Loading jsonl: {args.test_jsonl_path}')
+    rows = load_jsonl(args.test_jsonl_path)
+    if args.end_idx == -1:
+        selected_rows = rows[args.start_idx:]
+    else:
+        selected_rows = rows[args.start_idx:args.end_idx]
+    print(f'[Info] Processing {len(selected_rows)} rows')
+
+    predictions = []
+    for entry in tqdm(selected_rows, desc='Grounding DINO crop inference'):
+        image_path = entry.get('image_path', '')
+        extracted_predictions = entry.get('extracted_predictions', {})
+        crop_boxes = get_crop_boxes(extracted_predictions, args.crop_key)
+        if not crop_boxes:
+            continue
+
+        full_image_path = resolve_image_path(image_path, args.image_root_dir)
+        if not os.path.exists(full_image_path):
+            print(f'[Warn] Image not found: {full_image_path}')
+            continue
+
+        image = cv2.imread(full_image_path)
+        if image is None:
+            print(f'[Warn] Failed to read image: {full_image_path}')
+            continue
+        image_h, image_w = image.shape[:2]
+
+        crop_outputs = []
+        merged_outputs = []
+        existing_boxes_by_category: Dict[str, List[List[float]]] = {}
+
+        for crop_idx, crop_box in enumerate(crop_boxes):
+            crop_box_int = clamp_crop_box(
+                crop_box, image_w, image_h, expand=args.crop_expand)
+            if crop_box_int is None:
+                print(f'[Warn] Skip invalid crop box #{crop_idx}: {crop_box}')
+                continue
+
+            x0, y0, x1, y1 = crop_box_int
+            crop_img = image[y0:y1, x0:x1]
+            crop_h, crop_w = crop_img.shape[:2]
+            if crop_h == 0 or crop_w == 0:
+                continue
+
+            result = inference_detector(
+                model,
+                crop_img,
+                text_prompt=prompt_entities,
+                custom_entities=True,
+            )
+            pred_instances = result.pred_instances
+            if hasattr(pred_instances, 'scores'):
+                keep = pred_instances.scores > args.score_thr
+                pred_instances = pred_instances[keep]
+                result.pred_instances = pred_instances
+
+            local_predictions = group_predictions_by_label(
+                result, fallback_entities=prompt_entities)
+            filtered_local = filter_local_predictions(
+                local_predictions,
+                crop_w=crop_w,
+                crop_h=crop_h,
+                boundary_tolerance=args.boundary_tolerance,
+            )
+            global_predictions = adjust_predictions_to_global(
+                filtered_local, x0, y0)
+            filtered_global, existing_boxes_by_category = filter_global_predictions(
+                global_predictions,
+                existing_boxes_by_category=existing_boxes_by_category,
+                iou_threshold=args.iou_thr,
+            )
+
+            crop_outputs.append(
+                {
+                    'crop_idx': crop_idx,
+                    'crop_box': crop_box_int,
+                    'local_predictions': filtered_local,
+                    'global_predictions': filtered_global,
+                })
+            merged_outputs.append(filtered_global)
+
+        if not crop_outputs:
+            continue
+
+        prediction_row = deepcopy(entry)
+        prediction_row['text_prompt_entities'] = list(prompt_entities)
+        prediction_row['new_extract'] = merged_outputs
+        prediction_row['crop_predictions'] = crop_outputs
+        prediction_row['merged_predictions'] = merge_prediction_dicts(merged_outputs)
+        predictions.append(prediction_row)
+
+    print(f'[Info] Saving {len(predictions)} rows to: {args.save_path}')
+    with open(args.save_path, 'w', encoding='utf-8') as f:
+        for row in predictions:
+            f.write(json.dumps(row, ensure_ascii=False) + '\n')
+
+    print('[Info] Done.')
+
+
+if __name__ == '__main__':
+    main()

grounding-dino/run_eval_and_vis.sh

@@ -0,0 +1,203 @@
+#!/bin/bash
+# ================================================================
+# Grounding DINO 评估 + 可视化 一体化脚本
+# 功能:
+#   1. 用 test.py 跑推理，保存 pkl 结果 + 可视化图片
+#   2. 用自定义脚本计算 Precision / Recall / F1 (per-class + overall)
+#   3. 用 analyze_results.py 展示 topk 好/坏样本
+#   4. 用 confusion_matrix.py 生成混淆矩阵
+# ================================================================
+set -euo pipefail
+
+resolve_python() {
+    if [ -n "${PYTHON:-}" ]; then
+        echo "${PYTHON}"
+    elif command -v python3 >/dev/null 2>&1; then
+        command -v python3
+    elif command -v python >/dev/null 2>&1; then
+        command -v python
+    else
+        echo ""
+    fi
+}
+
+detect_gpus() {
+    if [ -n "${GPUS:-}" ]; then
+        echo "${GPUS}"
+        return
+    fi
+
+    if [ -n "${CUDA_VISIBLE_DEVICES:-}" ]; then
+        awk -F',' '{print NF}' <<< "${CUDA_VISIBLE_DEVICES}"
+        return
+    fi
+
+    if command -v nvidia-smi >/dev/null 2>&1; then
+        local n
+        n=$(nvidia-smi -L 2>/dev/null | wc -l | tr -d ' ')
+        if [ "${n}" -gt 0 ]; then
+            echo "${n}"
+            return
+        fi
+    fi
+
+    echo 1
+}
+
+resolve_checkpoint() {
+    local requested_path="${1:-}"
+    local work_dir="${2}"
+    local best_checkpoint
+
+    if [ -n "${requested_path}" ] && [ -f "${requested_path}" ]; then
+        echo "${requested_path}"
+        return
+    fi
+
+    best_checkpoint=$(find "${work_dir}" -maxdepth 1 -type f -name 'best*.pth' | sort | tail -n 1)
+    if [ -n "${best_checkpoint}" ] && [ -f "${best_checkpoint}" ]; then
+        echo "${best_checkpoint}"
+        return
+    fi
+
+    if [ -f "${work_dir}/last_checkpoint" ]; then
+        local last_checkpoint
+        last_checkpoint=$(cat "${work_dir}/last_checkpoint")
+        if [ -f "${last_checkpoint}" ]; then
+            echo "${last_checkpoint}"
+            return
+        fi
+    fi
+
+    local latest_checkpoint
+    latest_checkpoint=$(find "${work_dir}" -maxdepth 1 -type f -name '*.pth' | sort | tail -n 1)
+    if [ -n "${latest_checkpoint}" ] && [ -f "${latest_checkpoint}" ]; then
+        echo "${latest_checkpoint}"
+        return
+    fi
+
+    echo ""
+}
+
+# ============== 路径配置 ==============
+PYTHON="$(resolve_python)"
+BASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MMDET_DIR="${BASE_DIR}/mmdetection"
+WORK_DIR="${BASE_DIR}/work_dirs/mm_grounding_dino_traffic"
+
+CONFIG="${CONFIG:-${WORK_DIR}/grounding_dino_swin-t_finetune_traffic.py}"
+CHECKPOINT="${CHECKPOINT:-${WORK_DIR}/best_coco_traffic_sign_precision_epoch_18.pth}"
+CHECKPOINT="$(resolve_checkpoint "${CHECKPOINT}" "${WORK_DIR}")"
+
+OUTPUT_DIR="${OUTPUT_DIR:-${BASE_DIR}/eval_output}"
+PKL_FILE="${OUTPUT_DIR}/predictions.pkl"
+VIS_DIR="${OUTPUT_DIR}/vis_images"
+ANALYZE_DIR="${OUTPUT_DIR}/analyze_results"
+CM_DIR="${OUTPUT_DIR}/confusion_matrix"
+
+SCORE_THR="${SCORE_THR:-0.3}"
+TOPK="${TOPK:-20}"
+GPUS="$(detect_gpus)"
+BATCH_SIZE="${BATCH_SIZE:-4}"
+
+if [ -z "${PYTHON}" ]; then
+    echo "Error: python executable not found."
+    exit 1
+fi
+
+if [ ! -f "${CONFIG}" ]; then
+    echo "Error: config file not found: ${CONFIG}"
+    exit 1
+fi
+
+if [ -z "${CHECKPOINT}" ] || [ ! -f "${CHECKPOINT}" ]; then
+    echo "Error: checkpoint file not found."
+    echo "Tried default path and fallback lookup under: ${WORK_DIR}"
+    exit 1
+fi
+
+mkdir -p "$OUTPUT_DIR" "$VIS_DIR" "$ANALYZE_DIR" "$CM_DIR"
+
+# ============== Step 1: 推理 + 保存pkl + 可视化 ==============
+echo "========================================"
+echo "STEP 1: 运行推理 (保存pkl + 可视化)"
+echo "========================================"
+echo "CONFIG: ${CONFIG}"
+echo "CHECKPOINT: ${CHECKPOINT}"
+echo "GPUS: ${GPUS}"
+echo "BATCH_SIZE: ${BATCH_SIZE}"
+
+cd "${MMDET_DIR}"
+if [ "${GPUS}" -le 1 ]; then
+    "${PYTHON}" tools/test.py \
+        "$CONFIG" \
+        "$CHECKPOINT" \
+        --out "$PKL_FILE" \
+        --show-dir "$VIS_DIR" \
+        --cfg-options test_dataloader.batch_size="${BATCH_SIZE}"
+else
+    bash tools/dist_test.sh \
+        "$CONFIG" \
+        "$CHECKPOINT" \
+        "${GPUS}" \
+        --out "$PKL_FILE" \
+        --show-dir "$VIS_DIR" \
+        --cfg-options test_dataloader.batch_size="${BATCH_SIZE}"
+fi
+
+echo ">>> pkl 结果已保存到: $PKL_FILE"
+echo ">>> 可视化结果已保存到: $VIS_DIR"
+
+# ============== Step 2: 计算 Precision / Recall / F1 ==============
+echo "========================================"
+echo "STEP 2: 计算 Precision / Recall / F1"
+echo "========================================"
+
+"${PYTHON}" ${BASE_DIR}/compute_recall_f1.py \
+    --config "$CONFIG" \
+    --pkl "$PKL_FILE" \
+    --score-thr $SCORE_THR \
+    --output "${OUTPUT_DIR}/metrics_report.txt"
+
+# ============== Step 3: analyze_results (好/坏样本可视化) ==============
+echo "========================================"
+echo "STEP 3: 好/坏样本可视化 (topk=${TOPK})"
+echo "========================================"
+
+"${PYTHON}" ${MMDET_DIR}/tools/analysis_tools/analyze_results.py \
+    "$CONFIG" \
+    "$PKL_FILE" \
+    "$ANALYZE_DIR" \
+    --topk $TOPK \
+    --show-score-thr $SCORE_THR \
+    --cfg-options launcher=none
+
+echo ">>> 好样本保存到: ${ANALYZE_DIR}/good/"
+echo ">>> 坏样本保存到: ${ANALYZE_DIR}/bad/"
+
+# ============== Step 4: 混淆矩阵 ==============
+echo "========================================"
+echo "STEP 4: 生成混淆矩阵"
+echo "========================================"
+
+"${PYTHON}" ${MMDET_DIR}/tools/analysis_tools/confusion_matrix.py \
+    "$CONFIG" \
+    "$PKL_FILE" \
+    "$CM_DIR" \
+    --score-thr $SCORE_THR \
+    --tp-iou-thr 0.5
+
+echo ">>> 混淆矩阵保存到: $CM_DIR"
+
+echo ""
+echo "========================================"
+echo "全部完成! 结果目录结构:"
+echo "  ${OUTPUT_DIR}/"
+echo "  ├── predictions.pkl          (推理结果)"
+echo "  ├── metrics_report.txt       (Precision/Recall/F1)"
+echo "  ├── vis_images/              (检测可视化)"
+echo "  ├── analyze_results/         (好坏样本对比)"
+echo "  │   ├── good/                (检测效果好的样本)"
+echo "  │   └── bad/                 (检测效果差的样本)"
+echo "  └── confusion_matrix/        (混淆矩阵)"
+echo "========================================"

grounding-dino/run_eval_rex_style.sh

@@ -0,0 +1,193 @@
+#!/bin/bash
+set -e
+
+if [ -n "${PYTHON:-}" ]; then
+  PYTHON="${PYTHON}"
+else
+  PYTHON="$(command -v python3 || true)"
+fi
+
+if [ -z "${PYTHON}" ]; then
+  echo "Error: python executable not found."
+  exit 1
+fi
+
+BASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MMDET_DIR="${BASE_DIR}/mmdetection"
+PIP_INDEX_URL="${PIP_INDEX_URL:-https://pypi.tuna.tsinghua.edu.cn/simple}"
+SETUP_ENV="${SETUP_ENV:-1}"
+USE_VENV="${USE_VENV:-1}"
+VENV_DIR="${VENV_DIR:-${BASE_DIR}/.eval_venv}"
+INSTALL_OPENMIM="${INSTALL_OPENMIM:-0}"
+HF_ENDPOINT_URL="${HF_ENDPOINT_URL:-https://hf-mirror.com}"
+LOCAL_BERT_DIR="${LOCAL_BERT_DIR:-${BASE_DIR}/pretrained/hf/bert-base-uncased}"
+HF_HOME_DIR="${HF_HOME_DIR:-${BASE_DIR}/.cache/huggingface}"
+
+CONFIG="${CONFIG:-${BASE_DIR}/mmdetection/configs/mm_grounding_dino/grounding_dino_swin-t_finetune_traffic.py}"
+CHECKPOINT="${CHECKPOINT:-$(cat ${BASE_DIR}/work_dirs/mm_grounding_dino_traffic/last_checkpoint)}"
+OUTPUT_DIR="${OUTPUT_DIR:-${BASE_DIR}/eval_output_rex_style}"
+
+PKL_FILE="${OUTPUT_DIR}/predictions.pkl"
+JSONL_FILE="${OUTPUT_DIR}/predictions_rex_eval.jsonl"
+REPORT_FILE="${OUTPUT_DIR}/rex_eval_results.txt"
+VIS_DIR="${OUTPUT_DIR}/vis_images"
+
+GPUS=${1:-1}
+SCORE_THR="${SCORE_THR:-0.3}"
+LARGE_IOU_THR="${LARGE_IOU_THR:-0.5}"
+SMALL_IOU_THR="${SMALL_IOU_THR:-0.2}"
+SIZE_THR="${SIZE_THR:-50}"
+BATCH_SIZE="${BATCH_SIZE:-1}"
+NUM_WORKERS="${NUM_WORKERS:-4}"
+DISABLE_TF32="${DISABLE_TF32:-1}"
+DEBUG_SYNC="${DEBUG_SYNC:-0}"
+
+mkdir -p "${OUTPUT_DIR}" "${VIS_DIR}"
+
+if [ "${USE_VENV}" = "1" ]; then
+  if [ ! -x "${VENV_DIR}/bin/python" ]; then
+    if [ "${SETUP_ENV}" = "1" ]; then
+      echo "Creating isolated venv: ${VENV_DIR}"
+      "${PYTHON}" -m venv "${VENV_DIR}" --system-site-packages
+    else
+      echo "Error: venv not found at ${VENV_DIR}. Run with SETUP_ENV=1 first."
+      exit 1
+    fi
+  fi
+  PYTHON="${VENV_DIR}/bin/python"
+fi
+
+if [ "${SETUP_ENV}" = "1" ]; then
+  echo "========================================"
+  echo "STEP 0: Rebuild evaluation environment"
+  echo "========================================"
+  echo "PYTHON(install): ${PYTHON}"
+  echo "PIP_INDEX_URL: ${PIP_INDEX_URL}"
+  echo "INSTALL_OPENMIM: ${INSTALL_OPENMIM}"
+
+  "${PYTHON}" -m pip install -U pip setuptools wheel packaging -i "${PIP_INDEX_URL}"
+  if [ "${INSTALL_OPENMIM}" = "1" ]; then
+    "${PYTHON}" -m pip install -U openmim -i "${PIP_INDEX_URL}"
+  fi
+  "${PYTHON}" -m pip install mmengine -i "${PIP_INDEX_URL}"
+  if ! "${PYTHON}" -m pip install "mmcv==2.1.0" --no-cache-dir -i "${PIP_INDEX_URL}"; then
+    echo "mmcv install failed, retry with --no-build-isolation (fix pkg_resources error)"
+    "${PYTHON}" -m pip install -U setuptools wheel packaging ninja Cython -i "${PIP_INDEX_URL}"
+    "${PYTHON}" -m pip install "mmcv==2.1.0" --no-cache-dir --no-build-isolation -i "${PIP_INDEX_URL}"
+  fi
+
+  cd "${MMDET_DIR}"
+  "${PYTHON}" -m pip install -r requirements/multimodal.txt -i "${PIP_INDEX_URL}"
+  "${PYTHON}" -m pip install -v -e . --no-build-isolation
+
+  "${PYTHON}" -m pip install --no-cache-dir --upgrade \
+    "opencv-python-headless==4.8.0.74" "numpy<2.0.0" "tqdm==4.67.1" "requests>=2.32.2" \
+    -i "${PIP_INDEX_URL}"
+
+  export HF_ENDPOINT="${HF_ENDPOINT_URL}"
+  export HF_HOME="${HF_HOME_DIR}"
+  export HUGGINGFACE_HUB_CACHE="${HF_HOME_DIR}/hub"
+  export TRANSFORMERS_CACHE="${HF_HOME_DIR}/hub"
+  export LOCAL_BERT_DIR
+  mkdir -p "${LOCAL_BERT_DIR}" "${HUGGINGFACE_HUB_CACHE}"
+
+  "${PYTHON}" - <<'PY'
+import os
+from pathlib import Path
+from huggingface_hub import snapshot_download
+
+repo_id = "bert-base-uncased"
+local_dir = os.environ["LOCAL_BERT_DIR"]
+snapshot_download(repo_id=repo_id, local_dir=local_dir)
+
+required_files = ["config.json", "tokenizer_config.json", "vocab.txt"]
+missing = [f for f in required_files if not Path(local_dir, f).exists()]
+if missing:
+    raise SystemExit(f"Missing required files in local BERT dir: {missing}")
+print("Local BERT files are ready.")
+PY
+
+  export HF_HUB_OFFLINE=1
+  export TRANSFORMERS_OFFLINE=1
+fi
+
+echo "========================================"
+echo "STEP 1: Run MMDetection test to export pkl"
+echo "========================================"
+echo "CONFIG: ${CONFIG}"
+echo "CHECKPOINT: ${CHECKPOINT}"
+echo "GPUS: ${GPUS}"
+echo "OUTPUT_DIR: ${OUTPUT_DIR}"
+echo "BATCH_SIZE: ${BATCH_SIZE}"
+echo "NUM_WORKERS: ${NUM_WORKERS}"
+
+if [ "${DISABLE_TF32}" = "1" ]; then
+  # TF32 can trigger unstable GEMM behavior on some torch/cuda combos.
+  export NVIDIA_TF32_OVERRIDE=0
+  export TORCH_ALLOW_TF32_CUBLAS_OVERRIDE=0
+fi
+if [ "${DEBUG_SYNC}" = "1" ]; then
+  export CUDA_LAUNCH_BLOCKING=1
+fi
+
+cd "${MMDET_DIR}"
+
+run_test_once () {
+  local bs="$1"
+  local workers="$2"
+
+  if [ "${GPUS}" -eq 1 ]; then
+    "${PYTHON}" tools/test.py \
+      "${CONFIG}" \
+      "${CHECKPOINT}" \
+      --out "${PKL_FILE}" \
+      --show-dir "${VIS_DIR}" \
+      --cfg-options \
+        test_dataloader.batch_size="${bs}" \
+        test_dataloader.num_workers="${workers}" \
+        test_dataloader.persistent_workers=False
+  else
+    bash tools/dist_test.sh \
+      "${CONFIG}" \
+      "${CHECKPOINT}" \
+      "${GPUS}" \
+      --out "${PKL_FILE}" \
+      --show-dir "${VIS_DIR}" \
+      --cfg-options \
+        test_dataloader.batch_size="${bs}" \
+        test_dataloader.num_workers="${workers}" \
+        test_dataloader.persistent_workers=False
+  fi
+}
+
+if ! run_test_once "${BATCH_SIZE}" "${NUM_WORKERS}"; then
+  if [ "${BATCH_SIZE}" -ne 1 ]; then
+    echo "Primary test run failed, retry with safer settings (BATCH_SIZE=1, DEBUG_SYNC=1)."
+    export CUDA_LAUNCH_BLOCKING=1
+    run_test_once 1 2
+  else
+    exit 1
+  fi
+fi
+
+echo "========================================"
+echo "STEP 2: Run Rex-Omni evaluate.py method"
+echo "========================================"
+
+PYTHONPATH="${MMDET_DIR}:${PYTHONPATH}" "${PYTHON}" "${BASE_DIR}/evaluate_with_rex_omni.py" \
+  --config "${CONFIG}" \
+  --pkl "${PKL_FILE}" \
+  --output-jsonl "${JSONL_FILE}" \
+  --output-report "${REPORT_FILE}" \
+  --score-thr "${SCORE_THR}" \
+  --large-iou-thr "${LARGE_IOU_THR}" \
+  --small-iou-thr "${SMALL_IOU_THR}" \
+  --size-thr "${SIZE_THR}"
+
+echo "========================================"
+echo "Done."
+echo "PKL: ${PKL_FILE}"
+echo "Rex JSONL: ${JSONL_FILE}"
+echo "Rex report: ${REPORT_FILE}"
+echo "VIS: ${VIS_DIR}"
+echo "========================================"

grounding-dino/run_train.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+set -e  # 遇到错误立即停止
+set -x  # 打印调试信息
+
+# ================= 配置区域 =================
+BASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -n "${PYTHON:-}" ]; then
+    PYTHON="${PYTHON}"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON="$(command -v python3)"
+else
+    PYTHON="$(command -v python)"
+fi
+PIP="${PYTHON} -m pip"
+MMDET_DIR="${BASE_DIR}/mmdetection"
+CONFIG_FILE="${MMDET_DIR}/configs/grounding_dino/my_swin_b_finetune.py"
+GPUS=2
+# ===========================================
+
+echo "========================================"
+echo "STEP 1: 暴力清理 (清空所有相关库)"
+echo "========================================"
+
+# 卸载所有涉及的库
+$PIP uninstall mmdet mmcv mmcv-full mmengine -y || true
+$PIP uninstall opencv-python opencv-python-headless opencv-contrib-python -y || true
+$PIP uninstall opencv-python opencv-python-headless opencv-contrib-python -y || true
+$PIP uninstall numpy -y || true
+
+# 物理删除残留
+SITE_PACKAGES=$($PYTHON -c "import site; print(site.getsitepackages()[0])")
+rm -rf "${SITE_PACKAGES}/cv2"
+rm -rf "${SITE_PACKAGES}/opencv*"
+rm -rf "${SITE_PACKAGES}/numpy*" 
+rm -rf "${SITE_PACKAGES}/mmcv*"
+
+echo "========================================"
+echo "STEP 2: 安装 MM 基础库 (锁定兼容版本)"
+echo "========================================"
+
+# 安装基础引擎
+$PIP install -U openmim -i https://pypi.tuna.tsinghua.edu.cn/simple
+$PIP install mmengine -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+# 【关键修改】显式安装 2.1.0 版本，避开 incompatible 报错
+# 使用 --no-cache-dir 防止缓存干扰
+$PIP install "mmcv==2.1.0" --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+echo "========================================"
+echo "STEP 3: 安装 MMDetection"
+echo "========================================"
+
+cd "$MMDET_DIR"
+$PIP install -r requirements/multimodal.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+$PIP install -v -e .
+
+echo "========================================"
+echo "STEP 4: 环境强制修复 (解决 OpenCV 和 NumPy)"
+echo "========================================"
+
+echo "正在剔除冲突库..."
+# 1. 卸载可能被自动安装的标准版 OpenCV
+$PIP uninstall opencv-python opencv-contrib-python -y || true
+$PIP uninstall opencv-python-headless -y || true
+
+echo "正在锁定正确版本..."
+# 2. 安装 Headless OpenCV
+$PIP install opencv-python-headless==4.8.0.74 --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+# 3. 强制重装 NumPy 1.x (解决 import error)
+$PIP install "numpy<2.0.0" --force-reinstall -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+echo "========================================"
+echo "STEP 5: 最终验证 & 启动"
+echo "========================================"
+
+# 验证 NumPy 版本
+$PYTHON -c "import numpy; print(f'>>> Current NumPy Version: {numpy.__version__}'); assert int(numpy.__version__.split('.')[0]) < 2"
+# 验证 OpenCV
+$PYTHON -c "import cv2; print(f'>>> Current OpenCV Version: {cv2.__version__}')"
+# 验证 MMCV 版本
+$PYTHON -c "import mmcv; print(f'>>> Current MMCV Version: {mmcv.__version__}')"
+
+# 启动训练
+export OPENCV_HEADLESS=1
+bash "${MMDET_DIR}/tools/dist_train.sh" "${MMDET_DIR}/configs/grounding_dino/grounding_dino_swin-b_mydata.py" "${GPUS}"

grounding-dino/train_mm_grounding_dino.sh

@@ -0,0 +1,177 @@
+#!/bin/bash
+set -e  # 遇到错误立即停止
+set -x  # 打印调试信息
+
+# ================= 配置区域 =================
+BASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -n "${PYTHON:-}" ]; then
+    PYTHON="${PYTHON}"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON="$(command -v python3)"
+else
+    PYTHON="$(command -v python)"
+fi
+PIP="${PYTHON} -m pip"
+MMDET_DIR="${BASE_DIR}/mmdetection"
+CONFIG_FILE="${MMDET_DIR}/configs/grounding_dino/my_swin_b_finetune.py"
+GPUS=1
+HF_ENDPOINT_URL="${HF_ENDPOINT_URL:-https://hf-mirror.com}"
+LOCAL_BERT_DIR="${LOCAL_BERT_DIR:-${BASE_DIR}/pretrained/hf/bert-base-uncased}"
+HF_HOME_DIR="${HF_HOME_DIR:-${BASE_DIR}/.cache/huggingface}"
+# ===========================================
+
+echo "========================================"
+echo "STEP 1: 暴力清理 (清空所有相关库)"
+echo "========================================"
+
+# 卸载所有涉及的库
+$PIP uninstall mmdet mmcv mmcv-full mmengine -y || true
+$PIP uninstall opencv-python opencv-python-headless opencv-contrib-python -y || true
+$PIP uninstall opencv-python opencv-python-headless opencv-contrib-python -y || true
+$PIP uninstall numpy -y || true
+$PIP uninstall tqdm requests -y || true
+
+# 物理删除残留
+SITE_PACKAGES=$($PYTHON -c "import site; print(site.getsitepackages()[0])")
+rm -rf "${SITE_PACKAGES}/cv2"
+rm -rf "${SITE_PACKAGES}/opencv*"
+rm -rf "${SITE_PACKAGES}/numpy*" 
+rm -rf "${SITE_PACKAGES}/mmcv*"
+rm -rf "${SITE_PACKAGES}/tqdm" "${SITE_PACKAGES}/tqdm-"*.dist-info
+
+echo "========================================"
+echo "STEP 2: 安装 MM 基础库 (锁定兼容版本)"
+echo "========================================"
+
+# 安装基础引擎
+$PIP install -U openmim -i https://pypi.tuna.tsinghua.edu.cn/simple
+$PIP install mmengine -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+# 【关键修改】显式安装 2.1.0 版本，避开 incompatible 报错
+# 使用 --no-cache-dir 防止缓存干扰
+$PIP install "mmcv==2.1.0" --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+echo "========================================"
+echo "STEP 3: 安装 MMDetection"
+echo "========================================"
+
+cd "$MMDET_DIR"
+$PIP install -r requirements/multimodal.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+$PIP install -v -e .
+
+echo "========================================"
+echo "STEP 4: 环境强制修复 (解决 OpenCV 和 NumPy)"
+echo "========================================"
+
+echo "正在剔除冲突库..."
+# 1. 卸载可能被自动安装的标准版 OpenCV
+$PIP uninstall opencv-python opencv-contrib-python -y || true
+$PIP uninstall opencv-python-headless -y || true
+
+echo "正在锁定正确版本..."
+# 2. 安装 Headless OpenCV
+$PIP install opencv-python-headless==4.8.0.74 --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+# 3. 强制重装 NumPy 1.x (解决 import error)
+$PIP install "numpy<2.0.0" --force-reinstall -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+# 4. 修复 tqdm 元数据损坏 (解决 transformers 检查版本失败)
+$PIP install --no-cache-dir --force-reinstall "tqdm==4.67.1" "requests>=2.32.2" -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+echo "========================================"
+echo "STEP 5: 使用 HF 国内镜像下载 BERT 到本地"
+echo "========================================"
+
+export HF_ENDPOINT="$HF_ENDPOINT_URL"
+export HF_HOME="$HF_HOME_DIR"
+export HUGGINGFACE_HUB_CACHE="${HF_HOME_DIR}/hub"
+export TRANSFORMERS_CACHE="${HF_HOME_DIR}/hub"
+export LOCAL_BERT_DIR
+mkdir -p "$LOCAL_BERT_DIR" "$HUGGINGFACE_HUB_CACHE"
+
+$PYTHON - <<'PY'
+import os
+from pathlib import Path
+from huggingface_hub import snapshot_download
+
+repo_id = "bert-base-uncased"
+local_dir = os.environ["LOCAL_BERT_DIR"]
+
+print(f">>> HF endpoint: {os.environ.get('HF_ENDPOINT')}")
+print(f">>> Downloading {repo_id} to: {local_dir}")
+snapshot_download(repo_id=repo_id, local_dir=local_dir)
+
+required_files = [
+    "config.json",
+    "tokenizer_config.json",
+    "vocab.txt",
+]
+missing = [f for f in required_files if not Path(local_dir, f).exists()]
+if missing:
+    raise SystemExit(f"Missing required files in local BERT dir: {missing}")
+
+print(">>> Local BERT files are ready.")
+PY
+
+# 下载完成后强制离线，避免训练过程访问外网重试
+export HF_HUB_OFFLINE=1
+export TRANSFORMERS_OFFLINE=1
+
+# echo "========================================"
+# echo "STEP 6: 最终验证 & 启动"
+# echo "========================================"
+
+# # 验证 NumPy 版本
+# $PYTHON -c "import numpy; print(f'>>> Current NumPy Version: {numpy.__version__}'); assert int(numpy.__version__.split('.')[0]) < 2"
+# # 验证 OpenCV
+# $PYTHON -c "import cv2; print(f'>>> Current OpenCV Version: {cv2.__version__}')"
+# # 验证 MMCV 版本
+# $PYTHON -c "import mmcv; print(f'>>> Current MMCV Version: {mmcv.__version__}')"
+
+# ================= 开始训练脚本 =================
+# ================= 配置区域 =================
+MMDET_DIR="${BASE_DIR}/mmdetection"
+CONFIG_FILE="${MMDET_DIR}/configs/mm_grounding_dino/grounding_dino_swin-t_finetune_traffic.py"
+WORK_DIR="${BASE_DIR}/work_dirs/mm_grounding_dino_traffic"
+GPUS=${1:-4}  # 默认使用 4 卡，可通过参数指定
+
+# ================= 环境检查 =================
+echo "========================================"
+echo "环境检查"
+echo "========================================"
+
+# 检查 Python 和依赖
+$PYTHON -c "import importlib.metadata as m; print(f'tqdm version: {m.version(\"tqdm\")}')"
+$PYTHON -c "import mmdet; print(f'MMDetection version: {mmdet.__version__}')"
+$PYTHON -c "import mmcv; print(f'MMCV version: {mmcv.__version__}')"
+$PYTHON -c "import torch; print(f'PyTorch version: {torch.__version__}')"
+$PYTHON -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}')"
+$PYTHON -c "import torch; print(f'CUDA device count: {torch.cuda.device_count()}')"
+$PYTHON -c "from transformers import AutoTokenizer; AutoTokenizer.from_pretrained('${LOCAL_BERT_DIR}', local_files_only=True); print('Local BERT tokenizer check: OK')"
+
+# ================= 开始训练 =================
+echo "========================================"
+echo "开始训练 MM-Grounding DINO"
+echo "配置文件: ${CONFIG_FILE}"
+echo "工作目录: ${WORK_DIR}"
+echo "GPU 数量: ${GPUS}"
+echo "========================================"
+
+cd "$MMDET_DIR"
+
+# 单卡训练
+if [ "$GPUS" -eq 1 ]; then
+    "$PYTHON" tools/train.py "${CONFIG_FILE}" \
+        --work-dir "${WORK_DIR}" \
+        --cfg-options lang_model_name="${LOCAL_BERT_DIR}" model.language_model.name="${LOCAL_BERT_DIR}"
+# 多卡分布式训练
+else
+    PYTHON="$PYTHON" bash tools/dist_train.sh "${CONFIG_FILE}" "${GPUS}" \
+        --work-dir "${WORK_DIR}" \
+        --cfg-options lang_model_name="${LOCAL_BERT_DIR}" model.language_model.name="${LOCAL_BERT_DIR}"
+fi
+
+echo "========================================"
+echo "训练完成!"
+echo "模型保存在: ${WORK_DIR}"
+echo "========================================"