SegAnyMo: herramienta de código abierto para segmentar automáticamente objetos arbitrarios en movimiento a partir de vídeo

Últimas herramientas de IAPublicado hace 4 meses Sharenet.ai

724 0

Introducción general

SegAnyMo es un proyecto de código abierto desarrollado por un equipo de investigadores de la UC Berkeley y la Universidad de Pekín, entre los que figuran miembros como Nan Huang. La herramienta se centra en el procesamiento de vídeo y puede identificar y segmentar automáticamente objetos arbitrarios en movimiento en un vídeo, como personas, animales o vehículos. Combina tecnologías como TAPNet, DINOv2 y SAM2, y tiene previsto presentar resultados en CVPR 2025. El código del proyecto es totalmente público y gratuito para que los usuarios lo descarguen, utilicen o modifiquen, y es adecuado para desarrolladores, investigadores y entusiastas del procesamiento de vídeo.El objetivo de SegAnyMo es simplificar el análisis de vídeo en movimiento y ofrecer soluciones eficientes de segmentación.

Lista de funciones

Detecta automáticamente objetos en movimiento en el vídeo y genera máscaras de segmentación precisas.
Admite formatos de vídeo (por ejemplo, MP4, AVI) o entrada de secuencias de imágenes.
Proporciona modelos preentrenados para facilitar una rápida implantación y realización de pruebas.
La integración con TAPNet genera trazas de seguimiento en 2D y captura información de movimiento.
Uso de DINOv2 para extraer características semánticas que mejoren la precisión de la segmentación.
Segmentación a nivel de píxel utilizando la máscara de refinamiento SAM2.
Admite la formación personalizada de conjuntos de datos para adaptarse a distintos escenarios.
Los resultados se visualizan para facilitar la comprobación y el ajuste.

Utilizar la ayuda

SegAnyMo requiere una cierta base técnica y está dirigido principalmente a usuarios con experiencia en programación. A continuación encontrará una guía detallada de instalación y uso.

Proceso de instalación

Preparar el hardware y el software
El proyecto se está desarrollando en Ubuntu 22.04, y se recomienda una tarjeta gráfica NVIDIA RTX A6000 o similar con CUDA. Requiere Git y Anaconda preinstalados.
- Clonar el repositorio de código:
```
git clone --recurse-submodules https://github.com/nnanhuang/SegAnyMo
```
- Vaya al catálogo de proyectos:
```
cd SegAnyMo
```
Creación de un entorno virtual
Cree un entorno Python separado con Anaconda para evitar conflictos de dependencias.
- Crear un entorno:
```
conda create -n seg python=3.12.4
```
- Activar el entorno:
```
conda activate seg
```

Instalación de dependencias básicas
Instala PyTorch y otras librerías necesarias.

Instala PyTorch (soporta CUDA 12.1):

conda install pytorch==2.4.0 torchvision==0.19.0 torchaudio==2.4.0 pytorch-cuda=12.1 -c pytorch -c nvidia

Instale otras dependencias:
```
pip install -r requirements.txt
```

Instalar xformers (razonamiento acelerado):

pip install -U xformers --index-url https://download.pytorch.org/whl/cu121

Instalación de DINOv2
Para la extracción de características se utiliza DINOv2.
- Vaya al catálogo de preprocesamiento y clone:
```
cd preproc && git clone https://github.com/facebookresearch/dinov2
```
Instalación de SAM2
SAM2 es el núcleo de refinamiento de máscaras.
- Ir al catálogo SAM2:
```
cd sam2
```
- Instalación:
```
pip install -e .
```
- Descargue el modelo preentrenado:
```
cd checkpoints && ./download_ckpts.sh && cd ../..
```

Instalación de TAPNet
TAPNet se utiliza para generar trazas de seguimiento en 2D.

Vaya al catálogo TAPNet:
```
cd preproc/tapnet
```
Instalación:
```
pip install .
```

Descarga el modelo:

cd ../checkpoints && wget https://storage.googleapis.com/dm-tapnet/bootstap/bootstapir_checkpoint_v2.pt

Verificar la instalación
Compruebe que el entorno es normal:

python -c "import torch; print(torch.cuda.is_available())"

exportaciones True Indica éxito.

Utilización

Preparación de datos

SegAnyMo admite la entrada de secuencias de vídeo o imágenes. Los datos deben organizarse en la siguiente estructura:

data
├── images
│   ├── scene_name
│   │   ├── image_name
│   │   ├── ...
├── bootstapir
│   ├── scene_name
│   │   ├── image_name
│   │   ├── ...
├── dinos
│   ├── scene_name
│   │   ├── image_name
│   │   ├── ...
├── depth_anything_v2
│   ├── scene_name
│   │   ├── image_name
│   │   ├── ...

Si la entrada es vídeo, utilice una herramienta (como FFmpeg) para extraer fotogramas al images Carpeta.
Si se trata de una secuencia de imágenes, colóquela directamente en el directorio correspondiente.

