-
-## About ClearML
-
-[ClearML](https://cutt.ly/yolov5-tutorial-clearml) is an [open-source](https://github.com/allegroai/clearml) toolbox designed to save you time ⏱️.
-
-🔨 Track every YOLOv5 training run in the experiment manager
-
-🔧 Version and easily access your custom training data with the integrated ClearML Data Versioning Tool
-
-🔦 Remotely train and monitor your YOLOv5 training runs using ClearML Agent
-
-🔬 Get the very best mAP using ClearML Hyperparameter Optimization
-
-🔭 Turn your newly trained YOLOv5 model into an API with just a few commands using ClearML Serving
-
--And so much more. It's up to you how many of these tools you want to use, you can stick to the experiment manager, or chain them all together into an impressive pipeline! -
-
- - - - -
-
- -## 🦾 Setting Things Up - -To keep track of your experiments and/or data, ClearML needs to communicate to a server. You have 2 options to get one: - -Either sign up for free to the [ClearML Hosted Service](https://cutt.ly/yolov5-tutorial-clearml) or you can set up your own server, see [here](https://clear.ml/docs/latest/docs/deploying_clearml/clearml_server). Even the server is open-source, so even if you're dealing with sensitive data, you should be good to go! - -1. Install the `clearml` python package: - - ```bash - pip install clearml - ``` - -1. Connect the ClearML SDK to the server by [creating credentials](https://app.clear.ml/settings/workspace-configuration) (go right top to Settings -> Workspace -> Create new credentials), then execute the command below and follow the instructions: - - ```bash - clearml-init - ``` - -That's it! You're done 😎 - -
- -## 🚀 Training YOLOv5 With ClearML - -To enable ClearML experiment tracking, simply install the ClearML pip package. - -```bash -pip install clearml>=1.2.0 -``` - -This will enable integration with the YOLOv5 training script. Every training run from now on, will be captured and stored by the ClearML experiment manager. - -If you want to change the `project_name` or `task_name`, use the `--project` and `--name` arguments of the `train.py` script, by default the project will be called `YOLOv5` and the task `Training`. -PLEASE NOTE: ClearML uses `/` as a delimter for subprojects, so be careful when using `/` in your project name! - -```bash -python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt --cache -``` - -or with custom project and task name: -```bash -python train.py --project my_project --name my_training --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt --cache -``` - -This will capture: -- Source code + uncommitted changes -- Installed packages -- (Hyper)parameters -- Model files (use `--save-period n` to save a checkpoint every n epochs) -- Console output -- Scalars (mAP_0.5, mAP_0.5:0.95, precision, recall, losses, learning rates, ...) -- General info such as machine details, runtime, creation date etc. -- All produced plots such as label correlogram and confusion matrix -- Images with bounding boxes per epoch -- Mosaic per epoch -- Validation images per epoch -- ... - -That's a lot right? 🤯 -Now, we can visualize all of this information in the ClearML UI to get an overview of our training progress. Add custom columns to the table view (such as e.g. mAP_0.5) so you can easily sort on the best performing model. Or select multiple experiments and directly compare them! - -There even more we can do with all of this information, like hyperparameter optimization and remote execution, so keep reading if you want to see how that works! - -
- -## 🔗 Dataset Version Management - -Versioning your data separately from your code is generally a good idea and makes it easy to aqcuire the latest version too. This repository supports supplying a dataset version ID and it will make sure to get the data if it's not there yet. Next to that, this workflow also saves the used dataset ID as part of the task parameters, so you will always know for sure which data was used in which experiment! - - - -### Prepare Your Dataset - -The YOLOv5 repository supports a number of different datasets by using yaml files containing their information. By default datasets are downloaded to the `../datasets` folder in relation to the repository root folder. So if you downloaded the `coco128` dataset using the link in the yaml or with the scripts provided by yolov5, you get this folder structure: - -``` -.. -|_ yolov5 -|_ datasets - |_ coco128 - |_ images - |_ labels - |_ LICENSE - |_ README.txt -``` -But this can be any dataset you wish. Feel free to use your own, as long as you keep to this folder structure. - -Next, ⚠️**copy the corresponding yaml file to the root of the dataset folder**⚠️. This yaml files contains the information ClearML will need to properly use the dataset. You can make this yourself too, of course, just follow the structure of the example yamls. - -Basically we need the following keys: `path`, `train`, `test`, `val`, `nc`, `names`. - -``` -.. -|_ yolov5 -|_ datasets - |_ coco128 - |_ images - |_ labels - |_ coco128.yaml # <---- HERE! - |_ LICENSE - |_ README.txt -``` - -### Upload Your Dataset - -To get this dataset into ClearML as a versionned dataset, go to the dataset root folder and run the following command: -```bash -cd coco128 -clearml-data sync --project YOLOv5 --name coco128 --folder . -``` - -The command `clearml-data sync` is actually a shorthand command. You could also run these commands one after the other: -```bash -# Optionally add --parent
- -## 👀 Hyperparameter Optimization - -Now that we have our experiments and data versioned, it's time to take a look at what we can build on top! - -Using the code information, installed packages and environment details, the experiment itself is now **completely reproducible**. In fact, ClearML allows you to clone an experiment and even change its parameters. We can then just rerun it with these new parameters automatically, this is basically what HPO does! - -To **run hyperparameter optimization locally**, we've included a pre-made script for you. Just make sure a training task has been run at least once, so it is in the ClearML experiment manager, we will essentially clone it and change its hyperparameters. - -You'll need to fill in the ID of this `template task` in the script found at `utils/loggers/clearml/hpo.py` and then just run it :) You can change `task.execute_locally()` to `task.execute()` to put it in a ClearML queue and have a remote agent work on it instead. - -```bash -# To use optuna, install it first, otherwise you can change the optimizer to just be RandomSearch -pip install optuna -python utils/loggers/clearml/hpo.py -``` - - - -## 🤯 Remote Execution (advanced) - -Running HPO locally is really handy, but what if we want to run our experiments on a remote machine instead? Maybe you have access to a very powerful GPU machine on-site or you have some budget to use cloud GPUs. -This is where the ClearML Agent comes into play. Check out what the agent can do here: - -- [YouTube video](https://youtu.be/MX3BrXnaULs) -- [Documentation](https://clear.ml/docs/latest/docs/clearml_agent) - -In short: every experiment tracked by the experiment manager contains enough information to reproduce it on a different machine (installed packages, uncommitted changes etc.). So a ClearML agent does just that: it listens to a queue for incoming tasks and when it finds one, it recreates the environment and runs it while still reporting scalars, plots etc. to the experiment manager. - -You can turn any machine (a cloud VM, a local GPU machine, your own laptop ... ) into a ClearML agent by simply running: -```bash -clearml-agent daemon --queue
-
Edad de Hielo AR: Una aplicación genial para dar vida al mundo prehistórico
-¿Alguna vez te has preguntado cómo sería ver un mamut lanudo, un tigre de dientes de sable, o un oso de cara corta en la vida real? Bueno, ahora puedes, gracias a Ice Age AR, una aplicación gratuita de realidad aumentada que te permite dar vida a tus personajes favoritos de Ice Age: Collision Course. En este artículo, te contaremos todo lo que necesitas saber sobre esta increíble aplicación, cómo usarla y por qué deberías probarla.
-descarga de la edad de hielo
Download ->>->>->> https://bltlly.com/2v6Ma0
-
¿Qué es la edad de hielo AR?
-Ice Age AR es una aplicación que utiliza la tecnología de realidad aumentada para crear modelos 3D realistas de los animales de la Edad de Hielo en la pantalla de tu smartphone o tablet. La realidad aumentada (RA) es una tecnología que superpone imágenes digitales sobre el mundo real, creando una experiencia inmersiva e interactiva. Puede utilizar la cámara de su dispositivo para escanear marcadores especiales que desencadenan las secuencias de AR, y luego ver como los animales aparecen delante de usted. También puedes interactuar con ellos, pasearlos, tomar fotos y compartirlas con tus amigos.
-Las características de la aplicación
-Ice Age AR ofrece nueve experiencias diferentes de realidad aumentada, incluyendo:
--
-
- Conoce a Manny, Sid y Diego en AMAZING LIFE SIZE MODE. Puedes ver lo grandes que eran estos animales y compararlos contigo mismo. -
- Tome uno de sus héroes sub-cero para un paseo! Hacer rugir Diego o ver torpe Sid pose. Puedes controlar sus movimientos y expresiones con gestos simples. -
- Libera dos personajes a la vez en el modo interactivo DOS JUGADORES. Juega con un amigo y cada uno puede controlar un personaje en una escena interactiva. -
- Toma el control de Scrat en el ESPACIO. Ayúdalo a encontrar su bellota y volar su nave espacial evitando asteroides. -
Los requisitos de la aplicación
-Esta aplicación está disponible para dispositivos Android e iOS, pero solo funciona en combinación con el libro "Ice Age: Collision Course - Bring the herd to life". El libro contiene los marcadores de realidad aumentada que activan la aplicación. Puede comprar el libro en línea o en su librería local. Alternativamente, puede descargar una página de prueba desde la propia aplicación.
- -Para usar la aplicación, necesita un teléfono inteligente o tableta compatible con una cámara orientada hacia atrás y una conexión a Internet. La aplicación es gratuita para descargar y usar, pero puede contener anuncios y compras en la aplicación.
-Los comentarios de la aplicación
-Ice Age AR ha recibido críticas positivas de usuarios que lo han probado. Estos son algunos de sus comentarios:
-"Esta aplicación es genial!!!!! Me encanta cómo se puede tomar una foto, pero no se puede ver el rebaño en la vida real, pero yo estaba un poco esperando que, pero es una buena aplicación lo recomiendo" - Thomas Y amigos Historias-
"Me encantó, funcionó perfectamente, lástima que no poseo el libro." - Jake MF-
"¡Prepárate para una increíble experiencia de Realidad Aumentada de la Era de Hielo! Descarga esta aplicación de realidad aumentada GRATIS para dar vida a tus personajes favoritos de Ice Age: Collision Course." - App Store descripción-
¿Cómo usar la Edad de Hielo AR?
-Usar Ice Age AR es muy fácil y divertido. Solo sigue estos sencillos pasos:
-Descargar e instalar la aplicación Descargar e instalar la aplicación
-
Lo primero que tienes que hacer es descargar e instalar la aplicación Ice Age AR en tu dispositivo. Puedes encontrarlo en Google Play Store o en App Store, dependiendo de tu dispositivo. Solo busca "Ice Age AR" y busca el icono de la aplicación que muestra Scrat sosteniendo una bellota. Toca el botón de instalación y espera a que la aplicación se descargue e instale.
-Encuentra los marcadores AR
- -Iniciar la aplicación y escanear los marcadores
-Una vez que tenga la aplicación y los marcadores de RA listos, puede iniciar la aplicación y comenzar a escanear los marcadores. Para ello, es necesario abrir la aplicación y toque en el "Escanear" botón. Luego, debes apuntar la cámara de tu dispositivo a uno de los marcadores de RA y esperar unos segundos. La aplicación detectará automáticamente el marcador y lanzará la secuencia AR correspondiente. Verá una pantalla de carga con algunas instrucciones y consejos, y luego verá que el animal aparece en su pantalla.
-Interactuar con los caracteres
-Después de ver el animal en tu pantalla, puedes interactuar con él de diferentes maneras. Puedes usar tus dedos para tocar, deslizar, pellizcar o girar la pantalla para cambiar el ángulo, el tamaño o la posición del animal. También puede usar comandos de voz o gestos para hacer que el animal se mueva o haga sonidos. Por ejemplo, puedes decir "Rugir" para hacer rugir a Diego, o "Saltar" para hacer saltar a Sid. También puedes tocar diferentes partes del cuerpo del animal para ver lo que sucede.
-Toma fotos y compártelas
-Una de las mejores características de Ice Age AR es que puedes tomar fotos de ti mismo con los animales y compartirlas con tus amigos. Para hacer esto, debe tocar el icono de la cámara en la esquina inferior derecha de la pantalla. Esto abrirá un modo selfie donde puedes verte a ti mismo y al animal en la misma pantalla. Puede ajustar su posición y posar como desee, y luego toque en el botón de obturación para tomar una foto. La foto se guardará en la galería de tu dispositivo, y también puedes compartirla directamente desde la aplicación por correo electrónico, redes sociales o aplicaciones de mensajería.
-¿Por qué usar Ice Age AR?
-Ice Age AR no es solo una aplicación divertida y entretenida, sino también educativa y creativa. Estas son algunas de las razones por las que deberías usarla:
-Aprende sobre los animales de la Edad de Hielo
- -Diviértete con tus amigos y familiares
-Ice Age AR también es una gran manera de divertirse con sus amigos y familiares. Pueden jugar juntos en el modo de dos jugadores, donde cada uno puede controlar un personaje en una escena interactiva. También puedes tomar fotos junto con tus personajes favoritos y compartirlas en línea. Incluso puedes crear tus propias historias o escenarios usando Ice Age AR como una herramienta para la imaginación y la creatividad.
-Experimenta la realidad aumentada
-Ice Age AR también es una gran manera de experimentar la tecnología de realidad aumentada, que se está volviendo más popular y accesible en los últimos años. La realidad aumentada es una tecnología que mejora su percepción de la realidad mediante la adición de elementos digitales a la misma. Puede crear efectos increíbles que te hacen sentir como si estuvieras en otro mundo o tiempo. También puede ofrecer nuevas posibilidades de aprendizaje, entretenimiento, comunicación y arte.
-Conclusión
-Ice Age AR es una aplicación genial que da vida al mundo prehistórico usando tecnología de realidad aumentada. Te permite interactuar con modelos 3D realistas de animales de la Edad de Hielo en la pantalla de tu smartphone o tablet. También puedes aprender sobre ellos, divertirte con ellos, tomar fotos con ellos y compartirlas con tus amigos. Todo lo que necesitas es un dispositivo compatible, un dispositivo compatible, la aplicación y el libro con los marcadores AR. También puede descargar una página de prueba de la propia aplicación para probarlo. Si eres un fanático de la Edad de Hielo o simplemente tienes curiosidad por el mundo prehistórico, definitivamente deberías probar Ice Age AR. Es una app genial que te hará sentir como si estuvieras en otra época.
-Preguntas frecuentes
-Aquí están algunas de las preguntas más frecuentes sobre la Edad de Hielo AR:
-Q: ¿Es segura la RA de la edad de hielo para los niños?
- -Q: ¿Cómo puedo obtener más marcadores AR?
-A: La única manera de conseguir más marcadores de AR es comprar el libro "Ice Age: Collision Course - Bring the herd to life". El libro tiene 32 páginas, cada una con un marcador RA diferente. Puede comprar el libro en línea o en su librería local. Alternativamente, puede descargar una página de prueba de la propia aplicación, que cuenta con Manny, Sid y Diego.
-Q: ¿Cómo puedo cambiar entre diferentes idiomas?
-A: Ice Age AR admite dos idiomas: inglés y francés. Puede cambiar entre ellos pulsando en el icono de configuración en la esquina superior izquierda de la pantalla. A continuación, puede seleccionar su idioma preferido en el menú desplegable.
-Q: ¿Cómo puedo quitar anuncios o desbloquear funciones premium?
-A: Ice Age AR es gratis de descargar y usar, pero puede contener anuncios y compras en la aplicación. Puede eliminar anuncios o desbloquear funciones premium tocando el icono de la tienda en la esquina superior derecha de la pantalla. Luego, puede elegir entre diferentes opciones, como eliminar anuncios por $0.99 o desbloquear todos los caracteres por $4.99.
-Q: ¿Cómo puedo contactar a los desarrolladores o reportar un problema?
-A: Si tienes alguna pregunta, comentario, o problemas con Ice Age AR, puedes contactar a los desarrolladores tocando el icono de información en la esquina superior izquierda de la pantalla. Luego, puede seleccionar "Contáctenos" o "Reportar un problema" en el menú. También puede visitar su sitio web en www.iceagear.com o seguirlos en Facebook o Twitter.
64aa2da5cf-
-
\ No newline at end of file diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/cachecontrol/caches/__init__.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/cachecontrol/caches/__init__.py deleted file mode 100644 index 37827291fb5a76d7ef9a7a3a695710b2074ca09a..0000000000000000000000000000000000000000 --- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/cachecontrol/caches/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -# SPDX-FileCopyrightText: 2015 Eric Larson -# -# SPDX-License-Identifier: Apache-2.0 - -from .file_cache import FileCache, SeparateBodyFileCache -from .redis_cache import RedisCache - - -__all__ = ["FileCache", "SeparateBodyFileCache", "RedisCache"] diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/utils.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/utils.py deleted file mode 100644 index bab11b80c60f10a4f3bccb12eb5b17c48a449767..0000000000000000000000000000000000000000 --- a/spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/_vendor/packaging/utils.py +++ /dev/null @@ -1,136 +0,0 @@ -# This file is dual licensed under the terms of the Apache License, Version -# 2.0, and the BSD License. See the LICENSE file in the root of this repository -# for complete details. - -import re -from typing import FrozenSet, NewType, Tuple, Union, cast - -from .tags import Tag, parse_tag -from .version import InvalidVersion, Version - -BuildTag = Union[Tuple[()], Tuple[int, str]] -NormalizedName = NewType("NormalizedName", str) - - -class InvalidWheelFilename(ValueError): - """ - An invalid wheel filename was found, users should refer to PEP 427. - """ - - -class InvalidSdistFilename(ValueError): - """ - An invalid sdist filename was found, users should refer to the packaging user guide. - """ - - -_canonicalize_regex = re.compile(r"[-_.]+") -# PEP 427: The build number must start with a digit. -_build_tag_regex = re.compile(r"(\d+)(.*)") - - -def canonicalize_name(name: str) -> NormalizedName: - # This is taken from PEP 503. - value = _canonicalize_regex.sub("-", name).lower() - return cast(NormalizedName, value) - - -def canonicalize_version(version: Union[Version, str]) -> str: - """ - This is very similar to Version.__str__, but has one subtle difference - with the way it handles the release segment. - """ - if isinstance(version, str): - try: - parsed = Version(version) - except InvalidVersion: - # Legacy versions cannot be normalized - return version - else: - parsed = version - - parts = [] - - # Epoch - if parsed.epoch != 0: - parts.append(f"{parsed.epoch}!") - - # Release segment - # NB: This strips trailing '.0's to normalize - parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in parsed.release))) - - # Pre-release - if parsed.pre is not None: - parts.append("".join(str(x) for x in parsed.pre)) - - # Post-release - if parsed.post is not None: - parts.append(f".post{parsed.post}") - - # Development release - if parsed.dev is not None: - parts.append(f".dev{parsed.dev}") - - # Local version segment - if parsed.local is not None: - parts.append(f"+{parsed.local}") - - return "".join(parts) - - -def parse_wheel_filename( - filename: str, -) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]: - if not filename.endswith(".whl"): - raise InvalidWheelFilename( - f"Invalid wheel filename (extension must be '.whl'): {filename}" - ) - - filename = filename[:-4] - dashes = filename.count("-") - if dashes not in (4, 5): - raise InvalidWheelFilename( - f"Invalid wheel filename (wrong number of parts): {filename}" - ) - - parts = filename.split("-", dashes - 2) - name_part = parts[0] - # See PEP 427 for the rules on escaping the project name - if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None: - raise InvalidWheelFilename(f"Invalid project name: {filename}") - name = canonicalize_name(name_part) - version = Version(parts[1]) - if dashes == 5: - build_part = parts[2] - build_match = _build_tag_regex.match(build_part) - if build_match is None: - raise InvalidWheelFilename( - f"Invalid build number: {build_part} in '{filename}'" - ) - build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2))) - else: - build = () - tags = parse_tag(parts[-1]) - return (name, version, build, tags) - - -def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]: - if filename.endswith(".tar.gz"): - file_stem = filename[: -len(".tar.gz")] - elif filename.endswith(".zip"): - file_stem = filename[: -len(".zip")] - else: - raise InvalidSdistFilename( - f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):" - f" {filename}" - ) - - # We are requiring a PEP 440 version, which cannot contain dashes, - # so we split on the last dash. - name_part, sep, version_part = file_stem.rpartition("-") - if not sep: - raise InvalidSdistFilename(f"Invalid sdist filename: {filename}") - - name = canonicalize_name(name_part) - version = Version(version_part) - return (name, version) diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/detection_utils.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/detection_utils.py deleted file mode 100644 index 0371e5fada00fb5485b92638837802485c57977d..0000000000000000000000000000000000000000 --- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/detection_utils.py +++ /dev/null @@ -1,465 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved - -""" -Common data processing utilities that are used in a -typical object detection data pipeline. -""" -import logging -import numpy as np -import pycocotools.mask as mask_util -import torch -from fvcore.common.file_io import PathManager -from PIL import Image, ImageOps - -from detectron2.structures import ( - BitMasks, - Boxes, - BoxMode, - Instances, - Keypoints, - PolygonMasks, - RotatedBoxes, - polygons_to_bitmask, -) - -from . import transforms as T -from .catalog import MetadataCatalog - - -class SizeMismatchError(ValueError): - """ - When loaded image has difference width/height compared with annotation. - """ - - -def read_image(file_name, format=None): - """ - Read an image into the given format. - Will apply rotation and flipping if the image has such exif information. - - Args: - file_name (str): image file path - format (str): one of the supported image modes in PIL, or "BGR" - - Returns: - image (np.ndarray): an HWC image in the given format. - """ - with PathManager.open(file_name, "rb") as f: - image = Image.open(f) - - # capture and ignore this bug: https://github.com/python-pillow/Pillow/issues/3973 - try: - image = ImageOps.exif_transpose(image) - except Exception: - pass - - if format is not None: - # PIL only supports RGB, so convert to RGB and flip channels over below - conversion_format = format - if format == "BGR": - conversion_format = "RGB" - image = image.convert(conversion_format) - image = np.asarray(image) - if format == "BGR": - # flip channels if needed - image = image[:, :, ::-1] - # PIL squeezes out the channel dimension for "L", so make it HWC - if format == "L": - image = np.expand_dims(image, -1) - return image - - -def check_image_size(dataset_dict, image): - """ - Raise an error if the image does not match the size specified in the dict. - """ - if "width" in dataset_dict or "height" in dataset_dict: - image_wh = (image.shape[1], image.shape[0]) - expected_wh = (dataset_dict["width"], dataset_dict["height"]) - if not image_wh == expected_wh: - raise SizeMismatchError( - "Mismatched (W,H){}, got {}, expect {}".format( - " for image " + dataset_dict["file_name"] - if "file_name" in dataset_dict - else "", - image_wh, - expected_wh, - ) - ) - - # To ensure bbox always remap to original image size - if "width" not in dataset_dict: - dataset_dict["width"] = image.shape[1] - if "height" not in dataset_dict: - dataset_dict["height"] = image.shape[0] - - -def transform_proposals(dataset_dict, image_shape, transforms, min_box_side_len, proposal_topk): - """ - Apply transformations to the proposals in dataset_dict, if any. - - Args: - dataset_dict (dict): a dict read from the dataset, possibly - contains fields "proposal_boxes", "proposal_objectness_logits", "proposal_bbox_mode" - image_shape (tuple): height, width - transforms (TransformList): - min_box_side_len (int): keep proposals with at least this size - proposal_topk (int): only keep top-K scoring proposals - - The input dict is modified in-place, with abovementioned keys removed. A new - key "proposals" will be added. Its value is an `Instances` - object which contains the transformed proposals in its field - "proposal_boxes" and "objectness_logits". - """ - if "proposal_boxes" in dataset_dict: - # Transform proposal boxes - boxes = transforms.apply_box( - BoxMode.convert( - dataset_dict.pop("proposal_boxes"), - dataset_dict.pop("proposal_bbox_mode"), - BoxMode.XYXY_ABS, - ) - ) - boxes = Boxes(boxes) - objectness_logits = torch.as_tensor( - dataset_dict.pop("proposal_objectness_logits").astype("float32") - ) - - boxes.clip(image_shape) - keep = boxes.nonempty(threshold=min_box_side_len) - boxes = boxes[keep] - objectness_logits = objectness_logits[keep] - - proposals = Instances(image_shape) - proposals.proposal_boxes = boxes[:proposal_topk] - proposals.objectness_logits = objectness_logits[:proposal_topk] - dataset_dict["proposals"] = proposals - - -def transform_instance_annotations( - annotation, transforms, image_size, *, keypoint_hflip_indices=None -): - """ - Apply transforms to box, segmentation and keypoints annotations of a single instance. - - It will use `transforms.apply_box` for the box, and - `transforms.apply_coords` for segmentation polygons & keypoints. - If you need anything more specially designed for each data structure, - you'll need to implement your own version of this function or the transforms. - - Args: - annotation (dict): dict of instance annotations for a single instance. - It will be modified in-place. - transforms (TransformList): - image_size (tuple): the height, width of the transformed image - keypoint_hflip_indices (ndarray[int]): see `create_keypoint_hflip_indices`. - - Returns: - dict: - the same input dict with fields "bbox", "segmentation", "keypoints" - transformed according to `transforms`. - The "bbox_mode" field will be set to XYXY_ABS. - """ - bbox = BoxMode.convert(annotation["bbox"], annotation["bbox_mode"], BoxMode.XYXY_ABS) - # Note that bbox is 1d (per-instance bounding box) - annotation["bbox"] = transforms.apply_box([bbox])[0] - annotation["bbox_mode"] = BoxMode.XYXY_ABS - - if "segmentation" in annotation: - # each instance contains 1 or more polygons - segm = annotation["segmentation"] - if isinstance(segm, list): - # polygons - polygons = [np.asarray(p).reshape(-1, 2) for p in segm] - annotation["segmentation"] = [ - p.reshape(-1) for p in transforms.apply_polygons(polygons) - ] - elif isinstance(segm, dict): - # RLE - mask = mask_util.decode(segm) - mask = transforms.apply_segmentation(mask) - assert tuple(mask.shape[:2]) == image_size - annotation["segmentation"] = mask - else: - raise ValueError( - "Cannot transform segmentation of type '{}'!" - "Supported types are: polygons as list[list[float] or ndarray]," - " COCO-style RLE as a dict.".format(type(segm)) - ) - - if "keypoints" in annotation: - keypoints = transform_keypoint_annotations( - annotation["keypoints"], transforms, image_size, keypoint_hflip_indices - ) - annotation["keypoints"] = keypoints - - return annotation - - -def transform_keypoint_annotations(keypoints, transforms, image_size, keypoint_hflip_indices=None): - """ - Transform keypoint annotations of an image. - - Args: - keypoints (list[float]): Nx3 float in Detectron2 Dataset format. - transforms (TransformList): - image_size (tuple): the height, width of the transformed image - keypoint_hflip_indices (ndarray[int]): see `create_keypoint_hflip_indices`. - """ - # (N*3,) -> (N, 3) - keypoints = np.asarray(keypoints, dtype="float64").reshape(-1, 3) - keypoints[:, :2] = transforms.apply_coords(keypoints[:, :2]) - - # This assumes that HorizFlipTransform is the only one that does flip - do_hflip = sum(isinstance(t, T.HFlipTransform) for t in transforms.transforms) % 2 == 1 - - # Alternative way: check if probe points was horizontally flipped. - # probe = np.asarray([[0.0, 0.0], [image_width, 0.0]]) - # probe_aug = transforms.apply_coords(probe.copy()) - # do_hflip = np.sign(probe[1][0] - probe[0][0]) != np.sign(probe_aug[1][0] - probe_aug[0][0]) # noqa - - # If flipped, swap each keypoint with its opposite-handed equivalent - if do_hflip: - assert keypoint_hflip_indices is not None - keypoints = keypoints[keypoint_hflip_indices, :] - - # Maintain COCO convention that if visibility == 0, then x, y = 0 - # TODO may need to reset visibility for cropped keypoints, - # but it does not matter for our existing algorithms - keypoints[keypoints[:, 2] == 0] = 0 - return keypoints - - -def annotations_to_instances(annos, image_size, mask_format="polygon"): - """ - Create an :class:`Instances` object used by the models, - from instance annotations in the dataset dict. - - Args: - annos (list[dict]): a list of instance annotations in one image, each - element for one instance. - image_size (tuple): height, width - - Returns: - Instances: - It will contain fields "gt_boxes", "gt_classes", - "gt_masks", "gt_keypoints", if they can be obtained from `annos`. - This is the format that builtin models expect. - """ - boxes = [BoxMode.convert(obj["bbox"], obj["bbox_mode"], BoxMode.XYXY_ABS) for obj in annos] - target = Instances(image_size) - boxes = target.gt_boxes = Boxes(boxes) - boxes.clip(image_size) - - classes = [obj["category_id"] for obj in annos] - classes = torch.tensor(classes, dtype=torch.int64) - target.gt_classes = classes - - if len(annos) and "segmentation" in annos[0]: - segms = [obj["segmentation"] for obj in annos] - if mask_format == "polygon": - masks = PolygonMasks(segms) - else: - assert mask_format == "bitmask", mask_format - masks = [] - for segm in segms: - if isinstance(segm, list): - # polygon - masks.append(polygons_to_bitmask(segm, *image_size)) - elif isinstance(segm, dict): - # COCO RLE - masks.append(mask_util.decode(segm)) - elif isinstance(segm, np.ndarray): - assert segm.ndim == 2, "Expect segmentation of 2 dimensions, got {}.".format( - segm.ndim - ) - # mask array - masks.append(segm) - else: - raise ValueError( - "Cannot convert segmentation of type '{}' to BitMasks!" - "Supported types are: polygons as list[list[float] or ndarray]," - " COCO-style RLE as a dict, or a full-image segmentation mask " - "as a 2D ndarray.".format(type(segm)) - ) - # torch.from_numpy does not support array with negative stride. - masks = BitMasks( - torch.stack([torch.from_numpy(np.ascontiguousarray(x)) for x in masks]) - ) - target.gt_masks = masks - - if len(annos) and "keypoints" in annos[0]: - kpts = [obj.get("keypoints", []) for obj in annos] - target.gt_keypoints = Keypoints(kpts) - - return target - - -def annotations_to_instances_rotated(annos, image_size): - """ - Create an :class:`Instances` object used by the models, - from instance annotations in the dataset dict. - Compared to `annotations_to_instances`, this function is for rotated boxes only - - Args: - annos (list[dict]): a list of instance annotations in one image, each - element for one instance. - image_size (tuple): height, width - - Returns: - Instances: - Containing fields "gt_boxes", "gt_classes", - if they can be obtained from `annos`. - This is the format that builtin models expect. - """ - boxes = [obj["bbox"] for obj in annos] - target = Instances(image_size) - boxes = target.gt_boxes = RotatedBoxes(boxes) - boxes.clip(image_size) - - classes = [obj["category_id"] for obj in annos] - classes = torch.tensor(classes, dtype=torch.int64) - target.gt_classes = classes - - return target - - -def filter_empty_instances(instances, by_box=True, by_mask=True): - """ - Filter out empty instances in an `Instances` object. - - Args: - instances (Instances): - by_box (bool): whether to filter out instances with empty boxes - by_mask (bool): whether to filter out instances with empty masks - - Returns: - Instances: the filtered instances. - """ - assert by_box or by_mask - r = [] - if by_box: - r.append(instances.gt_boxes.nonempty()) - if instances.has("gt_masks") and by_mask: - r.append(instances.gt_masks.nonempty()) - - # TODO: can also filter visible keypoints - - if not r: - return instances - m = r[0] - for x in r[1:]: - m = m & x - return instances[m] - - -def create_keypoint_hflip_indices(dataset_names): - """ - Args: - dataset_names (list[str]): list of dataset names - Returns: - ndarray[int]: a vector of size=#keypoints, storing the - horizontally-flipped keypoint indices. - """ - - check_metadata_consistency("keypoint_names", dataset_names) - check_metadata_consistency("keypoint_flip_map", dataset_names) - - meta = MetadataCatalog.get(dataset_names[0]) - names = meta.keypoint_names - # TODO flip -> hflip - flip_map = dict(meta.keypoint_flip_map) - flip_map.update({v: k for k, v in flip_map.items()}) - flipped_names = [i if i not in flip_map else flip_map[i] for i in names] - flip_indices = [names.index(i) for i in flipped_names] - return np.asarray(flip_indices) - - -def gen_crop_transform_with_instance(crop_size, image_size, instance): - """ - Generate a CropTransform so that the cropping region contains - the center of the given instance. - - Args: - crop_size (tuple): h, w in pixels - image_size (tuple): h, w - instance (dict): an annotation dict of one instance, in Detectron2's - dataset format. - """ - crop_size = np.asarray(crop_size, dtype=np.int32) - bbox = BoxMode.convert(instance["bbox"], instance["bbox_mode"], BoxMode.XYXY_ABS) - center_yx = (bbox[1] + bbox[3]) * 0.5, (bbox[0] + bbox[2]) * 0.5 - assert ( - image_size[0] >= center_yx[0] and image_size[1] >= center_yx[1] - ), "The annotation bounding box is outside of the image!" - assert ( - image_size[0] >= crop_size[0] and image_size[1] >= crop_size[1] - ), "Crop size is larger than image size!" - - min_yx = np.maximum(np.floor(center_yx).astype(np.int32) - crop_size, 0) - max_yx = np.maximum(np.asarray(image_size, dtype=np.int32) - crop_size, 0) - max_yx = np.minimum(max_yx, np.ceil(center_yx).astype(np.int32)) - - y0 = np.random.randint(min_yx[0], max_yx[0] + 1) - x0 = np.random.randint(min_yx[1], max_yx[1] + 1) - return T.CropTransform(x0, y0, crop_size[1], crop_size[0]) - - -def check_metadata_consistency(key, dataset_names): - """ - Check that the datasets have consistent metadata. - - Args: - key (str): a metadata key - dataset_names (list[str]): a list of dataset names - - Raises: - AttributeError: if the key does not exist in the metadata - ValueError: if the given datasets do not have the same metadata values defined by key - """ - if len(dataset_names) == 0: - return - logger = logging.getLogger(__name__) - entries_per_dataset = [getattr(MetadataCatalog.get(d), key) for d in dataset_names] - for idx, entry in enumerate(entries_per_dataset): - if entry != entries_per_dataset[0]: - logger.error( - "Metadata '{}' for dataset '{}' is '{}'".format(key, dataset_names[idx], str(entry)) - ) - logger.error( - "Metadata '{}' for dataset '{}' is '{}'".format( - key, dataset_names[0], str(entries_per_dataset[0]) - ) - ) - raise ValueError("Datasets have different metadata '{}'!".format(key)) - - -def build_transform_gen(cfg, is_train): - """ - Create a list of :class:`TransformGen` from config. - Now it includes resizing and flipping. - - Returns: - list[TransformGen] - """ - if is_train: - min_size = cfg.INPUT.MIN_SIZE_TRAIN - max_size = cfg.INPUT.MAX_SIZE_TRAIN - sample_style = cfg.INPUT.MIN_SIZE_TRAIN_SAMPLING - else: - min_size = cfg.INPUT.MIN_SIZE_TEST - max_size = cfg.INPUT.MAX_SIZE_TEST - sample_style = "choice" - if sample_style == "range": - assert len(min_size) == 2, "more than 2 ({}) min_size(s) are provided for ranges".format( - len(min_size) - ) - - logger = logging.getLogger(__name__) - tfm_gens = [] - tfm_gens.append(T.ResizeShortestEdge(min_size, max_size, sample_style)) - if is_train: - tfm_gens.append(T.RandomFlip()) - logger.info("TransformGens used in training: " + str(tfm_gens)) - return tfm_gens diff --git a/spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/Dockerfile b/spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/Dockerfile deleted file mode 100644 index 13befb65d79c5c33a038dfa31f87c10b05896999..0000000000000000000000000000000000000000 --- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/Dockerfile +++ /dev/null @@ -1,45 +0,0 @@ -FROM nvidia/cuda:10.0-cudnn7-devel-ubuntu16.04 -# install anaconda 5.2.0 -ENV LANG=C.UTF-8 LC_ALL=C.UTF-8 -ENV PATH /opt/conda/bin:$PATH - -RUN apt-get update --fix-missing && apt-get install -y wget bzip2 ca-certificates \ - libglib2.0-0 libxext6 libsm6 libxrender1 \ - git mercurial subversion - -RUN wget --quiet https://repo.anaconda.com/archive/Anaconda3-5.2.0-Linux-x86_64.sh -O ~/anaconda.sh && \ - /bin/bash ~/anaconda.sh -b -p /opt/conda && \ - rm ~/anaconda.sh && \ - ln -s /opt/conda/etc/profile.d/conda.sh /etc/profile.d/conda.sh && \ - echo ". /opt/conda/etc/profile.d/conda.sh" >> ~/.bashrc && \ - echo "conda activate base" >> ~/.bashrc - -RUN apt-get install -y curl grep sed dpkg && \ - TINI_VERSION=`curl https://github.com/krallin/tini/releases/latest | grep -o "/v.*\"" | sed 's:^..\(.*\).$:\1:'` && \ - curl -L "https://github.com/krallin/tini/releases/download/v${TINI_VERSION}/tini_${TINI_VERSION}.deb" > tini.deb && \ - dpkg -i tini.deb && \ - rm tini.deb && \ - apt-get clean - -ENTRYPOINT [ "/usr/bin/tini", "--" ] -CMD [ "/bin/bash" ] - -# install pytorch 1.1 and cudatoolkit -RUN conda install pytorch==1.1.0 torchvision==0.3.0 cudatoolkit=10.0 -c pytorch - -# clone and install openvqa dependencies -RUN mkdir /workspace && \ - cd /workspace && \ - git clone https://github.com/MILVLG/openvqa.git && \ - cd openvqa &&\ - pip install -r requirements.txt && \ - wget https://github.com/explosion/spacy-models/releases/download/en_vectors_web_lg-2.1.0/en_vectors_web_lg-2.1.0.tar.gz -O en_vectors_web_lg-2.1.0.tar.gz && \ - pip install en_vectors_web_lg-2.1.0.tar.gz && \ - rm en_vectors_web_lg-2.1.0.tar.gz && \ - cd / - -# delete openvqa repo -RUN rm -r /workspace/openvqa - -WORKDIR /workspace - diff --git a/spaces/CVPR/LIVE/thrust/thrust/mr/disjoint_sync_pool.h b/spaces/CVPR/LIVE/thrust/thrust/mr/disjoint_sync_pool.h deleted file mode 100644 index ed6cab7ed67b4358934c360e83351b90db0211a4..0000000000000000000000000000000000000000 --- a/spaces/CVPR/LIVE/thrust/thrust/mr/disjoint_sync_pool.h +++ /dev/null @@ -1,119 +0,0 @@ -/* - * Copyright 2018 NVIDIA Corporation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/*! \file disjoint_sync_pool.h - * \brief A mutex-synchronized version of \p disjoint_unsynchronized_pool_resource. - */ - -#pragma once - -#include
-
-
- );
-}
-
-const STYLES = {
- area: {position: 'absolute', bottom:'10px', left: '30%', zIndex: 500, display: 'flex', flexDirection: 'column', alignItems: 'center'},
- text: {margin: '0px', width:'700px', padding: '5px', background: 'none', color: '#000000', fontSize: '1.6em', border: 'none'},
- speak: {padding: '10px', display: 'inline-block', color: '#FFFFFF', background: '#222222', border: 'None', marginLeft: '10px'},
- area2: {position: 'absolute', top:'5px', right: '15px', zIndex: 500},
- label: {color: '#777777', fontSize:'1.2em'},
- languageSelect: {border: 'none', padding: '10px', backgroundColor: '#222222', color: '#fff', display: 'inline-block'},
- buttonContainer: {display: 'flex', justifyContent: 'center', gap: '10px'}
-}
-
-function App() {
-
- const audioPlayer = useRef();
-
- const [speak, setSpeak] = useState(false);
- const [text, setText] = useState("My name is Arwen. I'm a virtual human who can speak whatever you type here along with realistic facial movements.");
- const [audioSource, setAudioSource] = useState(null);
- const [playing, setPlaying] = useState(false);
- const [language, setLanguage] = useState('en-US');
- const [loop, setLoop] = useState(false);
- const [chat, setChat] = useState(false);
-
- // End of play
- function playerEnded(e) {
- setAudioSource(null);
- setSpeak(false);
- setPlaying(false);
-
- if (loop) {
- setTimeout(() => {
- setSpeak(true); // Khởi động lại yêu cầu đến backend sau 5s
- }, 5000);
- }
- }
-
- // Player is read
- function playerReady(e) {
- audioPlayer.current.audioEl.current.play();
- setPlaying(true);
-
- }
-
- return (
-
-
-