[0-9]+(?:\.[0-9]+)*) # release segment
- (?P # pre-release
- [-_\.]?
- (?P(a|b|c|rc|alpha|beta|pre|preview))
- [-_\.]?
- (?P[0-9]+)?
- )?
- (?P # post release
- (?:-(?P[0-9]+))
- |
- (?:
- [-_\.]?
- (?Ppost|rev|r)
- [-_\.]?
- (?P[0-9]+)?
- )
- )?
- (?P # dev release
- [-_\.]?
- (?Pdev)
- [-_\.]?
- (?P[0-9]+)?
- )?
- )
- (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
-"""
-
-VERSION_REGEX = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.X | re.I)
-
-
-def pep440(version: str) -> bool:
- return VERSION_REGEX.match(version) is not None
-
-
-# -------------------------------------------------------------------------------------
-# PEP 508
-
-PEP508_IDENTIFIER_PATTERN = r"([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])"
-PEP508_IDENTIFIER_REGEX = re.compile(f"^{PEP508_IDENTIFIER_PATTERN}$", re.I)
-
-
-def pep508_identifier(name: str) -> bool:
- return PEP508_IDENTIFIER_REGEX.match(name) is not None
-
-
-try:
- try:
- from packaging import requirements as _req
- except ImportError: # pragma: no cover
- # let's try setuptools vendored version
- from setuptools._vendor.packaging import requirements as _req # type: ignore
-
- def pep508(value: str) -> bool:
- try:
- _req.Requirement(value)
- return True
- except _req.InvalidRequirement:
- return False
-
-except ImportError: # pragma: no cover
- _logger.warning(
- "Could not find an installation of `packaging`. Requirements, dependencies and "
- "versions might not be validated. "
- "To enforce validation, please install `packaging`."
- )
-
- def pep508(value: str) -> bool:
- return True
-
-
-def pep508_versionspec(value: str) -> bool:
- """Expression that can be used to specify/lock versions (including ranges)"""
- if any(c in value for c in (";", "]", "@")):
- # In PEP 508:
- # conditional markers, extras and URL specs are not included in the
- # versionspec
- return False
- # Let's pretend we have a dependency called `requirement` with the given
- # version spec, then we can re-use the pep508 function for validation:
- return pep508(f"requirement{value}")
-
-
-# -------------------------------------------------------------------------------------
-# PEP 517
-
-
-def pep517_backend_reference(value: str) -> bool:
- module, _, obj = value.partition(":")
- identifiers = (i.strip() for i in _chain(module.split("."), obj.split(".")))
- return all(python_identifier(i) for i in identifiers if i)
-
-
-# -------------------------------------------------------------------------------------
-# Classifiers - PEP 301
-
-
-def _download_classifiers() -> str:
- import ssl
- from email.message import Message
- from urllib.request import urlopen
-
- url = "https://pypi.org/pypi?:action=list_classifiers"
- context = ssl.create_default_context()
- with urlopen(url, context=context) as response:
- headers = Message()
- headers["content_type"] = response.getheader("content-type", "text/plain")
- return response.read().decode(headers.get_param("charset", "utf-8"))
-
-
-class _TroveClassifier:
- """The ``trove_classifiers`` package is the official way of validating classifiers,
- however this package might not be always available.
- As a workaround we can still download a list from PyPI.
- We also don't want to be over strict about it, so simply skipping silently is an
- option (classifiers will be validated anyway during the upload to PyPI).
- """
-
- def __init__(self):
- self.downloaded: typing.Union[None, False, typing.Set[str]] = None
- self._skip_download = False
- # None => not cached yet
- # False => cache not available
- self.__name__ = "trove_classifier" # Emulate a public function
-
- def _disable_download(self):
- # This is a private API. Only setuptools has the consent of using it.
- self._skip_download = True
-
- def __call__(self, value: str) -> bool:
- if self.downloaded is False or self._skip_download is True:
- return True
-
- if os.getenv("NO_NETWORK") or os.getenv("VALIDATE_PYPROJECT_NO_NETWORK"):
- self.downloaded = False
- msg = (
- "Install ``trove-classifiers`` to ensure proper validation. "
- "Skipping download of classifiers list from PyPI (NO_NETWORK)."
- )
- _logger.debug(msg)
- return True
-
- if self.downloaded is None:
- msg = (
- "Install ``trove-classifiers`` to ensure proper validation. "
- "Meanwhile a list of classifiers will be downloaded from PyPI."
- )
- _logger.debug(msg)
- try:
- self.downloaded = set(_download_classifiers().splitlines())
- except Exception:
- self.downloaded = False
- _logger.debug("Problem with download, skipping validation")
- return True
-
- return value in self.downloaded or value.lower().startswith("private ::")
-
-
-try:
- from trove_classifiers import classifiers as _trove_classifiers
-
- def trove_classifier(value: str) -> bool:
- return value in _trove_classifiers or value.lower().startswith("private ::")
-
-except ImportError: # pragma: no cover
- trove_classifier = _TroveClassifier()
-
-
-# -------------------------------------------------------------------------------------
-# Non-PEP related
-
-
-def url(value: str) -> bool:
- from urllib.parse import urlparse
-
- try:
- parts = urlparse(value)
- if not parts.scheme:
- _logger.warning(
- "For maximum compatibility please make sure to include a "
- "`scheme` prefix in your URL (e.g. 'http://'). "
- f"Given value: {value}"
- )
- if not (value.startswith("/") or value.startswith("\\") or "@" in value):
- parts = urlparse(f"http://{value}")
-
- return bool(parts.scheme and parts.netloc)
- except Exception:
- return False
-
-
-# https://packaging.python.org/specifications/entry-points/
-ENTRYPOINT_PATTERN = r"[^\[\s=]([^=]*[^\s=])?"
-ENTRYPOINT_REGEX = re.compile(f"^{ENTRYPOINT_PATTERN}$", re.I)
-RECOMMEDED_ENTRYPOINT_PATTERN = r"[\w.-]+"
-RECOMMEDED_ENTRYPOINT_REGEX = re.compile(f"^{RECOMMEDED_ENTRYPOINT_PATTERN}$", re.I)
-ENTRYPOINT_GROUP_PATTERN = r"\w+(\.\w+)*"
-ENTRYPOINT_GROUP_REGEX = re.compile(f"^{ENTRYPOINT_GROUP_PATTERN}$", re.I)
-
-
-def python_identifier(value: str) -> bool:
- return value.isidentifier()
-
-
-def python_qualified_identifier(value: str) -> bool:
- if value.startswith(".") or value.endswith("."):
- return False
- return all(python_identifier(m) for m in value.split("."))
-
-
-def python_module_name(value: str) -> bool:
- return python_qualified_identifier(value)
-
-
-def python_entrypoint_group(value: str) -> bool:
- return ENTRYPOINT_GROUP_REGEX.match(value) is not None
-
-
-def python_entrypoint_name(value: str) -> bool:
- if not ENTRYPOINT_REGEX.match(value):
- return False
- if not RECOMMEDED_ENTRYPOINT_REGEX.match(value):
- msg = f"Entry point `{value}` does not follow recommended pattern: "
- msg += RECOMMEDED_ENTRYPOINT_PATTERN
- _logger.warning(msg)
- return True
-
-
-def python_entrypoint_reference(value: str) -> bool:
- module, _, rest = value.partition(":")
- if "[" in rest:
- obj, _, extras_ = rest.partition("[")
- if extras_.strip()[-1] != "]":
- return False
- extras = (x.strip() for x in extras_.strip(string.whitespace + "[]").split(","))
- if not all(pep508_identifier(e) for e in extras):
- return False
- _logger.warning(f"`{value}` - using extras for entry points is not recommended")
- else:
- obj = rest
-
- module_parts = module.split(".")
- identifiers = _chain(module_parts, obj.split(".")) if rest else module_parts
- return all(python_identifier(i.strip()) for i in identifiers)
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated.h b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated.h
deleted file mode 100644
index 12aca388e47b12dafd20999f2991a9d42f4b904b..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-#pragma once
-#include
-
-namespace detectron2 {
-
-at::Tensor nms_rotated_cpu(
- const at::Tensor& dets,
- const at::Tensor& scores,
- const double iou_threshold);
-
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-at::Tensor nms_rotated_cuda(
- const at::Tensor& dets,
- const at::Tensor& scores,
- const double iou_threshold);
-#endif
-
-// Interface for Python
-// inline is needed to prevent multiple function definitions when this header is
-// included by different cpps
-inline at::Tensor nms_rotated(
- const at::Tensor& dets,
- const at::Tensor& scores,
- const double iou_threshold) {
- assert(dets.device().is_cuda() == scores.device().is_cuda());
- if (dets.device().is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
- return nms_rotated_cuda(
- dets.contiguous(), scores.contiguous(), iou_threshold);
-#else
- AT_ERROR("Detectron2 is not compiled with GPU support!");
-#endif
- }
-
- return nms_rotated_cpu(dets.contiguous(), scores.contiguous(), iou_threshold);
-}
-
-} // namespace detectron2
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/dense_detector.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/dense_detector.py
deleted file mode 100644
index 382eab976f4426496f6a54ce7d47b093db477f91..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/dense_detector.py
+++ /dev/null
@@ -1,282 +0,0 @@
-import numpy as np
-from typing import Dict, List, Optional, Tuple
-import torch
-from torch import Tensor, nn
-
-from detectron2.data.detection_utils import convert_image_to_rgb
-from detectron2.modeling import Backbone
-from detectron2.structures import Boxes, ImageList, Instances
-from detectron2.utils.events import get_event_storage
-
-from ..postprocessing import detector_postprocess
-
-
-def permute_to_N_HWA_K(tensor, K: int):
- """
- Transpose/reshape a tensor from (N, (Ai x K), H, W) to (N, (HxWxAi), K)
- """
- assert tensor.dim() == 4, tensor.shape
- N, _, H, W = tensor.shape
- tensor = tensor.view(N, -1, K, H, W)
- tensor = tensor.permute(0, 3, 4, 1, 2)
- tensor = tensor.reshape(N, -1, K) # Size=(N,HWA,K)
- return tensor
-
-
-class DenseDetector(nn.Module):
- """
- Base class for dense detector. We define a dense detector as a fully-convolutional model that
- makes per-pixel (i.e. dense) predictions.
- """
-
- def __init__(
- self,
- backbone: Backbone,
- head: nn.Module,
- head_in_features: Optional[List[str]] = None,
- *,
- pixel_mean,
- pixel_std,
- ):
- """
- Args:
- backbone: backbone module
- head: head module
- head_in_features: backbone features to use in head. Default to all backbone features.
- pixel_mean (Tuple[float]):
- Values to be used for image normalization (BGR order).
- To train on images of different number of channels, set different mean & std.
- Default values are the mean pixel value from ImageNet: [103.53, 116.28, 123.675]
- pixel_std (Tuple[float]):
- When using pre-trained models in Detectron1 or any MSRA models,
- std has been absorbed into its conv1 weights, so the std needs to be set 1.
- Otherwise, you can use [57.375, 57.120, 58.395] (ImageNet std)
- """
- super().__init__()
-
- self.backbone = backbone
- self.head = head
- if head_in_features is None:
- shapes = self.backbone.output_shape()
- self.head_in_features = sorted(shapes.keys(), key=lambda x: shapes[x].stride)
- else:
- self.head_in_features = head_in_features
-
- self.register_buffer("pixel_mean", torch.tensor(pixel_mean).view(-1, 1, 1), False)
- self.register_buffer("pixel_std", torch.tensor(pixel_std).view(-1, 1, 1), False)
-
- @property
- def device(self):
- return self.pixel_mean.device
-
- def forward(self, batched_inputs: List[Dict[str, Tensor]]):
- """
- Args:
- batched_inputs: a list, batched outputs of :class:`DatasetMapper` .
- Each item in the list contains the inputs for one image.
- For now, each item in the list is a dict that contains:
-
- * image: Tensor, image in (C, H, W) format.
- * instances: Instances
-
- Other information that's included in the original dicts, such as:
-
- * "height", "width" (int): the output resolution of the model, used in inference.
- See :meth:`postprocess` for details.
-
- Returns:
- In training, dict[str, Tensor]: mapping from a named loss to a tensor storing the
- loss. Used during training only. In inference, the standard output format, described
- in :doc:`/tutorials/models`.
- """
- images = self.preprocess_image(batched_inputs)
- features = self.backbone(images.tensor)
- features = [features[f] for f in self.head_in_features]
- predictions = self.head(features)
-
- if self.training:
- assert not torch.jit.is_scripting(), "Not supported"
- assert "instances" in batched_inputs[0], "Instance annotations are missing in training!"
- gt_instances = [x["instances"].to(self.device) for x in batched_inputs]
- return self.forward_training(images, features, predictions, gt_instances)
- else:
- results = self.forward_inference(images, features, predictions)
- if torch.jit.is_scripting():
- return results
-
- processed_results = []
- for results_per_image, input_per_image, image_size in zip(
- results, batched_inputs, images.image_sizes
- ):
- height = input_per_image.get("height", image_size[0])
- width = input_per_image.get("width", image_size[1])
- r = detector_postprocess(results_per_image, height, width)
- processed_results.append({"instances": r})
- return processed_results
-
- def forward_training(self, images, features, predictions, gt_instances):
- raise NotImplementedError()
-
- def preprocess_image(self, batched_inputs: List[Dict[str, Tensor]]):
- """
- Normalize, pad and batch the input images.
- """
- images = [x["image"].to(self.device) for x in batched_inputs]
- images = [(x - self.pixel_mean) / self.pixel_std for x in images]
- images = ImageList.from_tensors(images, self.backbone.size_divisibility)
- return images
-
- def _transpose_dense_predictions(
- self, predictions: List[List[Tensor]], dims_per_anchor: List[int]
- ) -> List[List[Tensor]]:
- """
- Transpose the dense per-level predictions.
-
- Args:
- predictions: a list of outputs, each is a list of per-level
- predictions with shape (N, Ai x K, Hi, Wi), where N is the
- number of images, Ai is the number of anchors per location on
- level i, K is the dimension of predictions per anchor.
- dims_per_anchor: the value of K for each predictions. e.g. 4 for
- box prediction, #classes for classification prediction.
-
- Returns:
- List[List[Tensor]]: each prediction is transposed to (N, Hi x Wi x Ai, K).
- """
- assert len(predictions) == len(dims_per_anchor)
- res: List[List[Tensor]] = []
- for pred, dim_per_anchor in zip(predictions, dims_per_anchor):
- pred = [permute_to_N_HWA_K(x, dim_per_anchor) for x in pred]
- res.append(pred)
- return res
-
- def _ema_update(self, name: str, value: float, initial_value: float, momentum: float = 0.9):
- """
- Apply EMA update to `self.name` using `value`.
-
- This is mainly used for loss normalizer. In Detectron1, loss is normalized by number
- of foreground samples in the batch. When batch size is 1 per GPU, #foreground has a
- large variance and using it lead to lower performance. Therefore we maintain an EMA of
- #foreground to stabilize the normalizer.
-
- Args:
- name: name of the normalizer
- value: the new value to update
- initial_value: the initial value to start with
- momentum: momentum of EMA
-
- Returns:
- float: the updated EMA value
- """
- if hasattr(self, name):
- old = getattr(self, name)
- else:
- old = initial_value
- new = old * momentum + value * (1 - momentum)
- setattr(self, name, new)
- return new
-
- def _decode_per_level_predictions(
- self,
- anchors: Boxes,
- pred_scores: Tensor,
- pred_deltas: Tensor,
- score_thresh: float,
- topk_candidates: int,
- image_size: Tuple[int, int],
- ) -> Instances:
- """
- Decode boxes and classification predictions of one featuer level, by
- the following steps:
- 1. filter the predictions based on score threshold and top K scores.
- 2. transform the box regression outputs
- 3. return the predicted scores, classes and boxes
-
- Args:
- anchors: Boxes, anchor for this feature level
- pred_scores: HxWxA,K
- pred_deltas: HxWxA,4
-
- Returns:
- Instances: with field "scores", "pred_boxes", "pred_classes".
- """
- # Apply two filtering to make NMS faster.
- # 1. Keep boxes with confidence score higher than threshold
- keep_idxs = pred_scores > score_thresh
- pred_scores = pred_scores[keep_idxs]
- topk_idxs = torch.nonzero(keep_idxs) # Kx2
-
- # 2. Keep top k top scoring boxes only
- num_topk = min(topk_candidates, topk_idxs.size(0))
- pred_scores, idxs = pred_scores.topk(num_topk)
- topk_idxs = topk_idxs[idxs]
-
- anchor_idxs, classes_idxs = topk_idxs.unbind(dim=1)
-
- pred_boxes = self.box2box_transform.apply_deltas(
- pred_deltas[anchor_idxs], anchors.tensor[anchor_idxs]
- )
- return Instances(
- image_size, pred_boxes=Boxes(pred_boxes), scores=pred_scores, pred_classes=classes_idxs
- )
-
- def _decode_multi_level_predictions(
- self,
- anchors: List[Boxes],
- pred_scores: List[Tensor],
- pred_deltas: List[Tensor],
- score_thresh: float,
- topk_candidates: int,
- image_size: Tuple[int, int],
- ) -> Instances:
- """
- Run `_decode_per_level_predictions` for all feature levels and concat the results.
- """
- predictions = [
- self._decode_per_level_predictions(
- anchors_i,
- box_cls_i,
- box_reg_i,
- self.test_score_thresh,
- self.test_topk_candidates,
- image_size,
- )
- # Iterate over every feature level
- for box_cls_i, box_reg_i, anchors_i in zip(pred_scores, pred_deltas, anchors)
- ]
- return predictions[0].cat(predictions) # 'Instances.cat' is not scriptale but this is
-
- def visualize_training(self, batched_inputs, results):
- """
- A function used to visualize ground truth images and final network predictions.
- It shows ground truth bounding boxes on the original image and up to 20
- predicted object bounding boxes on the original image.
-
- Args:
- batched_inputs (list): a list that contains input to the model.
- results (List[Instances]): a list of #images elements returned by forward_inference().
- """
- from detectron2.utils.visualizer import Visualizer
-
- assert len(batched_inputs) == len(
- results
- ), "Cannot visualize inputs and results of different sizes"
- storage = get_event_storage()
- max_boxes = 20
-
- image_index = 0 # only visualize a single image
- img = batched_inputs[image_index]["image"]
- img = convert_image_to_rgb(img.permute(1, 2, 0), self.input_format)
- v_gt = Visualizer(img, None)
- v_gt = v_gt.overlay_instances(boxes=batched_inputs[image_index]["instances"].gt_boxes)
- anno_img = v_gt.get_image()
- processed_results = detector_postprocess(results[image_index], img.shape[0], img.shape[1])
- predicted_boxes = processed_results.pred_boxes.tensor.detach().cpu().numpy()
-
- v_pred = Visualizer(img, None)
- v_pred = v_pred.overlay_instances(boxes=predicted_boxes[0:max_boxes])
- prop_img = v_pred.get_image()
- vis_img = np.vstack((anno_img, prop_img))
- vis_img = vis_img.transpose(2, 0, 1)
- vis_name = f"Top: GT bounding boxes; Bottom: {max_boxes} Highest Scoring Results"
- storage.put_image(vis_name, vis_img)
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/mask_head.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/mask_head.py
deleted file mode 100644
index 5ac5c4b9aaa34653d6c50e512a5a4300da450c7f..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/roi_heads/mask_head.py
+++ /dev/null
@@ -1,292 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from typing import List
-import fvcore.nn.weight_init as weight_init
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from detectron2.config import configurable
-from detectron2.layers import Conv2d, ConvTranspose2d, ShapeSpec, cat, get_norm
-from detectron2.structures import Instances
-from detectron2.utils.events import get_event_storage
-from detectron2.utils.registry import Registry
-
-__all__ = [
- "BaseMaskRCNNHead",
- "MaskRCNNConvUpsampleHead",
- "build_mask_head",
- "ROI_MASK_HEAD_REGISTRY",
-]
-
-
-ROI_MASK_HEAD_REGISTRY = Registry("ROI_MASK_HEAD")
-ROI_MASK_HEAD_REGISTRY.__doc__ = """
-Registry for mask heads, which predicts instance masks given
-per-region features.
-
-The registered object will be called with `obj(cfg, input_shape)`.
-"""
-
-
-@torch.jit.unused
-def mask_rcnn_loss(pred_mask_logits: torch.Tensor, instances: List[Instances], vis_period: int = 0):
- """
- Compute the mask prediction loss defined in the Mask R-CNN paper.
-
- Args:
- pred_mask_logits (Tensor): A tensor of shape (B, C, Hmask, Wmask) or (B, 1, Hmask, Wmask)
- for class-specific or class-agnostic, where B is the total number of predicted masks
- in all images, C is the number of foreground classes, and Hmask, Wmask are the height
- and width of the mask predictions. The values are logits.
- instances (list[Instances]): A list of N Instances, where N is the number of images
- in the batch. These instances are in 1:1
- correspondence with the pred_mask_logits. The ground-truth labels (class, box, mask,
- ...) associated with each instance are stored in fields.
- vis_period (int): the period (in steps) to dump visualization.
-
- Returns:
- mask_loss (Tensor): A scalar tensor containing the loss.
- """
- cls_agnostic_mask = pred_mask_logits.size(1) == 1
- total_num_masks = pred_mask_logits.size(0)
- mask_side_len = pred_mask_logits.size(2)
- assert pred_mask_logits.size(2) == pred_mask_logits.size(3), "Mask prediction must be square!"
-
- gt_classes = []
- gt_masks = []
- for instances_per_image in instances:
- if len(instances_per_image) == 0:
- continue
- if not cls_agnostic_mask:
- gt_classes_per_image = instances_per_image.gt_classes.to(dtype=torch.int64)
- gt_classes.append(gt_classes_per_image)
-
- gt_masks_per_image = instances_per_image.gt_masks.crop_and_resize(
- instances_per_image.proposal_boxes.tensor, mask_side_len
- ).to(device=pred_mask_logits.device)
- # A tensor of shape (N, M, M), N=#instances in the image; M=mask_side_len
- gt_masks.append(gt_masks_per_image)
-
- if len(gt_masks) == 0:
- return pred_mask_logits.sum() * 0
-
- gt_masks = cat(gt_masks, dim=0)
-
- if cls_agnostic_mask:
- pred_mask_logits = pred_mask_logits[:, 0]
- else:
- indices = torch.arange(total_num_masks)
- gt_classes = cat(gt_classes, dim=0)
- pred_mask_logits = pred_mask_logits[indices, gt_classes]
-
- if gt_masks.dtype == torch.bool:
- gt_masks_bool = gt_masks
- else:
- # Here we allow gt_masks to be float as well (depend on the implementation of rasterize())
- gt_masks_bool = gt_masks > 0.5
- gt_masks = gt_masks.to(dtype=torch.float32)
-
- # Log the training accuracy (using gt classes and 0.5 threshold)
- mask_incorrect = (pred_mask_logits > 0.0) != gt_masks_bool
- mask_accuracy = 1 - (mask_incorrect.sum().item() / max(mask_incorrect.numel(), 1.0))
- num_positive = gt_masks_bool.sum().item()
- false_positive = (mask_incorrect & ~gt_masks_bool).sum().item() / max(
- gt_masks_bool.numel() - num_positive, 1.0
- )
- false_negative = (mask_incorrect & gt_masks_bool).sum().item() / max(num_positive, 1.0)
-
- storage = get_event_storage()
- storage.put_scalar("mask_rcnn/accuracy", mask_accuracy)
- storage.put_scalar("mask_rcnn/false_positive", false_positive)
- storage.put_scalar("mask_rcnn/false_negative", false_negative)
- if vis_period > 0 and storage.iter % vis_period == 0:
- pred_masks = pred_mask_logits.sigmoid()
- vis_masks = torch.cat([pred_masks, gt_masks], axis=2)
- name = "Left: mask prediction; Right: mask GT"
- for idx, vis_mask in enumerate(vis_masks):
- vis_mask = torch.stack([vis_mask] * 3, axis=0)
- storage.put_image(name + f" ({idx})", vis_mask)
-
- mask_loss = F.binary_cross_entropy_with_logits(pred_mask_logits, gt_masks, reduction="mean")
- return mask_loss
-
-
-def mask_rcnn_inference(pred_mask_logits: torch.Tensor, pred_instances: List[Instances]):
- """
- Convert pred_mask_logits to estimated foreground probability masks while also
- extracting only the masks for the predicted classes in pred_instances. For each
- predicted box, the mask of the same class is attached to the instance by adding a
- new "pred_masks" field to pred_instances.
-
- Args:
- pred_mask_logits (Tensor): A tensor of shape (B, C, Hmask, Wmask) or (B, 1, Hmask, Wmask)
- for class-specific or class-agnostic, where B is the total number of predicted masks
- in all images, C is the number of foreground classes, and Hmask, Wmask are the height
- and width of the mask predictions. The values are logits.
- pred_instances (list[Instances]): A list of N Instances, where N is the number of images
- in the batch. Each Instances must have field "pred_classes".
-
- Returns:
- None. pred_instances will contain an extra "pred_masks" field storing a mask of size (Hmask,
- Wmask) for predicted class. Note that the masks are returned as a soft (non-quantized)
- masks the resolution predicted by the network; post-processing steps, such as resizing
- the predicted masks to the original image resolution and/or binarizing them, is left
- to the caller.
- """
- cls_agnostic_mask = pred_mask_logits.size(1) == 1
-
- if cls_agnostic_mask:
- mask_probs_pred = pred_mask_logits.sigmoid()
- else:
- # Select masks corresponding to the predicted classes
- num_masks = pred_mask_logits.shape[0]
- class_pred = cat([i.pred_classes for i in pred_instances])
- indices = torch.arange(num_masks, device=class_pred.device)
- mask_probs_pred = pred_mask_logits[indices, class_pred][:, None].sigmoid()
- # mask_probs_pred.shape: (B, 1, Hmask, Wmask)
-
- num_boxes_per_image = [len(i) for i in pred_instances]
- mask_probs_pred = mask_probs_pred.split(num_boxes_per_image, dim=0)
-
- for prob, instances in zip(mask_probs_pred, pred_instances):
- instances.pred_masks = prob # (1, Hmask, Wmask)
-
-
-class BaseMaskRCNNHead(nn.Module):
- """
- Implement the basic Mask R-CNN losses and inference logic described in :paper:`Mask R-CNN`
- """
-
- @configurable
- def __init__(self, *, loss_weight: float = 1.0, vis_period: int = 0):
- """
- NOTE: this interface is experimental.
-
- Args:
- loss_weight (float): multiplier of the loss
- vis_period (int): visualization period
- """
- super().__init__()
- self.vis_period = vis_period
- self.loss_weight = loss_weight
-
- @classmethod
- def from_config(cls, cfg, input_shape):
- return {"vis_period": cfg.VIS_PERIOD}
-
- def forward(self, x, instances: List[Instances]):
- """
- Args:
- x: input region feature(s) provided by :class:`ROIHeads`.
- instances (list[Instances]): contains the boxes & labels corresponding
- to the input features.
- Exact format is up to its caller to decide.
- Typically, this is the foreground instances in training, with
- "proposal_boxes" field and other gt annotations.
- In inference, it contains boxes that are already predicted.
-
- Returns:
- A dict of losses in training. The predicted "instances" in inference.
- """
- x = self.layers(x)
- if self.training:
- return {"loss_mask": mask_rcnn_loss(x, instances, self.vis_period) * self.loss_weight}
- else:
- mask_rcnn_inference(x, instances)
- return instances
-
- def layers(self, x):
- """
- Neural network layers that makes predictions from input features.
- """
- raise NotImplementedError
-
-
-# To get torchscript support, we make the head a subclass of `nn.Sequential`.
-# Therefore, to add new layers in this head class, please make sure they are
-# added in the order they will be used in forward().
-@ROI_MASK_HEAD_REGISTRY.register()
-class MaskRCNNConvUpsampleHead(BaseMaskRCNNHead, nn.Sequential):
- """
- A mask head with several conv layers, plus an upsample layer (with `ConvTranspose2d`).
- Predictions are made with a final 1x1 conv layer.
- """
-
- @configurable
- def __init__(self, input_shape: ShapeSpec, *, num_classes, conv_dims, conv_norm="", **kwargs):
- """
- NOTE: this interface is experimental.
-
- Args:
- input_shape (ShapeSpec): shape of the input feature
- num_classes (int): the number of foreground classes (i.e. background is not
- included). 1 if using class agnostic prediction.
- conv_dims (list[int]): a list of N>0 integers representing the output dimensions
- of N-1 conv layers and the last upsample layer.
- conv_norm (str or callable): normalization for the conv layers.
- See :func:`detectron2.layers.get_norm` for supported types.
- """
- super().__init__(**kwargs)
- assert len(conv_dims) >= 1, "conv_dims have to be non-empty!"
-
- self.conv_norm_relus = []
-
- cur_channels = input_shape.channels
- for k, conv_dim in enumerate(conv_dims[:-1]):
- conv = Conv2d(
- cur_channels,
- conv_dim,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=not conv_norm,
- norm=get_norm(conv_norm, conv_dim),
- activation=nn.ReLU(),
- )
- self.add_module("mask_fcn{}".format(k + 1), conv)
- self.conv_norm_relus.append(conv)
- cur_channels = conv_dim
-
- self.deconv = ConvTranspose2d(
- cur_channels, conv_dims[-1], kernel_size=2, stride=2, padding=0
- )
- self.add_module("deconv_relu", nn.ReLU())
- cur_channels = conv_dims[-1]
-
- self.predictor = Conv2d(cur_channels, num_classes, kernel_size=1, stride=1, padding=0)
-
- for layer in self.conv_norm_relus + [self.deconv]:
- weight_init.c2_msra_fill(layer)
- # use normal distribution initialization for mask prediction layer
- nn.init.normal_(self.predictor.weight, std=0.001)
- if self.predictor.bias is not None:
- nn.init.constant_(self.predictor.bias, 0)
-
- @classmethod
- def from_config(cls, cfg, input_shape):
- ret = super().from_config(cfg, input_shape)
- conv_dim = cfg.MODEL.ROI_MASK_HEAD.CONV_DIM
- num_conv = cfg.MODEL.ROI_MASK_HEAD.NUM_CONV
- ret.update(
- conv_dims=[conv_dim] * (num_conv + 1), # +1 for ConvTranspose
- conv_norm=cfg.MODEL.ROI_MASK_HEAD.NORM,
- input_shape=input_shape,
- )
- if cfg.MODEL.ROI_MASK_HEAD.CLS_AGNOSTIC_MASK:
- ret["num_classes"] = 1
- else:
- ret["num_classes"] = cfg.MODEL.ROI_HEADS.NUM_CLASSES
- return ret
-
- def layers(self, x):
- for layer in self:
- x = layer(x)
- return x
-
-
-def build_mask_head(cfg, input_shape):
- """
- Build a mask head defined by `cfg.MODEL.ROI_MASK_HEAD.NAME`.
- """
- name = cfg.MODEL.ROI_MASK_HEAD.NAME
- return ROI_MASK_HEAD_REGISTRY.get(name)(cfg, input_shape)
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/utils/serialize.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/utils/serialize.py
deleted file mode 100644
index 0b38862804b70cf1159a9bc93acdef73c184d883..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/utils/serialize.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import cloudpickle
-
-
-class PicklableWrapper(object):
- """
- Wrap an object to make it more picklable, note that it uses
- heavy weight serialization libraries that are slower than pickle.
- It's best to use it only on closures (which are usually not picklable).
-
- This is a simplified version of
- https://github.com/joblib/joblib/blob/master/joblib/externals/loky/cloudpickle_wrapper.py
- """
-
- def __init__(self, obj):
- while isinstance(obj, PicklableWrapper):
- # Wrapping an object twice is no-op
- obj = obj._obj
- self._obj = obj
-
- def __reduce__(self):
- s = cloudpickle.dumps(self._obj)
- return cloudpickle.loads, (s,)
-
- def __call__(self, *args, **kwargs):
- return self._obj(*args, **kwargs)
-
- def __getattr__(self, attr):
- # Ensure that the wrapped object can be used seamlessly as the previous object.
- if attr not in ["_obj"]:
- return getattr(self._obj, attr)
- return getattr(self, attr)
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/dev/packaging/build_wheel.sh b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/dev/packaging/build_wheel.sh
deleted file mode 100644
index 2d9facccdcb9f5d46014a9fb253429ff5f45a127..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/dev/packaging/build_wheel.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-# Copyright (c) Facebook, Inc. and its affiliates.
-set -ex
-
-ldconfig # https://github.com/NVIDIA/nvidia-docker/issues/854
-
-script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-. "$script_dir/pkg_helpers.bash"
-
-echo "Build Settings:"
-echo "CU_VERSION: $CU_VERSION" # e.g. cu101
-echo "D2_VERSION_SUFFIX: $D2_VERSION_SUFFIX" # e.g. +cu101 or ""
-echo "PYTHON_VERSION: $PYTHON_VERSION" # e.g. 3.6
-echo "PYTORCH_VERSION: $PYTORCH_VERSION" # e.g. 1.4
-
-setup_cuda
-setup_wheel_python
-
-yum install ninja-build -y
-ln -sv /usr/bin/ninja-build /usr/bin/ninja || true
-
-pip_install pip numpy -U
-pip_install "torch==$PYTORCH_VERSION" \
- -f https://download.pytorch.org/whl/"$CU_VERSION"/torch_stable.html
-
-# use separate directories to allow parallel build
-BASE_BUILD_DIR=build/$CU_VERSION-py$PYTHON_VERSION-pt$PYTORCH_VERSION
-python setup.py \
- build -b "$BASE_BUILD_DIR" \
- bdist_wheel -b "$BASE_BUILD_DIR/build_dist" -d "wheels/$CU_VERSION/torch$PYTORCH_VERSION"
-rm -rf "$BASE_BUILD_DIR"
diff --git a/spaces/Bala2-03-2003/AIBALA/README.md b/spaces/Bala2-03-2003/AIBALA/README.md
deleted file mode 100644
index a0facbad4ac6aa1d1f6a7541b988601892825679..0000000000000000000000000000000000000000
--- a/spaces/Bala2-03-2003/AIBALA/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: AIBALA
-emoji: 👁
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.39.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Benson/text-generation/Examples/Carx Street 3 Apk.md b/spaces/Benson/text-generation/Examples/Carx Street 3 Apk.md
deleted file mode 100644
index c3ed3c40a43d1b7411d2a2b32206311511c803c2..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Carx Street 3 Apk.md
+++ /dev/null
@@ -1,105 +0,0 @@
-
-CarX Street 3 APK: Una revisión del último juego de carreras de calle
-Si usted es un fan de los juegos de carreras callejeras, es posible que haya oído hablar de CarX Street 3 APK, la última entrega de la serie CarX. Este juego se encuentra actualmente en pruebas beta abiertas y promete ofrecer una experiencia de carreras emocionante y realista en un mundo abierto dinámico. En este artículo, vamos a revisar las características, proceso de descarga, pros y contras, y preguntas frecuentes de CarX Street 3 APK.
- ¿Qué es CarX Street 3 APK?
-CarX Street 3 APK es un juego para Android desarrollado por CarX Technologies, LLC, los creadores de CarX Drift Racing 2. Es un juego de carreras callejeras que le permite abrazar la libertad de ser un corredor callejero en el mundo abierto de Sunset City. Puedes aceptar el desafío y convertirte en la leyenda de la ciudad al competir en carreras realistas en carreteras y calles de la ciudad, así como en carreras de deriva de alta velocidad. También puede construir el coche de sus sueños utilizando la afinación de piezas que desbloquea toda la física del comportamiento del coche CarX Technology. Puedes explorar cada rincón del enorme mundo y disfrutar del dinámico cambio de día/noche.
-carx street 3 apk
Download > https://bltlly.com/2v6Kl5
- Características de CarX Street 3 APK
-CarX Street 3 APK tiene muchas características que lo convierten en un juego emocionante e inmersivo para los entusiastas de las carreras callejeras. Estos son algunos de ellos:
- Modo de carrera
-Usted puede elegir su propio camino en el modo de carrera, donde se puede conducir a la velocidad máxima o la deriva a través de turnos. Puedes unirte a clubes, derrotar jefes y demostrar a todos que eres el mejor conductor de la ciudad. También puedes comprar casas para tus coches y reunir colecciones para cada modo de carrera. Puedes cargar combustible con el combustible adecuado para la próxima carrera en las gasolineras de la ciudad.
- Sintonización de coches
-Puedes personalizar tu coche para que se adapte a tus preferencias y necesidades para cada carrera. Puedes intercambiar piezas y engañar a tu coche para una carrera específica. Puede actualizar el motor, la transmisión, el cuerpo, la suspensión y los neumáticos. También puede cambiar el motor de su automóvil único.
- Personalización visual
-
- Física y gráficos realistas
-El juego cuenta con una física impresionante y controles que te hacen sentir como si estuvieras conduciendo un coche real. Puedes admirar los modernos gráficos de alta calidad y el enorme mundo abierto que ofrece impresionantes vistas y detalles.
- Exploración del mundo abierto
-Puedes explorar cada rincón de Sunset City a cualquier hora del día o de la noche. Puedes descubrir lugares ocultos, atajos, rampas, saltos y secretos. También puedes interactuar con otros jugadores y PNJ de la ciudad.
- Cómo descargar e instalar CarX Street 3 APK?
-Si desea probar CarX Street 3 APK en su dispositivo Android, es necesario seguir estos pasos:
-
- Requisitos para CarX Street 3 APK
-
Antes de descargar e instalar CarX Street 3 APK, es necesario asegurarse de que el dispositivo cumple con los siguientes requisitos:
-
-
-| Requisito |
-Mínimo |
-Recomendado |
-
-
-| Sistema operativo |
-Android 6.0 o superior |
-Android 8.0 o superior |
-
-
-| RAM |
-2 GB |
-4 GB o más |
-
-
-| Espacio de almacenamiento |
-1.5 GB |
-2 GB o más |
-
-
-| Conexión a Internet |
-Requerido para funciones en línea |
-Requerido para funciones en línea |
-
-
-| Servicios de Google Play |
-Necesario para la instalación y las actualizaciones |
-Necesario para la instalación y las actualizaciones |
-
-
- Pasos para descargar e instalar CarX Street 3 APK
-Para descargar e instalar CarX Street 3 APK en su dispositivo, debe seguir estos pasos:
-
-- Vaya al sitio web oficial de CarX Technologies, LLC, [7](https://carx-online.com/), y haga clic en el botón "Descargar".
-- Seleccione la opción "CarX Street" y elija la opción "APK".
-- Serás redirigido a una página de descarga donde puedes elegir un enlace espejo para descargar el archivo APK.
-
-- Es posible que tenga que habilitar la opción "Fuentes desconocidas" en la configuración del dispositivo para permitir la instalación de aplicaciones desde fuentes distintas de Google Play.
-- Siga las instrucciones en pantalla para completar el proceso de instalación.
-- Ahora puede iniciar el juego y disfrutar de la experiencia de carreras callejeras.
-
- Pros y contras de CarX Street 3 APK
- CarX Street 3 APK es un juego que tiene muchas ventajas y desventajas. Estos son algunos de ellos:
- Pros de CarX Street 3 APK
-
-
-
-
-## Environments
-
-YOLOv5 may be run in any of the following up-to-date verified environments (with all dependencies including [CUDA](https://developer.nvidia.com/cuda)/[CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/) and [PyTorch](https://pytorch.org/) preinstalled):
-
-- **Google Colab and Kaggle** notebooks with free GPU: 