Pretratamiento operativo

Generar mapas de profundidad, características y trayectorias
Utilice los siguientes comandos para procesar los datos (unos 10 minutos, dependiendo de la cantidad de datos):
- Para secuencias de imágenes:
```
python core/utils/run_inference.py --data_dir $DATA_DIR --gpus 0 --depths --tracks --dinos --e
```
- Para el vídeo:
```
python core/utils/run_inference.py --video_path $VIDEO_PATH --gpus 0 --depths --tracks --dinos --e
```
Descripción de los parámetros:
- --e Activa el Modo Eficiente para reducir la frecuencia de imagen y la resolución y acelerar el procesamiento.
- --step 10 Indica que se utiliza 1 fotograma de cada 10 como fotograma de consulta, que puede ajustarse a la baja para mejorar la precisión.

Predicción de trayectorias de movimiento

Descargar modelos de pesos
a través de (un hueco) Cara de abrazo tal vez Google Drive Descargue el modelo preentrenado. Escriba la ruta al archivo configs/example_train.yaml (utilizado como expresión nominal) resume_path Campos.
- Predicción de la trayectoria de carrera:
```
python core/utils/run_inference.py --data_dir $DATA_DIR --motin_seg_dir $OUTPUT_DIR --config_file configs/example_train.yaml --gpus 0 --motion_seg_infer --e
```
La salida se guarda en el archivo $OUTPUT_DIR.

Generar máscara de segmentación

Utilización de la máscara de refinamiento SAM2
- Generación de máscaras de ejecución:
```
python core/utils/run_inference.py --data_dir $DATA_DIR --sam2dir $RESULT_DIR --motin_seg_dir $OUTPUT_DIR --gpus 0 --sam2 --e
```
Descripción de los parámetros:
- $DATA_DIR es la ruta de la imagen original.
- $RESULT_DIR es la ruta de guardado de la máscara.
- $OUTPUT_DIR es la trayectoria del resultado de la predicción de la trayectoria.
  Nota: SAM2 admite por defecto .jpg tal vez .jpeg el nombre del archivo debe ser un número. Si no es así, cambia el código o renombra el archivo.

Resultados de la evaluación

Descargar resultados precalculados
entidad transmitente Google Drive Descarga la máscara oficial para comparar.

Evaluación del conjunto de datos DAVIS:

CUDA_VISIBLE_DEVICES=0 python core/eval/eval_mask.py --res_dir $RES_DIR --eval_dir $GT_DIR --eval_seq_list core/utils/moving_val_sequences.txt

Evaluación refinada:

cd core/eval/davis2017-evaluation && CUDA_VISIBLE_DEVICES=0 python evaluation_method.py --task unsupervised --results_path $MASK_PATH

Formación a medida

Preprocesamiento de datos
Se utiliza como ejemplo el conjunto de datos HOI4D:

python core/utils/process_HOI.py
python core/utils/run_inference.py --data_dir $DATA_DIR --gpus 0 --tracks --depths --dinos

Las imágenes RGB y las máscaras dinámicas son necesarias para los conjuntos de datos personalizados.

Comprobar la integridad de los datos:

python current-data-dir/dynamic_stereo/dynamic_replica_data/check_process.py

La limpieza de datos ahorra espacio:

python core/utils/run_inference.py --data_dir $DATA_DIR --gpus 0 --clean

formación de modelos
modificaciones configs/$CONFIG.yaml entrenado con conjuntos de datos como Kubric, HOI4D, etc:

CUDA_VISIBLE_DEVICES=0 python train_seq.py ./configs/$CONFIG.yaml

escenario de aplicación

Postproducción de vídeo
Separe los objetos en movimiento (por ejemplo, personas corriendo) del vídeo, genere máscaras y utilícelas después para la composición de efectos.
Investigación sobre el análisis del comportamiento
Seguimiento de trayectorias de movimiento de animales o seres humanos y análisis de patrones de comportamiento.
Desarrollo de la conducción autónoma
Segmentación de objetos en movimiento (por ejemplo, vehículos, peatones) en vídeos de conducción para optimizar el sistema de percepción.
Optimización del sistema de vigilancia
Extraiga movimientos anómalos de los vídeos de vigilancia para mejorar la eficacia de la seguridad.

CONTROL DE CALIDAD

¿Necesita una GPU?
Sí, se recomienda que las tarjetas NVIDIA soporten CUDA, de lo contrario funcionan de forma ineficiente.
¿Admite el procesamiento en tiempo real?
La versión actual es adecuada para el procesamiento fuera de línea, las aplicaciones en tiempo real deben optimizarse por sí solas.
¿Cuánto espacio necesita para la formación?
Dependiendo del conjunto de datos, un conjunto de datos pequeño es de unos pocos gigabytes y un conjunto de datos grande puede ser de cientos de gigabytes.
¿Cómo mejorar la precisión de la segmentación?
disminuir --step o entrenar el modelo con más datos etiquetados.