- bool push(F&& prep, P&&... params) {
- if (elems_ == nullptr) return false;
- return elems_->push(this, [&](void* p) {
- if (prep(p)) ::new (p) T(std::forward(params)...);
- });
- }
-
- template
- bool force_push(F&& prep, P&&... params) {
- if (elems_ == nullptr) return false;
- return elems_->force_push(this, [&](void* p) {
- if (prep(p)) ::new (p) T(std::forward(params)...);
- });
- }
-
- template
- bool pop(T& item, F&& out) {
- if (elems_ == nullptr) {
- return false;
- }
- return elems_->pop(this, &(this->cursor_), [&item](void* p) {
- ::new (&item) T(std::move(*static_cast(p)));
- }, std::forward(out));
- }
-};
-
-} // namespace detail
-
-template
-class queue final : public detail::queue_base> {
- using base_t = detail::queue_base>;
-
-public:
- using value_t = T;
-
- using base_t::base_t;
-
- template
- bool push(P&&... params) {
- return base_t::template push(std::forward(params)...);
- }
-
- template
- bool force_push(P&&... params) {
- return base_t::template force_push(std::forward(params)...);
- }
-
- bool pop(T& item) {
- return base_t::pop(item, [](bool) {});
- }
-
- template
- bool pop(T& item, F&& out) {
- return base_t::pop(item, std::forward(out));
- }
-};
-
-} // namespace ipc
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/schedulers/pndm.md b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/schedulers/pndm.md
deleted file mode 100644
index 6670914b7ac0a0fd77224b06805fed2e463866e4..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/schedulers/pndm.md
+++ /dev/null
@@ -1,20 +0,0 @@
-
-
-# Pseudo numerical methods for diffusion models (PNDM)
-
-## Overview
-
-Original implementation can be found [here](https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181).
-
-## PNDMScheduler
-[[autodoc]] PNDMScheduler
\ No newline at end of file
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/text_to_video_synthesis/__init__.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/text_to_video_synthesis/__init__.py
deleted file mode 100644
index 97683885aac984ed0f7050d8524a63ff2c367f6c..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/text_to_video_synthesis/__init__.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from dataclasses import dataclass
-from typing import List, Optional, Union
-
-import numpy as np
-import torch
-
-from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
-
-
-@dataclass
-class TextToVideoSDPipelineOutput(BaseOutput):
- """
- Output class for text-to-video pipelines.
-
- Args:
- frames (`List[np.ndarray]` or `torch.FloatTensor`)
- List of denoised frames (essentially images) as NumPy arrays of shape `(height, width, num_channels)` or as
- a `torch` tensor. The length of the list denotes the video length (the number of frames).
- """
-
- frames: Union[List[np.ndarray], torch.FloatTensor]
-
-
-try:
- if not (is_transformers_available() and is_torch_available()):
- raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
- from ...utils.dummy_torch_and_transformers_objects import * # noqa F403
-else:
- from .pipeline_text_to_video_synth import TextToVideoSDPipeline
- from .pipeline_text_to_video_synth_img2img import VideoToVideoSDPipeline # noqa: F401
- from .pipeline_text_to_video_zero import TextToVideoZeroPipeline
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/fixtures/custom_pipeline/pipeline.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/fixtures/custom_pipeline/pipeline.py
deleted file mode 100644
index 0bb10c3d51851a064c4980420e5bdbb1149958cc..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/fixtures/custom_pipeline/pipeline.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# 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.
-
-
-from typing import Optional, Tuple, Union
-
-import torch
-
-from diffusers import DiffusionPipeline, ImagePipelineOutput
-
-
-class CustomLocalPipeline(DiffusionPipeline):
- r"""
- This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
- library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
-
- Parameters:
- unet ([`UNet2DModel`]): U-Net architecture to denoise the encoded image.
- scheduler ([`SchedulerMixin`]):
- A scheduler to be used in combination with `unet` to denoise the encoded image. Can be one of
- [`DDPMScheduler`], or [`DDIMScheduler`].
- """
-
- def __init__(self, unet, scheduler):
- super().__init__()
- self.register_modules(unet=unet, scheduler=scheduler)
-
- @torch.no_grad()
- def __call__(
- self,
- batch_size: int = 1,
- generator: Optional[torch.Generator] = None,
- num_inference_steps: int = 50,
- output_type: Optional[str] = "pil",
- return_dict: bool = True,
- **kwargs,
- ) -> Union[ImagePipelineOutput, Tuple]:
- r"""
- Args:
- batch_size (`int`, *optional*, defaults to 1):
- The number of images to generate.
- generator (`torch.Generator`, *optional*):
- A [torch generator](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make generation
- deterministic.
- eta (`float`, *optional*, defaults to 0.0):
- The eta parameter which controls the scale of the variance (0 is DDIM and 1 is one type of DDPM).
- num_inference_steps (`int`, *optional*, defaults to 50):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- output_type (`str`, *optional*, defaults to `"pil"`):
- The output format of the generate image. Choose between
- [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~pipelines.ImagePipelineOutput`] instead of a plain tuple.
-
- Returns:
- [`~pipelines.ImagePipelineOutput`] or `tuple`: [`~pipelines.utils.ImagePipelineOutput`] if
- `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the
- generated images.
- """
-
- # Sample gaussian noise to begin loop
- image = torch.randn(
- (batch_size, self.unet.config.in_channels, self.unet.config.sample_size, self.unet.config.sample_size),
- generator=generator,
- )
- image = image.to(self.device)
-
- # set step values
- self.scheduler.set_timesteps(num_inference_steps)
-
- for t in self.progress_bar(self.scheduler.timesteps):
- # 1. predict noise model_output
- model_output = self.unet(image, t).sample
-
- # 2. predict previous mean of image x_t-1 and add variance depending on eta
- # eta corresponds to η in paper and should be between [0, 1]
- # do x_t -> x_t-1
- image = self.scheduler.step(model_output, t, image).prev_sample
-
- image = (image / 2 + 0.5).clamp(0, 1)
- image = image.cpu().permute(0, 2, 3, 1).numpy()
- if output_type == "pil":
- image = self.numpy_to_pil(image)
-
- if not return_dict:
- return (image,), "This is a local test"
-
- return ImagePipelineOutput(images=image), "This is a local test"
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/schedulers/test_scheduler_ddim_inverse.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/schedulers/test_scheduler_ddim_inverse.py
deleted file mode 100644
index 39ee26306cc619de0fc23b5399732cf2a885ee3c..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/schedulers/test_scheduler_ddim_inverse.py
+++ /dev/null
@@ -1,135 +0,0 @@
-import torch
-
-from diffusers import DDIMInverseScheduler
-
-from .test_schedulers import SchedulerCommonTest
-
-
-class DDIMInverseSchedulerTest(SchedulerCommonTest):
- scheduler_classes = (DDIMInverseScheduler,)
- forward_default_kwargs = (("eta", 0.0), ("num_inference_steps", 50))
-
- def get_scheduler_config(self, **kwargs):
- config = {
- "num_train_timesteps": 1000,
- "beta_start": 0.0001,
- "beta_end": 0.02,
- "beta_schedule": "linear",
- "clip_sample": True,
- }
-
- config.update(**kwargs)
- return config
-
- def full_loop(self, **config):
- scheduler_class = self.scheduler_classes[0]
- scheduler_config = self.get_scheduler_config(**config)
- scheduler = scheduler_class(**scheduler_config)
-
- num_inference_steps, eta = 10, 0.0
-
- model = self.dummy_model()
- sample = self.dummy_sample_deter
-
- scheduler.set_timesteps(num_inference_steps)
-
- for t in scheduler.timesteps:
- residual = model(sample, t)
- sample = scheduler.step(residual, t, sample, eta).prev_sample
-
- return sample
-
- def test_timesteps(self):
- for timesteps in [100, 500, 1000]:
- self.check_over_configs(num_train_timesteps=timesteps)
-
- def test_steps_offset(self):
- for steps_offset in [0, 1]:
- self.check_over_configs(steps_offset=steps_offset)
-
- scheduler_class = self.scheduler_classes[0]
- scheduler_config = self.get_scheduler_config(steps_offset=1)
- scheduler = scheduler_class(**scheduler_config)
- scheduler.set_timesteps(5)
- assert torch.equal(scheduler.timesteps, torch.LongTensor([-199, 1, 201, 401, 601]))
-
- def test_betas(self):
- for beta_start, beta_end in zip([0.0001, 0.001, 0.01, 0.1], [0.002, 0.02, 0.2, 2]):
- self.check_over_configs(beta_start=beta_start, beta_end=beta_end)
-
- def test_schedules(self):
- for schedule in ["linear", "squaredcos_cap_v2"]:
- self.check_over_configs(beta_schedule=schedule)
-
- def test_prediction_type(self):
- for prediction_type in ["epsilon", "v_prediction"]:
- self.check_over_configs(prediction_type=prediction_type)
-
- def test_clip_sample(self):
- for clip_sample in [True, False]:
- self.check_over_configs(clip_sample=clip_sample)
-
- def test_timestep_spacing(self):
- for timestep_spacing in ["trailing", "leading"]:
- self.check_over_configs(timestep_spacing=timestep_spacing)
-
- def test_rescale_betas_zero_snr(self):
- for rescale_betas_zero_snr in [True, False]:
- self.check_over_configs(rescale_betas_zero_snr=rescale_betas_zero_snr)
-
- def test_thresholding(self):
- self.check_over_configs(thresholding=False)
- for threshold in [0.5, 1.0, 2.0]:
- for prediction_type in ["epsilon", "v_prediction"]:
- self.check_over_configs(
- thresholding=True,
- prediction_type=prediction_type,
- sample_max_value=threshold,
- )
-
- def test_time_indices(self):
- for t in [1, 10, 49]:
- self.check_over_forward(time_step=t)
-
- def test_inference_steps(self):
- for t, num_inference_steps in zip([1, 10, 50], [10, 50, 500]):
- self.check_over_forward(time_step=t, num_inference_steps=num_inference_steps)
-
- def test_add_noise_device(self):
- pass
-
- def test_full_loop_no_noise(self):
- sample = self.full_loop()
-
- result_sum = torch.sum(torch.abs(sample))
- result_mean = torch.mean(torch.abs(sample))
-
- assert abs(result_sum.item() - 509.1079) < 1e-2
- assert abs(result_mean.item() - 0.6629) < 1e-3
-
- def test_full_loop_with_v_prediction(self):
- sample = self.full_loop(prediction_type="v_prediction")
-
- result_sum = torch.sum(torch.abs(sample))
- result_mean = torch.mean(torch.abs(sample))
-
- assert abs(result_sum.item() - 1029.129) < 1e-2
- assert abs(result_mean.item() - 1.3400) < 1e-3
-
- def test_full_loop_with_set_alpha_to_one(self):
- # We specify different beta, so that the first alpha is 0.99
- sample = self.full_loop(set_alpha_to_one=True, beta_start=0.01)
- result_sum = torch.sum(torch.abs(sample))
- result_mean = torch.mean(torch.abs(sample))
-
- assert abs(result_sum.item() - 259.8116) < 1e-2
- assert abs(result_mean.item() - 0.3383) < 1e-3
-
- def test_full_loop_with_no_set_alpha_to_one(self):
- # We specify different beta, so that the first alpha is 0.99
- sample = self.full_loop(set_alpha_to_one=False, beta_start=0.01)
- result_sum = torch.sum(torch.abs(sample))
- result_mean = torch.mean(torch.abs(sample))
-
- assert abs(result_sum.item() - 239.055) < 1e-2
- assert abs(result_mean.item() - 0.3113) < 1e-3
diff --git a/spaces/Andy0409/text_generator/app.py b/spaces/Andy0409/text_generator/app.py
deleted file mode 100644
index 75e5f0d83f42be1f7fccfc3337293bb3a1f3d17a..0000000000000000000000000000000000000000
--- a/spaces/Andy0409/text_generator/app.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import gradio as gr
-from gradio.mix import Parallel
-
-ttl="Doing magic"
-desc="Generate now"
-
-model1 = gr.Interface.load("huggingface/gpt2")
-model2 = gr.Interface.load("huggingface/EleutherAI/gpt-j-6B")
-model3 = gr.Interface.load("huggingface/EleutherAI/gpt-neo-1.3B")
-
-gr.Parallel(model1, model2, model3, title=ttl, description=desc).launch()
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/_base_/models/faster_rcnn_r50_fpn.py b/spaces/Andy1621/uniformer_image_detection/configs/_base_/models/faster_rcnn_r50_fpn.py
deleted file mode 100644
index 0f038d12cb61e8b901fa47cb3bfdcf8164b3c859..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/_base_/models/faster_rcnn_r50_fpn.py
+++ /dev/null
@@ -1,107 +0,0 @@
-model = dict(
- type='FasterRCNN',
- pretrained='torchvision://resnet50',
- backbone=dict(
- type='ResNet',
- depth=50,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- norm_cfg=dict(type='BN', requires_grad=True),
- norm_eval=True,
- style='pytorch'),
- neck=dict(
- type='FPN',
- in_channels=[256, 512, 1024, 2048],
- out_channels=256,
- num_outs=5),
- rpn_head=dict(
- type='RPNHead',
- in_channels=256,
- feat_channels=256,
- anchor_generator=dict(
- type='AnchorGenerator',
- scales=[8],
- ratios=[0.5, 1.0, 2.0],
- strides=[4, 8, 16, 32, 64]),
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]),
- loss_cls=dict(
- type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
- loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
- roi_head=dict(
- type='StandardRoIHead',
- bbox_roi_extractor=dict(
- type='SingleRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[4, 8, 16, 32]),
- bbox_head=dict(
- type='Shared2FCBBoxHead',
- in_channels=256,
- fc_out_channels=1024,
- roi_feat_size=7,
- num_classes=80,
- bbox_coder=dict(
- type='DeltaXYWHBBoxCoder',
- target_means=[0., 0., 0., 0.],
- target_stds=[0.1, 0.1, 0.2, 0.2]),
- reg_class_agnostic=False,
- loss_cls=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
- loss_bbox=dict(type='L1Loss', loss_weight=1.0))),
- # model training and testing settings
- train_cfg=dict(
- rpn=dict(
- assigner=dict(
- type='MaxIoUAssigner',
- pos_iou_thr=0.7,
- neg_iou_thr=0.3,
- min_pos_iou=0.3,
- match_low_quality=True,
- ignore_iof_thr=-1),
- sampler=dict(
- type='RandomSampler',
- num=256,
- pos_fraction=0.5,
- neg_pos_ub=-1,
- add_gt_as_proposals=False),
- allowed_border=-1,
- pos_weight=-1,
- debug=False),
- rpn_proposal=dict(
- nms_pre=2000,
- max_per_img=1000,
- nms=dict(type='nms', iou_threshold=0.7),
- min_bbox_size=0),
- rcnn=dict(
- assigner=dict(
- type='MaxIoUAssigner',
- pos_iou_thr=0.5,
- neg_iou_thr=0.5,
- min_pos_iou=0.5,
- match_low_quality=False,
- ignore_iof_thr=-1),
- sampler=dict(
- type='RandomSampler',
- num=512,
- pos_fraction=0.25,
- neg_pos_ub=-1,
- add_gt_as_proposals=True),
- pos_weight=-1,
- debug=False)),
- test_cfg=dict(
- rpn=dict(
- nms_pre=1000,
- max_per_img=1000,
- nms=dict(type='nms', iou_threshold=0.7),
- min_bbox_size=0),
- rcnn=dict(
- score_thr=0.05,
- nms=dict(type='nms', iou_threshold=0.5),
- max_per_img=100)
- # soft-nms is also supported for rcnn testing
- # e.g., nms=dict(type='soft_nms', iou_threshold=0.5, min_score=0.05)
- ))
diff --git a/spaces/Andy1621/uniformer_image_detection/mmdet/datasets/pipelines/test_time_aug.py b/spaces/Andy1621/uniformer_image_detection/mmdet/datasets/pipelines/test_time_aug.py
deleted file mode 100644
index b6226e040499882c99f15594c66ebf3d07829168..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/mmdet/datasets/pipelines/test_time_aug.py
+++ /dev/null
@@ -1,119 +0,0 @@
-import warnings
-
-import mmcv
-
-from ..builder import PIPELINES
-from .compose import Compose
-
-
-@PIPELINES.register_module()
-class MultiScaleFlipAug(object):
- """Test-time augmentation with multiple scales and flipping.
-
- An example configuration is as followed:
-
- .. code-block::
-
- img_scale=[(1333, 400), (1333, 800)],
- flip=True,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='RandomFlip'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ]
-
- After MultiScaleFLipAug with above configuration, the results are wrapped
- into lists of the same length as followed:
-
- .. code-block::
-
- dict(
- img=[...],
- img_shape=[...],
- scale=[(1333, 400), (1333, 400), (1333, 800), (1333, 800)]
- flip=[False, True, False, True]
- ...
- )
-
- Args:
- transforms (list[dict]): Transforms to apply in each augmentation.
- img_scale (tuple | list[tuple] | None): Images scales for resizing.
- scale_factor (float | list[float] | None): Scale factors for resizing.
- flip (bool): Whether apply flip augmentation. Default: False.
- flip_direction (str | list[str]): Flip augmentation directions,
- options are "horizontal" and "vertical". If flip_direction is list,
- multiple flip augmentations will be applied.
- It has no effect when flip == False. Default: "horizontal".
- """
-
- def __init__(self,
- transforms,
- img_scale=None,
- scale_factor=None,
- flip=False,
- flip_direction='horizontal'):
- self.transforms = Compose(transforms)
- assert (img_scale is None) ^ (scale_factor is None), (
- 'Must have but only one variable can be setted')
- if img_scale is not None:
- self.img_scale = img_scale if isinstance(img_scale,
- list) else [img_scale]
- self.scale_key = 'scale'
- assert mmcv.is_list_of(self.img_scale, tuple)
- else:
- self.img_scale = scale_factor if isinstance(
- scale_factor, list) else [scale_factor]
- self.scale_key = 'scale_factor'
-
- self.flip = flip
- self.flip_direction = flip_direction if isinstance(
- flip_direction, list) else [flip_direction]
- assert mmcv.is_list_of(self.flip_direction, str)
- if not self.flip and self.flip_direction != ['horizontal']:
- warnings.warn(
- 'flip_direction has no effect when flip is set to False')
- if (self.flip
- and not any([t['type'] == 'RandomFlip' for t in transforms])):
- warnings.warn(
- 'flip has no effect when RandomFlip is not in transforms')
-
- def __call__(self, results):
- """Call function to apply test time augment transforms on results.
-
- Args:
- results (dict): Result dict contains the data to transform.
-
- Returns:
- dict[str: list]: The augmented data, where each value is wrapped
- into a list.
- """
-
- aug_data = []
- flip_args = [(False, None)]
- if self.flip:
- flip_args += [(True, direction)
- for direction in self.flip_direction]
- for scale in self.img_scale:
- for flip, direction in flip_args:
- _results = results.copy()
- _results[self.scale_key] = scale
- _results['flip'] = flip
- _results['flip_direction'] = direction
- data = self.transforms(_results)
- aug_data.append(data)
- # list of dict to dict of list
- aug_data_dict = {key: [] for key in aug_data[0]}
- for data in aug_data:
- for key, val in data.items():
- aug_data_dict[key].append(val)
- return aug_data_dict
-
- def __repr__(self):
- repr_str = self.__class__.__name__
- repr_str += f'(transforms={self.transforms}, '
- repr_str += f'img_scale={self.img_scale}, flip={self.flip}, '
- repr_str += f'flip_direction={self.flip_direction})'
- return repr_str
diff --git a/spaces/Andy1621/uniformer_image_detection/mmdet/models/detectors/atss.py b/spaces/Andy1621/uniformer_image_detection/mmdet/models/detectors/atss.py
deleted file mode 100644
index db7139c6b4fcd7e83007cdb785520743ddae7066..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/mmdet/models/detectors/atss.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from ..builder import DETECTORS
-from .single_stage import SingleStageDetector
-
-
-@DETECTORS.register_module()
-class ATSS(SingleStageDetector):
- """Implementation of `ATSS `_."""
-
- def __init__(self,
- backbone,
- neck,
- bbox_head,
- train_cfg=None,
- test_cfg=None,
- pretrained=None):
- super(ATSS, self).__init__(backbone, neck, bbox_head, train_cfg,
- test_cfg, pretrained)
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r50-d8_512x512_40k_voc12aug.py b/spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r50-d8_512x512_40k_voc12aug.py
deleted file mode 100644
index 8cec429c3e27ad2543b7e38fa206e6606fda4d5a..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r50-d8_512x512_40k_voc12aug.py
+++ /dev/null
@@ -1,6 +0,0 @@
-_base_ = [
- '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/pascal_voc12_aug.py',
- '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
- decode_head=dict(num_classes=21), auxiliary_head=dict(num_classes=21))
diff --git a/spaces/Arnaudding001/OpenAI_whisperLive/app-local.py b/spaces/Arnaudding001/OpenAI_whisperLive/app-local.py
deleted file mode 100644
index d8eabbc62924dab3d0cc03a8a2373ffffe01eadc..0000000000000000000000000000000000000000
--- a/spaces/Arnaudding001/OpenAI_whisperLive/app-local.py
+++ /dev/null
@@ -1,3 +0,0 @@
-# Run the app with no audio file restrictions
-from app import create_ui
-create_ui(-1)
\ No newline at end of file
diff --git a/spaces/Artrajz/vits-simple-api/vits/__init__.py b/spaces/Artrajz/vits-simple-api/vits/__init__.py
deleted file mode 100644
index 002cdc085c0977b9568c4e1a8fe3eb7d6dc61a51..0000000000000000000000000000000000000000
--- a/spaces/Artrajz/vits-simple-api/vits/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from .vits import VITS
\ No newline at end of file
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/modeline.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/modeline.py
deleted file mode 100644
index 43630835ca677066a315ac0a04d17cb6839da38d..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/pygments/modeline.py
+++ /dev/null
@@ -1,43 +0,0 @@
-"""
- pygments.modeline
- ~~~~~~~~~~~~~~~~~
-
- A simple modeline parser (based on pymodeline).
-
- :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
- :license: BSD, see LICENSE for details.
-"""
-
-import re
-
-__all__ = ['get_filetype_from_buffer']
-
-
-modeline_re = re.compile(r'''
- (?: vi | vim | ex ) (?: [<=>]? \d* )? :
- .* (?: ft | filetype | syn | syntax ) = ( [^:\s]+ )
-''', re.VERBOSE)
-
-
-def get_filetype_from_line(l):
- m = modeline_re.search(l)
- if m:
- return m.group(1)
-
-
-def get_filetype_from_buffer(buf, max_lines=5):
- """
- Scan the buffer for modelines and return filetype if one is found.
- """
- lines = buf.splitlines()
- for l in lines[-1:-max_lines-1:-1]:
- ret = get_filetype_from_line(l)
- if ret:
- return ret
- for i in range(max_lines, -1, -1):
- if i < len(lines):
- ret = get_filetype_from_line(lines[i])
- if ret:
- return ret
-
- return None
diff --git a/spaces/Atom007/SDXL-base-9-CPU/app.py b/spaces/Atom007/SDXL-base-9-CPU/app.py
deleted file mode 100644
index 239cfb2d44fee4db276096901b166addbd86daf8..0000000000000000000000000000000000000000
--- a/spaces/Atom007/SDXL-base-9-CPU/app.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import gradio as gr
-import torch
-import numpy as np
-import modin.pandas as pd
-from PIL import Image
-from diffusers import DiffusionPipeline
-from huggingface_hub import login
-import os
-
-login(token=os.environ.get('HF_KEY'))
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-0.9", add_to_git_credential=True)
-pipe = pipe.to(device)
-pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
-
-refiner = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-xl-refiner-0.9")
-refiner = refiner.to(device)
-refiner.unet = torch.compile(refiner.unet, mode="reduce-overhead", fullgraph=True)
-
-def genie (prompt, negative_prompt, scale, steps, seed):
- generator = torch.Generator(device=device).manual_seed(seed)
- int_image = pipe(prompt, negative_prompt=negative_prompt, num_inference_steps=steps, guidance_scale=scale, num_images_per_prompt=1, generator=generator, width=768, height=768, output_type="latent").images
- image = refiner(prompt=prompt, image=int_image).images[0]
- return image
-
-gr.Interface(fn=genie, inputs=[gr.Textbox(label='What you want the AI to generate. 77 Token Limit.'), gr.Textbox(label='What you Do Not want the AI-model to generate.'), gr.Slider(1, 15, 10), gr.Slider(25, maximum=50, value=25, step=1), gr.Slider(minimum=1, step=1, maximum=999999999999999999, randomize=True)], outputs='image', title="Stable Diffusion XL base 9 CPU", description="SDXL-base-9 CPU. WARNING: Extremely Slow. 65seconds/Iteration. Expected time to wait 25-50 minutes for an image of 25-50 iterations respectively.", article = "Code: Atom007").launch(debug=True, max_threads=80)
\ No newline at end of file
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/retinanet.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/retinanet.py
deleted file mode 100644
index 3ea88f61759e497ca629d1d1add43b7bd44e8072..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/meta_arch/retinanet.py
+++ /dev/null
@@ -1,439 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import math
-from typing import List, Tuple
-import torch
-from fvcore.nn import sigmoid_focal_loss_jit
-from torch import Tensor, nn
-from torch.nn import functional as F
-
-from detectron2.config import configurable
-from detectron2.layers import CycleBatchNormList, ShapeSpec, batched_nms, cat, get_norm
-from detectron2.structures import Boxes, ImageList, Instances, pairwise_iou
-from detectron2.utils.events import get_event_storage
-
-from ..anchor_generator import build_anchor_generator
-from ..backbone import Backbone, build_backbone
-from ..box_regression import Box2BoxTransform, _dense_box_regression_loss
-from ..matcher import Matcher
-from .build import META_ARCH_REGISTRY
-from .dense_detector import DenseDetector, permute_to_N_HWA_K # noqa
-
-__all__ = ["RetinaNet"]
-
-
-logger = logging.getLogger(__name__)
-
-
-@META_ARCH_REGISTRY.register()
-class RetinaNet(DenseDetector):
- """
- Implement RetinaNet in :paper:`RetinaNet`.
- """
-
- @configurable
- def __init__(
- self,
- *,
- backbone: Backbone,
- head: nn.Module,
- head_in_features,
- anchor_generator,
- box2box_transform,
- anchor_matcher,
- num_classes,
- focal_loss_alpha=0.25,
- focal_loss_gamma=2.0,
- smooth_l1_beta=0.0,
- box_reg_loss_type="smooth_l1",
- test_score_thresh=0.05,
- test_topk_candidates=1000,
- test_nms_thresh=0.5,
- max_detections_per_image=100,
- pixel_mean,
- pixel_std,
- vis_period=0,
- input_format="BGR",
- ):
- """
- NOTE: this interface is experimental.
-
- Args:
- backbone: a backbone module, must follow detectron2's backbone interface
- head (nn.Module): a module that predicts logits and regression deltas
- for each level from a list of per-level features
- head_in_features (Tuple[str]): Names of the input feature maps to be used in head
- anchor_generator (nn.Module): a module that creates anchors from a
- list of features. Usually an instance of :class:`AnchorGenerator`
- box2box_transform (Box2BoxTransform): defines the transform from anchors boxes to
- instance boxes
- anchor_matcher (Matcher): label the anchors by matching them with ground truth.
- num_classes (int): number of classes. Used to label background proposals.
-
- # Loss parameters:
- focal_loss_alpha (float): focal_loss_alpha
- focal_loss_gamma (float): focal_loss_gamma
- smooth_l1_beta (float): smooth_l1_beta
- box_reg_loss_type (str): Options are "smooth_l1", "giou", "diou", "ciou"
-
- # Inference parameters:
- test_score_thresh (float): Inference cls score threshold, only anchors with
- score > INFERENCE_TH are considered for inference (to improve speed)
- test_topk_candidates (int): Select topk candidates before NMS
- test_nms_thresh (float): Overlap threshold used for non-maximum suppression
- (suppress boxes with IoU >= this threshold)
- max_detections_per_image (int):
- Maximum number of detections to return per image during inference
- (100 is based on the limit established for the COCO dataset).
-
- pixel_mean, pixel_std: see :class:`DenseDetector`.
- """
- super().__init__(
- backbone, head, head_in_features, pixel_mean=pixel_mean, pixel_std=pixel_std
- )
- self.num_classes = num_classes
-
- # Anchors
- self.anchor_generator = anchor_generator
- self.box2box_transform = box2box_transform
- self.anchor_matcher = anchor_matcher
-
- # Loss parameters:
- self.focal_loss_alpha = focal_loss_alpha
- self.focal_loss_gamma = focal_loss_gamma
- self.smooth_l1_beta = smooth_l1_beta
- self.box_reg_loss_type = box_reg_loss_type
- # Inference parameters:
- self.test_score_thresh = test_score_thresh
- self.test_topk_candidates = test_topk_candidates
- self.test_nms_thresh = test_nms_thresh
- self.max_detections_per_image = max_detections_per_image
- # Vis parameters
- self.vis_period = vis_period
- self.input_format = input_format
-
- @classmethod
- def from_config(cls, cfg):
- backbone = build_backbone(cfg)
- backbone_shape = backbone.output_shape()
- feature_shapes = [backbone_shape[f] for f in cfg.MODEL.RETINANET.IN_FEATURES]
- head = RetinaNetHead(cfg, feature_shapes)
- anchor_generator = build_anchor_generator(cfg, feature_shapes)
- return {
- "backbone": backbone,
- "head": head,
- "anchor_generator": anchor_generator,
- "box2box_transform": Box2BoxTransform(weights=cfg.MODEL.RETINANET.BBOX_REG_WEIGHTS),
- "anchor_matcher": Matcher(
- cfg.MODEL.RETINANET.IOU_THRESHOLDS,
- cfg.MODEL.RETINANET.IOU_LABELS,
- allow_low_quality_matches=True,
- ),
- "pixel_mean": cfg.MODEL.PIXEL_MEAN,
- "pixel_std": cfg.MODEL.PIXEL_STD,
- "num_classes": cfg.MODEL.RETINANET.NUM_CLASSES,
- "head_in_features": cfg.MODEL.RETINANET.IN_FEATURES,
- # Loss parameters:
- "focal_loss_alpha": cfg.MODEL.RETINANET.FOCAL_LOSS_ALPHA,
- "focal_loss_gamma": cfg.MODEL.RETINANET.FOCAL_LOSS_GAMMA,
- "smooth_l1_beta": cfg.MODEL.RETINANET.SMOOTH_L1_LOSS_BETA,
- "box_reg_loss_type": cfg.MODEL.RETINANET.BBOX_REG_LOSS_TYPE,
- # Inference parameters:
- "test_score_thresh": cfg.MODEL.RETINANET.SCORE_THRESH_TEST,
- "test_topk_candidates": cfg.MODEL.RETINANET.TOPK_CANDIDATES_TEST,
- "test_nms_thresh": cfg.MODEL.RETINANET.NMS_THRESH_TEST,
- "max_detections_per_image": cfg.TEST.DETECTIONS_PER_IMAGE,
- # Vis parameters
- "vis_period": cfg.VIS_PERIOD,
- "input_format": cfg.INPUT.FORMAT,
- }
-
- def forward_training(self, images, features, predictions, gt_instances):
- # Transpose the Hi*Wi*A dimension to the middle:
- pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(
- predictions, [self.num_classes, 4]
- )
- anchors = self.anchor_generator(features)
- gt_labels, gt_boxes = self.label_anchors(anchors, gt_instances)
- return self.losses(anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes)
-
- def losses(self, anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes):
- """
- Args:
- anchors (list[Boxes]): a list of #feature level Boxes
- gt_labels, gt_boxes: see output of :meth:`RetinaNet.label_anchors`.
- Their shapes are (N, R) and (N, R, 4), respectively, where R is
- the total number of anchors across levels, i.e. sum(Hi x Wi x Ai)
- pred_logits, pred_anchor_deltas: both are list[Tensor]. Each element in the
- list corresponds to one level and has shape (N, Hi * Wi * Ai, K or 4).
- Where K is the number of classes used in `pred_logits`.
-
- Returns:
- dict[str, Tensor]:
- mapping from a named loss to a scalar tensor storing the loss.
- Used during training only. The dict keys are: "loss_cls" and "loss_box_reg"
- """
- num_images = len(gt_labels)
- gt_labels = torch.stack(gt_labels) # (N, R)
-
- valid_mask = gt_labels >= 0
- pos_mask = (gt_labels >= 0) & (gt_labels != self.num_classes)
- num_pos_anchors = pos_mask.sum().item()
- get_event_storage().put_scalar("num_pos_anchors", num_pos_anchors / num_images)
- normalizer = self._ema_update("loss_normalizer", max(num_pos_anchors, 1), 100)
-
- # classification and regression loss
- gt_labels_target = F.one_hot(gt_labels[valid_mask], num_classes=self.num_classes + 1)[
- :, :-1
- ] # no loss for the last (background) class
- loss_cls = sigmoid_focal_loss_jit(
- cat(pred_logits, dim=1)[valid_mask],
- gt_labels_target.to(pred_logits[0].dtype),
- alpha=self.focal_loss_alpha,
- gamma=self.focal_loss_gamma,
- reduction="sum",
- )
-
- loss_box_reg = _dense_box_regression_loss(
- anchors,
- self.box2box_transform,
- pred_anchor_deltas,
- gt_boxes,
- pos_mask,
- box_reg_loss_type=self.box_reg_loss_type,
- smooth_l1_beta=self.smooth_l1_beta,
- )
-
- return {
- "loss_cls": loss_cls / normalizer,
- "loss_box_reg": loss_box_reg / normalizer,
- }
-
- @torch.no_grad()
- def label_anchors(self, anchors, gt_instances):
- """
- Args:
- anchors (list[Boxes]): A list of #feature level Boxes.
- The Boxes contains anchors of this image on the specific feature level.
- gt_instances (list[Instances]): a list of N `Instances`s. The i-th
- `Instances` contains the ground-truth per-instance annotations
- for the i-th input image.
-
- Returns:
- list[Tensor]: List of #img tensors. i-th element is a vector of labels whose length is
- the total number of anchors across all feature maps (sum(Hi * Wi * A)).
- Label values are in {-1, 0, ..., K}, with -1 means ignore, and K means background.
-
- list[Tensor]: i-th element is a Rx4 tensor, where R is the total number of anchors
- across feature maps. The values are the matched gt boxes for each anchor.
- Values are undefined for those anchors not labeled as foreground.
- """
- anchors = Boxes.cat(anchors) # Rx4
-
- gt_labels = []
- matched_gt_boxes = []
- for gt_per_image in gt_instances:
- match_quality_matrix = pairwise_iou(gt_per_image.gt_boxes, anchors)
- matched_idxs, anchor_labels = self.anchor_matcher(match_quality_matrix)
- del match_quality_matrix
-
- if len(gt_per_image) > 0:
- matched_gt_boxes_i = gt_per_image.gt_boxes.tensor[matched_idxs]
-
- gt_labels_i = gt_per_image.gt_classes[matched_idxs]
- # Anchors with label 0 are treated as background.
- gt_labels_i[anchor_labels == 0] = self.num_classes
- # Anchors with label -1 are ignored.
- gt_labels_i[anchor_labels == -1] = -1
- else:
- matched_gt_boxes_i = torch.zeros_like(anchors.tensor)
- gt_labels_i = torch.zeros_like(matched_idxs) + self.num_classes
-
- gt_labels.append(gt_labels_i)
- matched_gt_boxes.append(matched_gt_boxes_i)
-
- return gt_labels, matched_gt_boxes
-
- def forward_inference(
- self, images: ImageList, features: List[Tensor], predictions: List[List[Tensor]]
- ):
- pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(
- predictions, [self.num_classes, 4]
- )
- anchors = self.anchor_generator(features)
-
- results: List[Instances] = []
- for img_idx, image_size in enumerate(images.image_sizes):
- scores_per_image = [x[img_idx].sigmoid_() for x in pred_logits]
- deltas_per_image = [x[img_idx] for x in pred_anchor_deltas]
- results_per_image = self.inference_single_image(
- anchors, scores_per_image, deltas_per_image, image_size
- )
- results.append(results_per_image)
- return results
-
- def inference_single_image(
- self,
- anchors: List[Boxes],
- box_cls: List[Tensor],
- box_delta: List[Tensor],
- image_size: Tuple[int, int],
- ):
- """
- Single-image inference. Return bounding-box detection results by thresholding
- on scores and applying non-maximum suppression (NMS).
-
- Arguments:
- anchors (list[Boxes]): list of #feature levels. Each entry contains
- a Boxes object, which contains all the anchors in that feature level.
- box_cls (list[Tensor]): list of #feature levels. Each entry contains
- tensor of size (H x W x A, K)
- box_delta (list[Tensor]): Same shape as 'box_cls' except that K becomes 4.
- image_size (tuple(H, W)): a tuple of the image height and width.
-
- Returns:
- Same as `inference`, but for only one image.
- """
- pred = self._decode_multi_level_predictions(
- anchors,
- box_cls,
- box_delta,
- self.test_score_thresh,
- self.test_topk_candidates,
- image_size,
- )
- keep = batched_nms( # per-class NMS
- pred.pred_boxes.tensor, pred.scores, pred.pred_classes, self.test_nms_thresh
- )
- return pred[keep[: self.max_detections_per_image]]
-
-
-class RetinaNetHead(nn.Module):
- """
- The head used in RetinaNet for object classification and box regression.
- It has two subnets for the two tasks, with a common structure but separate parameters.
- """
-
- @configurable
- def __init__(
- self,
- *,
- input_shape: List[ShapeSpec],
- num_classes,
- num_anchors,
- conv_dims: List[int],
- norm="",
- prior_prob=0.01,
- ):
- """
- NOTE: this interface is experimental.
-
- Args:
- input_shape (List[ShapeSpec]): input shape
- num_classes (int): number of classes. Used to label background proposals.
- num_anchors (int): number of generated anchors
- conv_dims (List[int]): dimensions for each convolution layer
- norm (str or callable):
- Normalization for conv layers except for the two output layers.
- See :func:`detectron2.layers.get_norm` for supported types.
- prior_prob (float): Prior weight for computing bias
- """
- super().__init__()
-
- self._num_features = len(input_shape)
- if norm == "BN" or norm == "SyncBN":
- logger.info(
- f"Using domain-specific {norm} in RetinaNetHead with len={self._num_features}."
- )
- bn_class = nn.BatchNorm2d if norm == "BN" else nn.SyncBatchNorm
-
- def norm(c):
- return CycleBatchNormList(
- length=self._num_features, bn_class=bn_class, num_features=c
- )
-
- else:
- norm_name = str(type(get_norm(norm, 1)))
- if "BN" in norm_name:
- logger.warning(
- f"Shared BatchNorm (type={norm_name}) may not work well in RetinaNetHead."
- )
-
- cls_subnet = []
- bbox_subnet = []
- for in_channels, out_channels in zip(
- [input_shape[0].channels] + list(conv_dims), conv_dims
- ):
- cls_subnet.append(
- nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
- )
- if norm:
- cls_subnet.append(get_norm(norm, out_channels))
- cls_subnet.append(nn.ReLU())
- bbox_subnet.append(
- nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
- )
- if norm:
- bbox_subnet.append(get_norm(norm, out_channels))
- bbox_subnet.append(nn.ReLU())
-
- self.cls_subnet = nn.Sequential(*cls_subnet)
- self.bbox_subnet = nn.Sequential(*bbox_subnet)
- self.cls_score = nn.Conv2d(
- conv_dims[-1], num_anchors * num_classes, kernel_size=3, stride=1, padding=1
- )
- self.bbox_pred = nn.Conv2d(
- conv_dims[-1], num_anchors * 4, kernel_size=3, stride=1, padding=1
- )
-
- # Initialization
- for modules in [self.cls_subnet, self.bbox_subnet, self.cls_score, self.bbox_pred]:
- for layer in modules.modules():
- if isinstance(layer, nn.Conv2d):
- torch.nn.init.normal_(layer.weight, mean=0, std=0.01)
- torch.nn.init.constant_(layer.bias, 0)
-
- # Use prior in model initialization to improve stability
- bias_value = -(math.log((1 - prior_prob) / prior_prob))
- torch.nn.init.constant_(self.cls_score.bias, bias_value)
-
- @classmethod
- def from_config(cls, cfg, input_shape: List[ShapeSpec]):
- num_anchors = build_anchor_generator(cfg, input_shape).num_cell_anchors
- assert (
- len(set(num_anchors)) == 1
- ), "Using different number of anchors between levels is not currently supported!"
- num_anchors = num_anchors[0]
-
- return {
- "input_shape": input_shape,
- "num_classes": cfg.MODEL.RETINANET.NUM_CLASSES,
- "conv_dims": [input_shape[0].channels] * cfg.MODEL.RETINANET.NUM_CONVS,
- "prior_prob": cfg.MODEL.RETINANET.PRIOR_PROB,
- "norm": cfg.MODEL.RETINANET.NORM,
- "num_anchors": num_anchors,
- }
-
- def forward(self, features: List[Tensor]):
- """
- Arguments:
- features (list[Tensor]): FPN feature map tensors in high to low resolution.
- Each tensor in the list correspond to different feature levels.
-
- Returns:
- logits (list[Tensor]): #lvl tensors, each has shape (N, AxK, Hi, Wi).
- The tensor predicts the classification probability
- at each spatial position for each of the A anchors and K object
- classes.
- bbox_reg (list[Tensor]): #lvl tensors, each has shape (N, Ax4, Hi, Wi).
- The tensor predicts 4-vector (dx,dy,dw,dh) box
- regression values for every anchor. These values are the
- relative offset between the anchor and the ground truth box.
- """
- assert len(features) == self._num_features
- logits = []
- bbox_reg = []
- for feature in features:
- logits.append(self.cls_score(self.cls_subnet(feature)))
- bbox_reg.append(self.bbox_pred(self.bbox_subnet(feature)))
- return logits, bbox_reg
diff --git a/spaces/BWQ/Chatgpt/README.md b/spaces/BWQ/Chatgpt/README.md
deleted file mode 100644
index 57a5c8ff85300c38dc94b710d473a8dfbffdc5e1..0000000000000000000000000000000000000000
--- a/spaces/BWQ/Chatgpt/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Chatgpt
-emoji: 🌍
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/BasalGanglia/stabilityai-stable-diffusion-2/app.py b/spaces/BasalGanglia/stabilityai-stable-diffusion-2/app.py
deleted file mode 100644
index d2782cea00b1bfcd22df7c204d9e52a6baf46ac2..0000000000000000000000000000000000000000
--- a/spaces/BasalGanglia/stabilityai-stable-diffusion-2/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/stabilityai/stable-diffusion-2").launch()
\ No newline at end of file
diff --git a/spaces/Benson/text-generation/Examples/Artesana Y Construccin.md b/spaces/Benson/text-generation/Examples/Artesana Y Construccin.md
deleted file mode 100644
index 36c965b2d5147f883ddce858ca7e9bc2cc8f336d..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Artesana Y Construccin.md
+++ /dev/null
@@ -1,163 +0,0 @@
-
-Arte y Construcción: Una Guía para Principiantes
-¿Te gustan los juegos de construcción? ¿Quieres crear tu propia casa o castillo o la mía? ¿Quieres explorar un vasto mundo lleno de sorpresas y aventuras? Si respondiste sí a cualquiera de estas preguntas, ¡deberías probar con juegos de manualidades y construcción!
-Los juegos de manualidades y construcción son un género de videojuegos que te permiten crear cualquier cosa que puedas imaginar usando varios bloques y elementos. También puede explorar diferentes mundos e interactuar con otros jugadores en línea o fuera de línea. Los juegos de manualidades y construcción son divertidos y populares porque te permiten expresar tu creatividad e imaginación en un entorno virtual.
-artesanía y construcción
Download File ---> https://bltlly.com/2v6JZS
-Pero ¿cuáles son los beneficios de jugar a juegos de manualidades y construcción? Bueno, aquí están algunos de ellos:
-
-- Mejoran tus habilidades espaciales y de resolución de problemas.
-- Mejoran tu capacidad de atención y concentración.
-- Estimulan el cerebro y la memoria.
-- Fomentan tus habilidades de trabajo en equipo y comunicación.
-- Relajan tu mente y estado de ánimo.
-
-Así que si usted está interesado en el arte y la construcción de juegos, pero no saben por dónde empezar o cómo jugar, no se preocupe! ¡Este artículo le guiará a través de los fundamentos de los juegos de artesanía y construcción y le ayudará a construir su casa de ensueño en ningún momento!
- Cómo empezar a crear y construir
-Elegir un juego
-Lo primero que tienes que hacer es elegir un juego que se adapte a tus preferencias e intereses. Hay muchos juegos de manualidades y construcción disponibles en diferentes plataformas, como PC, móvil, consola, etc. Algunos de los más populares son:
-
-- Elaboración y construcción : Este es un juego gratuito para dispositivos Android que te permite construir tu propio mundo con recursos ilimitados. También puedes explorar diferentes mapas, como ciudad, bosque, desierto, etc. También puedes personalizar tu personaje y jugar con tus amigos online.
-
-- Minecraft: Este es el juego de artesanía y construcción más famoso y popular del mundo. Está disponible en PC, móvil, consola y otras plataformas. Puedes crear tu propio mundo con diferentes modos, como supervivencia, creatividad, aventura, etc. También puedes explorar un mundo enorme con diferentes biomas, animales, pueblos, mazmorras, etc. También puedes jugar con millones de jugadores online o offline.
-
-Hay muchos otros juegos de artesanía y construcción que puedes probar, como Roblox, Terraria, Stardew Valley, etc. Cada juego tiene sus propias características y ventajas. Puedes elegir el que más te guste y se ajuste a tu presupuesto y dispositivo.
-Para principiantes, recomendamos Elaboración y Construcción o Artesano: Construcción de Artesanía porque son libres y fáciles de jugar en dispositivos móviles. También tienen muchos recursos y mapas para elegir. Sin embargo, si quieres una experiencia más avanzada e inmersiva, puedes probar Minecraft, que tiene más opciones y desafíos.
- Aprender lo básico
-Una vez que hayas elegido un juego, necesitas aprender los fundamentos de cómo jugarlo. Los conceptos básicos incluyen cómo controlar a tu personaje, cómo acceder a los menús, cómo usar las herramientas y los bloques, etc. Cada juego tiene su propio tutorial o guía que puedes seguir para aprender lo básico. También puede ver algunos videos o leer algunos artículos en línea para obtener algunos consejos y trucos.
-Aquí hay algunos consejos generales sobre cómo aprender los fundamentos de los juegos de artesanía y construcción:
-
-
-- Usa la pantalla táctil o el teclado y el ratón para mover a tu personaje. También puedes usar los botones o las teclas para saltar, agacharse, volar, etc.
-- Utilice el menú o el inventario para acceder a sus herramientas y bloques. También puede usar los botones o teclas para cambiar entre ellos.
-- Usa las herramientas y los bloques para crear o destruir cualquier cosa en el mundo. También puedes usar los botones o teclas para colocarlos o romperlos.
-
-- Usa la ayuda o el icono de interrogación para obtener más información sobre las características y funciones del juego.
-
-Aquí hay algunas capturas de pantalla o videos que muestran cómo jugar Crafting y BuildingCraftsman: Building Craft :
)
img src=( 5 )" =alt"Craftsman: Building Craft screenshot" width="300" height="200">
-Como puedes ver, ambos juegos tienen gráficos y jugabilidad similares, pero tienen algunas diferencias en los mapas, elementos y modos. Puedes probar ambos juegos y ver cuál te gusta más.
- Encontrar una ubicación
-Después de haber aprendido los fundamentos del juego, es necesario encontrar una ubicación para su edificio. La ubicación es importante porque afecta el estilo, el tamaño y la forma de su edificio. También debe considerar el medio ambiente, los recursos y los peligros a su alrededor.
-Cada juego tiene diferentes mundos o mapas que puedes explorar. Algunos de ellos son generados aleatoriamente, mientras que otros son pre-hechos. Algunos de ellos se basan en lugares de la vida real, mientras que otros son ficticios o de fantasía. Algunos de ellos son planos y simples, mientras que otros son complejos y diversos.
-Aquí hay algunos ejemplos de diferentes biomas o terrenos que puedes encontrar en juegos de artesanía y construcción:
-
-- Bosque: Este es un bioma que tiene muchos árboles, hierba, flores y animales. Es un buen lugar para encontrar madera y comida. También es un lugar hermoso y tranquilo para construir su casa.
-- Desierto: Este es un bioma que tiene mucha arena, cactus y arbustos muertos. Es un buen lugar para encontrar arenisca y vidrio. También es un lugar desafiante y caliente para construir su casa.
-- Nieve: Este es un bioma que tiene mucha nieve, hielo y muñecos de nieve. Es un buen lugar para encontrar bolas de nieve y bloques de hielo. También es un lugar frío y festivo para construir su casa.
-
-- Ocean: Este es un bioma que tiene mucha agua, coral y peces. Es un buen lugar para encontrar prismarinas y linternas de mar. También es un lugar húmedo y aventurero para construir su casa.
-
-Puedes elegir cualquier bioma o terreno que te guste para tu edificio. También puede mezclar y combinar diferentes biomas o terrenos para crear su propio mundo único. ¡El único límite es su imaginación!
Cómo crear y construir la casa de tus sueños
-Planificación de su diseño
-Ahora que ha encontrado una ubicación para su edificio, debe planificar su diseño antes de comenzar a construir. Planificar su diseño le ayudará a ahorrar tiempo, recursos y esfuerzo. También le ayudará a crear una casa más hermosa y funcional.
-Aquí hay algunos pasos sobre cómo planificar su diseño:
-
-- Dibuja tu idea: Puedes usar un papel y un lápiz o una aplicación digital para esbozar tu idea de cómo quieres que se vea tu casa. Puede dibujar la forma, el tamaño, el estilo y el color de su casa. También puede agregar algunos detalles, como ventanas, puertas, techo, etc.
-- Mide tu espacio: Puedes usar una regla o una cinta métrica para medir tu espacio en el juego. También puede utilizar los bloques como unidad de medida. Por ejemplo, un bloque es igual a un metro. A continuación, puede calcular cuántos bloques necesita para cada parte de su casa.
-- Elige un tema: Puedes elegir un tema para tu casa que coincida con tu personalidad y preferencia. Un tema es una idea o concepto general que guía su diseño. Por ejemplo, puede elegir un tema moderno, un tema medieval, un tema de fantasía, etc. También puede elegir un esquema de color que complemente su tema.
-
-Aquí hay algunos ejemplos de diferentes temas y esquemas de color para juegos de artesanía y construcción:
-
-
-| Tema |
-Esquema de colores |
-
-
-| Moderno |
-Blanco, negro, gris, azul, etc. |
-
-
-
-| Marrón, beige, verde, rojo, etc. |
-
-
-| Fantasía |
-Púrpura, rosa, amarillo, naranja, etc. |
-
-
- Recopilación de recursos
-Después de haber planeado su diseño, necesita reunir recursos para construir. Los recursos son los materiales que utilizas para crear o crear objetos y bloques en el juego. Puedes encontrar recursos en diferentes lugares del mundo del juego, como árboles, rocas, minerales, plantas, etc.
-Aquí hay algunos consejos sobre cómo reunir recursos:
-
-- Mine them: Puede utilizar herramientas como picos, ejes, palas, etc. para extraer recursos de la tierra o el medio ambiente. También puede usar explosivos como TNT o dinamita para detonarlos. Tenga cuidado de no dañar su entorno o usted mismo.
-- Craft them: Puedes usar recursos que hayas extraído o recopilado para crear otros recursos que necesites. Puedes usar mesas de manualidades u otros dispositivos para crear objetos y bloques en el juego. También puedes usar recetas o planos para guiarte.
-- Guárdelos: Puede usar contenedores como cofres, barriles, cajas, etc. para almacenar sus recursos en el juego. También puede usar etiquetas o letreros para organizarlos. Puede colocar sus contenedores cerca de su sitio de construcción o en un lugar seguro.
-
- Construyendo su estructura
Después de haber reunido suficientes recursos, puede comenzar a construir su estructura. Su estructura es la parte principal de su casa que define su forma y tamaño. Puede construir su estructura paso a paso, a partir de la base, luego las paredes, luego el techo, etc.
-Aquí hay algunos consejos sobre cómo construir su estructura:
-
-- Echa los cimientos: Puedes usar bloques como piedra, ladrillo, hormigón, etc. para poner los cimientos de tu casa. También puedes usar bloques como hierba, tierra, arena, etc. para nivelar el suelo. Puedes usar una cuadrícula o un plano para guiarte.
-
-- Construye el techo: Puedes usar bloques como madera, piedra, ladrillo, vidrio, etc. para construir el techo de tu casa. También puede utilizar bloques como escaleras, losas, vallas, etc. para crear diferentes pendientes y ángulos. También puede añadir tragaluces y chimeneas a su techo.
-
-Aquí hay algunas capturas de pantalla o videos que le muestran cómo construir su estructura en Elaboración y construcción o Craftsman: Building Craft :
-![Crafting and Building video]()
![Craftsman: Building Craft video]()
![Craftsman: Building Craft screenshot]()
![Craftsman: Building Craft video]()
![Craftsman: Building Craft screenshot]()
https://bltlly.com/2v6JsS
-Bus Simulator Ultimate es un juego que te permite crear tu propia compañía de autobuses y operar rutas a través de varios países, como Alemania, Turquía, Italia, Francia, España y más. Puede personalizar sus autobuses, contratar conductores, administrar sus ingresos y gastos, e interactuar con los pasajeros y otros conductores. También puede conducir su autobús en diferentes condiciones climáticas, situaciones de tráfico y eventos en la carretera.
-En este artículo, le diremos todo lo que necesita saber sobre Bus Simulator Ultimate, incluidas sus características, cómo descargarlo e instalarlo en su dispositivo Android usando happymod, por qué debe elegir la versión happymod y algunos consejos y trucos para jugar el juego. ¡Vamos a empezar!
- ¿Qué es Bus Simulator Ultimate?
-Bus Simulator Ultimate es un juego de simulación desarrollado por Zuuks Games, un estudio de juegos turco que también creó otros juegos populares como Truck Simulator 2018: Europe y Euro Truck Driver 2018. El juego fue lanzado en agosto de 2019 y desde entonces ha sido descargado más de 50 millones de veces en Google Play Store. También ha recibido críticas positivas de jugadores y críticos, que elogiaron sus gráficos, jugabilidad y realismo.
-Como su nombre indica, Bus Simulator Ultimate es un juego que simula la experiencia de conducir un autobús y gestionar una empresa de autobuses. Puede elegir entre más de 30 autobuses diferentes, cada uno con sus propias especificaciones y características. También puede diseñar sus propios autobuses cambiando sus colores, pieles, interiores y accesorios.
-
-Puede conducir su autobús en entornos 3D realistas que se basan en ubicaciones reales. Verá monumentos, edificios, puentes y paisajes famosos mientras conduce. También encontrará diferentes condiciones climáticas, como lluvia, nieve, niebla y noche. Usted tendrá que seguir las reglas de tráfico y señales, evitar accidentes y violaciones, y respetar los límites de velocidad. También tendrá que interactuar con sus pasajeros y otros conductores a través de un sistema de radio.
-
- Características de Bus Simulator Ultimate
-Bus Simulator Ultimate es un juego que ofrece muchas características que lo hacen divertido y atractivo. Algunas de estas características son:
-
-- Modo multijugador: Puedes jugar online con tus amigos u otros jugadores de todo el mundo. Puede unirse o crear un convoy y conducir juntos en la misma ruta. También puede chatear con otros jugadores utilizando la función de chat de voz o texto.
-- Sistema de radio: Puede escuchar varias estaciones de radio que reproducen música, noticias, deportes y más. También puede crear su propia estación de radio agregando sus canciones favoritas desde su dispositivo.
-- Sonidos realistas: Puede escuchar los sonidos realistas de su motor de autobús, bocina, frenos, limpiaparabrisas, puertas y más. También puede escuchar los sonidos del tráfico, el clima, los pasajeros y otros conductores.
-- Sistema de retroalimentación: Puede obtener retroalimentación de sus pasajeros y conductores en función de su rendimiento. Te evaluarán en diferentes aspectos, como habilidades de conducción, seguridad, comodidad, puntualidad y servicio. También puedes ver sus comentarios y sugerencias sobre cómo mejorar tu negocio.
-- Logros y tablas de clasificación: Puedes desbloquear varios logros completando ciertas tareas o objetivos en el juego. También puedes ver tu rango y progreso en las tablas de clasificación globales y regionales.
-
- Cómo descargar Cómo descargar e instalar Bus Simulator Ultimate son sürüm apk happymod
-
-
Descargar e instalar Bus Simulator Ultimate son sürüm apk happymod es muy fácil y simple. Solo tienes que seguir estos pasos:
-
-- Ir al sitio web oficial de happymod o la tienda de aplicaciones Uptodown y buscar Bus Simulator Ultimate.
-- Seleccione la última versión del juego y haga clic en el botón de descarga. Verá una ventana emergente pidiéndole que confirme la descarga. Haga clic en Aceptar.
-- Espere a que la descarga termine y luego abra el archivo apk. Es posible que necesite habilitar la instalación desde fuentes desconocidas en la configuración del dispositivo.
-- Siga las instrucciones en la pantalla e instale el juego en su dispositivo.
-- Iniciar el juego y disfrutar de Bus Simulator Ultimate son sürüm apk happymod!
-
¿Por qué elegir Bus Simulator Ultimate son sürüm apk happymod?
-Como mencionamos anteriormente, Bus Simulator Ultimate son sürüm apk happymod es una versión modificada del juego que le da más ventajas y características que la versión original. Estas son algunas de las razones por las que debería elegir esta versión:
-
-- Dinero ilimitado: Puedes obtener dinero ilimitado en el juego, que puedes usar para comprar nuevos autobuses, actualizar los existentes, contratar más conductores, expandir tus rutas y más. También puede gastar su dinero en otras cosas, como combustible, mantenimiento, impuestos y salarios.
-- Autobuses desbloqueados: Puede desbloquear todos los autobuses en el juego, que normalmente están disponibles solo después de completar ciertos niveles o pagar dinero real. Puede elegir entre más de 30 autobuses diferentes, cada uno con sus propias especificaciones y características. También puede personalizar sus autobuses como desee.
-- Compras gratis: Puedes comprar cualquier cosa en el juego sin gastar dinero. Puede comprar nuevas pieles, interiores, accesorios y más para sus autobuses. También puede comprar regalos para sus pasajeros y conductores para aumentar su satisfacción y lealtad.
-
-
-Estos son solo algunos de los beneficios de usar Bus Simulator Ultimate son sürüm apk happymod. Hay muchas más características y opciones que puedes descubrir y disfrutar jugando el juego tú mismo.
- Consejos y trucos para jugar Bus Simulator Ultimate
-Bus Simulator Ultimate es un juego que requiere habilidad, estrategia y paciencia. No se trata solo de conducir un autobús, sino también de gestionar una empresa de autobuses y satisfacer a sus clientes. Aquí hay algunos consejos y trucos que pueden ayudarte a jugar mejor:
-
-- Planifique sus rutas cuidadosamente: Antes de comenzar una ruta, debe revisar el mapa y ver la distancia, el tráfico, el clima y las condiciones de la carretera. También debe considerar la demanda y las preferencias de sus pasajeros. Debe elegir una ruta que sea rentable, segura y cómoda para usted y sus clientes.
-- Conduzca con seguridad y sin problemas: Cuando conduzca su autobús, debe seguir las reglas de tráfico y las señales, evitar accidentes y violaciones, y respetar los límites de velocidad. También debe conducir sin problemas y evitar el frenado repentino o la aceleración. Esto mejorará sus habilidades de conducción, seguridad, comodidad, puntualidad y calificaciones de servicio.
-- Interactuar con sus pasajeros y conductores: Debe comunicarse con sus pasajeros y conductores a través del sistema de radio. Debe saludarlos, informarles sobre la ruta y el destino, agradecerles por elegir su empresa y disculparse por cualquier inconveniente o retraso. También debe escuchar sus comentarios y sugerencias sobre cómo mejorar su servicio.
-- Actualizar sus autobuses y la empresa: Usted debe invertir su dinero en la mejora de sus autobuses y la empresa. Deberías comprar nuevos autobuses, mejorar los existentes, contratar más conductores, expandir tus rutas y más. Esto aumentará sus ingresos, cuota de mercado, satisfacción del cliente y reputación.
-
- Conclusión
-
-Si desea disfrutar de Bus Simulator Ultimate con más características y beneficios, debe descargar e instalar la versión apk happymod son sürüm. Esta es una versión modificada del juego que le da acceso a dinero ilimitado, autobuses desbloqueados, compras gratuitas y más. También puede deshacerse de los anuncios y disfrutar de descargas más rápidas con happymod.
-Esperamos que este artículo le ha ayudado a aprender más acerca de Bus Simulator Ultimate son sürüm apk happymod. Si tiene alguna pregunta o comentario, por favor siéntase libre de dejarlos abajo. ¡Gracias por leer!
- Preguntas frecuentes
-Aquí están algunas de las preguntas más frecuentes sobre Bus Simulator Ultimate son sürüm apk happymod:
-
-- ¿Es seguro usar Bus Simulator Ultimate son sürüm apk happymod?
-Sí, Bus Simulator Ultimate son sürüm apk happymod es seguro de usar siempre y cuando se descarga de una fuente de confianza como happymod o Uptodown. Estas fuentes escanean los archivos apk en busca de virus y malware antes de subirlos a sus sitios web. Sin embargo, siempre debe tener cuidado al descargar cualquier archivo de Internet y verificar sus permisos antes de instalarlo en su dispositivo. ¿Cuáles son los requisitos para jugar Bus Simulator Ultimate son sürüm apk happymod?
-Para jugar Bus Simulator Ultimate son sürüm apk happymod, es necesario tener un dispositivo Android que se ejecuta en Android 5.0 o superior. También necesita tener al menos 1 GB de RAM y 500 MB de espacio de almacenamiento gratuito. También es posible que necesite una conexión a Internet para jugar en línea o acceder a algunas características del juego.
-- ¿Cómo puedo actualizar Bus Simulator Ultimate son sürüm apk happymod?
-Para actualizar Bus Simulator Ultimate son sürüm apk happymod, es necesario visitar el sitio web de happymod o Uptodown y descargar la última versión del juego. A continuación, puede instalarlo sobre la versión existente en su dispositivo. Es posible que necesite habilitar la instalación desde fuentes desconocidas en la configuración del dispositivo.
-
-Sí, se puede jugar Bus Simulator Ultimate son sürüm apk happymod en el PC con un emulador de Android. Un emulador de Android es un software que le permite ejecutar aplicaciones y juegos de Android en su PC. Algunos de los emuladores populares de Android son BlueStacks, NoxPlayer y LDPlayer. Puede descargar e instalar cualquiera de estos emuladores en su PC y luego descargar e instalar Bus Simulator Ultimate son sürüm apk happymod de happymod o Uptodown.
-- ¿Puedo transferir mi progreso desde la versión original de Bus Simulator Ultimate a la versión happymod?
-Desafortunadamente, no. No puede transferir su progreso desde la versión original de Bus Simulator Ultimate a la versión happymod. La versión happymod es una versión modificada del juego que tiene diferentes archivos y datos que la versión original. Por lo tanto, tendrá que empezar desde cero si cambia a la versión happymod.
-
64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Benson/text-generation/Examples/Ciudad Smash Descarga Gratuita Apk.md b/spaces/Benson/text-generation/Examples/Ciudad Smash Descarga Gratuita Apk.md
deleted file mode 100644
index 5192f333d12f1d1010e859422e40bc8f1757da27..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Ciudad Smash Descarga Gratuita Apk.md
+++ /dev/null
@@ -1,62 +0,0 @@
-
-
- Dos métodos para descargar archivos APK de Google Play Store: utilizando una herramienta web o una aplicación extractora de APK.
- Cómo instalar archivos APK en dispositivos Android. | | H2: Cómo descargar muy pequeñas pesadillas 2 APK de Google Play Store | - Cómo utilizar APK Mirror o Evozi’s APK Downloader para generar y guardar el archivo APK para Very Little Nightmares 2.
- Cómo utilizar App APK Extractor & Analyzer para extraer el archivo APK de la aplicación instalada. | | H2: Cómo descargar muy pequeñas pesadillas 2 APK de tiendas de aplicaciones alternativas | - Cómo utilizar Aptoide o APKPure para encontrar y descargar el archivo APK para Very Little Nightmares 2.
- Cómo comprobar la seguridad y compatibilidad del archivo APK antes de instalarlo. | | H2: Conclusión y preguntas frecuentes | - Resumen de los principales puntos y consejos para descargar Muy Pequeñas Pesadillas 2 APK.
- Cinco preguntas frecuentes únicas con respuestas. | Tabla 2: Artículo con formato HTML Cómo descargar pesadillas muy pequeñas 2 APK
-Si eres un fan de los juegos de aventura de terror, es posible que hayas oído hablar de Very Little Nightmares 2, una secuela del popular juego Little Nightmares. En este juego, juegas como Mono, un joven que tiene que escapar de un mundo retorcido que está controlado por una torre de señal misteriosa. En el camino, te encontrarás con muchas criaturas aterradoras y rompecabezas que pondrán a prueba tu coraje e ingenio.
-Very Little Nightmares 2 está disponible en Steam, PlayStation, Xbox, Nintendo Switch y Google Play Store. Sin embargo, si quieres descargar el juego como un archivo APK, necesitarás usar algunos métodos alternativos. En este artículo, le mostraremos cómo descargar Very Little Nightmares 2 APK de diferentes fuentes y cómo instalarlo en su dispositivo Android.
-ciudad smash descarga gratuita apk
DOWNLOAD ⇔ https://bltlly.com/2v6Lfe
- ¿Qué es un archivo APK y cómo descargarlo
-
-Para descargar archivos APK, hay varios métodos. Una forma es ir a APK Mirror en su dispositivo Android a través de Chrome u otro navegador, buscar la aplicación que desee, y toque en 'Descargar APK'. Otra forma es utilizar un APK downloader web, como un
-Para instalar un archivo APK en tu Android, descarga el archivo usando el navegador predeterminado, Chrome, y acepta cualquier ventana emergente. Es importante descargar solo archivos APK de fuentes confiables y hacer una búsqueda rápida en Google para verificar la reputación de la aplicación o empresa.
- Cómo descargar muy pequeñas pesadillas 2 APK de Google Play Store
-Si quieres obtener la versión oficial de Very Little Nightmares 2 de Google Play Store, puedes usar uno de estos dos métodos:
-Método 1: Usar una herramienta web
-
-- Abra el Google Play Store en su dispositivo Android o computadora y busque Very Little Nightmares 2.
-- Copiar la URL de la aplicación desde la barra de direcciones.
-- Ir a Evozi’s APK Downloader en un navegador web y pegar la URL en el cuadro en la parte superior.
-- Seleccione un tipo de dispositivo en el menú desplegable "Dispositivo" y haga clic en el botón "Generar enlace de descarga".
-- Haga clic en el verde "Haga clic aquí para descargar Very Little Nightmares 2 APK" botón y guardar el archivo en su dispositivo u ordenador.
-
-Método 2: Usar una aplicación APK Extractor
-
-- Descargar e instalar App APK Extractor & Analyzer desde la Google Play Store en su dispositivo Android.
-- Abra la aplicación y otorgue los permisos necesarios para acceder a sus archivos y aplicaciones.
-- Encuentra muy pequeñas pesadillas 2 en la lista de aplicaciones instaladas y toque en él.
-
-- Transfiera el archivo a otro dispositivo u ordenador si lo desea.
-
- Cómo descargar muy pequeñas pesadillas 2 APK de tiendas de aplicaciones alternativas
-Si no puedes encontrar Very Little Nightmares 2 en Google Play Store, o quieres probar una versión diferente del juego, puedes usar una de estas tiendas de aplicaciones alternativas:
-Aptoide
-Aptoide es una popular tienda de aplicaciones que ofrece millones de aplicaciones y juegos gratis. Puede descargar Aptoide desde su sitio web oficial o desde otras fuentes. Para descargar Very Little Nightmares 2 APK de Aptoide, sigue estos pasos:
-
-- Abra Aptoide en su dispositivo Android o computadora y busque Very Little Nightmares 2.
-- Toque en el icono de la aplicación y leer la descripción, calificaciones y comentarios.
-- Toque en el botón "Instalar" y espere a que termine la descarga.
-- Abra el administrador de archivos en su dispositivo y busque el archivo APK descargado.
-- Toque en él y siga las instrucciones para instalarlo.
-
-APKPure
-APKPure es otra tienda de aplicaciones que ofrece aplicaciones y juegos gratuitos y seguros. Puede descargar APKPure desde su sitio web oficial o desde otras fuentes. Para descargar Very Little Nightmares 2 APK de APKPure, sigue estos pasos:
-
-- Abra APKPure en su dispositivo Android o computadora y busque Very Little Nightmares 2.
-- Toque en el icono de la aplicación y leer la descripción, calificaciones y comentarios.
-- Toque en el botón "Descargar APK" y guarde el archivo en su dispositivo u ordenador.
-- Abra el administrador de archivos en su dispositivo y busque el archivo APK descargado.
-- Toque en él y siga las instrucciones para instalarlo.
-
- Conclusión y preguntas frecuentes
-En este artículo, le hemos mostrado cómo descargar Very Little Nightmares 2 APK de diferentes fuentes y cómo instalarlo en su dispositivo Android. Esperamos que haya disfrutado de esta guía y la haya encontrado útil. Aquí hay algunas preguntas frecuentes que podrían ayudarlo más:
-
-
-A: Generalmente, sí, siempre y cuando lo descargue de fuentes confiables y verifique su seguridad antes de instalarlo. Sin embargo, siempre hay un riesgo de malware o virus al descargar cualquier archivo de fuentes desconocidas, así que tenga cuidado y utilice una aplicación antivirus confiable.
- Q: Es muy pequeñas pesadillas 2 APK compatible con mi dispositivo?
-A: La compatibilidad de Very Little Nightmares 2 APK depende de su modelo de dispositivo, versión de Android, y el espacio de almacenamiento disponible. Puede comprobar la compatibilidad del archivo APK leyendo su descripción, requisitos y comentarios en la tienda de aplicaciones o sitio web donde lo descargó. También puede utilizar una aplicación como APK Analyzer para comprobar los detalles del archivo APK antes de instalarlo.
- Q: ¿Cómo puedo actualizar muy pequeñas pesadillas 2 APK?
-A: Para actualizar Very Little Nightmares 2 APK, tendrá que descargar la última versión del archivo APK de la misma fuente donde lo obtuvo antes. Luego, puede desinstalar la versión anterior e instalar la nueva, o instalar la nueva sobre la anterior. Sin embargo, es posible que algunas actualizaciones no funcionen correctamente si las instalas en una versión anterior, por lo que es mejor desinstalarlas primero.
- Q: ¿Cómo puedo desinstalar muy pequeñas pesadillas 2 APK?
-A: Para desinstalar Very Little Nightmares 2 APK, puede ir a la configuración de su dispositivo > aplicaciones > Very Little Nightmares 2 > desinstalar, o utilizar una aplicación como (B, nh, T, T)
- att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
- if layer_past is None:
- att = att.masked_fill(self.mask[:,:,:T,:T] == 0, float('-inf'))
-
- att = F.softmax(att, dim=-1)
- att = self.attn_drop(att)
- y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)
- y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side
-
- # output projection
- y = self.resid_drop(self.proj(y))
- return y, present # TODO: check that this does not break anything
-
-
-class Block(nn.Module):
- """ an unassuming Transformer block """
- def __init__(self, config):
- super().__init__()
- self.ln1 = nn.LayerNorm(config.n_embd)
- self.ln2 = nn.LayerNorm(config.n_embd)
- self.attn = CausalSelfAttention(config)
- self.mlp = nn.Sequential(
- nn.Linear(config.n_embd, 4 * config.n_embd),
- nn.GELU(), # nice
- nn.Linear(4 * config.n_embd, config.n_embd),
- nn.Dropout(config.resid_pdrop),
- )
-
- def forward(self, x, layer_past=None, return_present=False):
- # TODO: check that training still works
- if return_present: assert not self.training
- # layer past: tuple of length two with B, nh, T, hs
- attn, present = self.attn(self.ln1(x), layer_past=layer_past)
-
- x = x + attn
- x = x + self.mlp(self.ln2(x))
- if layer_past is not None or return_present:
- return x, present
- return x
-
-
-class GPT(nn.Module):
- """ the full GPT language model, with a context size of block_size """
- def __init__(self, vocab_size, block_size, n_layer=12, n_head=8, n_embd=256,
- embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0):
- super().__init__()
- config = GPTConfig(vocab_size=vocab_size, block_size=block_size,
- embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop,
- n_layer=n_layer, n_head=n_head, n_embd=n_embd,
- n_unmasked=n_unmasked)
- # input embedding stem
- self.tok_emb = nn.Embedding(config.vocab_size, config.n_embd)
- self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd))
- self.drop = nn.Dropout(config.embd_pdrop)
- # transformer
- self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)])
- # decoder head
- self.ln_f = nn.LayerNorm(config.n_embd)
- self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
- self.block_size = config.block_size
- self.apply(self._init_weights)
- self.config = config
- logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters()))
-
- def get_block_size(self):
- return self.block_size
-
- def _init_weights(self, module):
- if isinstance(module, (nn.Linear, nn.Embedding)):
- module.weight.data.normal_(mean=0.0, std=0.02)
- if isinstance(module, nn.Linear) and module.bias is not None:
- module.bias.data.zero_()
- elif isinstance(module, nn.LayerNorm):
- module.bias.data.zero_()
- module.weight.data.fill_(1.0)
-
- def forward(self, idx, embeddings=None, targets=None):
- # forward the GPT model
- token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
-
- if embeddings is not None: # prepend explicit embeddings
- token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
-
- t = token_embeddings.shape[1]
- assert t <= self.block_size, "Cannot forward, model block size is exhausted."
- position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector
- x = self.drop(token_embeddings + position_embeddings)
- x = self.blocks(x)
- x = self.ln_f(x)
- logits = self.head(x)
-
- # if we are given some desired targets also calculate the loss
- loss = None
- if targets is not None:
- loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
-
- return logits, loss
-
- def forward_with_past(self, idx, embeddings=None, targets=None, past=None, past_length=None):
- # inference only
- assert not self.training
- token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
- if embeddings is not None: # prepend explicit embeddings
- token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
-
- if past is not None:
- assert past_length is not None
- past = torch.cat(past, dim=-2) # n_layer, 2, b, nh, len_past, dim_head
- past_shape = list(past.shape)
- expected_shape = [self.config.n_layer, 2, idx.shape[0], self.config.n_head, past_length, self.config.n_embd//self.config.n_head]
- assert past_shape == expected_shape, f"{past_shape} =/= {expected_shape}"
- position_embeddings = self.pos_emb[:, past_length, :] # each position maps to a (learnable) vector
- else:
- position_embeddings = self.pos_emb[:, :token_embeddings.shape[1], :]
-
- x = self.drop(token_embeddings + position_embeddings)
- presents = [] # accumulate over layers
- for i, block in enumerate(self.blocks):
- x, present = block(x, layer_past=past[i, ...] if past is not None else None, return_present=True)
- presents.append(present)
-
- x = self.ln_f(x)
- logits = self.head(x)
- # if we are given some desired targets also calculate the loss
- loss = None
- if targets is not None:
- loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
-
- return logits, loss, torch.stack(presents) # _, _, n_layer, 2, b, nh, 1, dim_head
-
-
-class DummyGPT(nn.Module):
- # for debugging
- def __init__(self, add_value=1):
- super().__init__()
- self.add_value = add_value
-
- def forward(self, idx):
- return idx + self.add_value, None
-
-
-class CodeGPT(nn.Module):
- """Takes in semi-embeddings"""
- def __init__(self, vocab_size, block_size, in_channels, n_layer=12, n_head=8, n_embd=256,
- embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0):
- super().__init__()
- config = GPTConfig(vocab_size=vocab_size, block_size=block_size,
- embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop,
- n_layer=n_layer, n_head=n_head, n_embd=n_embd,
- n_unmasked=n_unmasked)
- # input embedding stem
- self.tok_emb = nn.Linear(in_channels, config.n_embd)
- self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd))
- self.drop = nn.Dropout(config.embd_pdrop)
- # transformer
- self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)])
- # decoder head
- self.ln_f = nn.LayerNorm(config.n_embd)
- self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
- self.block_size = config.block_size
- self.apply(self._init_weights)
- self.config = config
- logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters()))
-
- def get_block_size(self):
- return self.block_size
-
- def _init_weights(self, module):
- if isinstance(module, (nn.Linear, nn.Embedding)):
- module.weight.data.normal_(mean=0.0, std=0.02)
- if isinstance(module, nn.Linear) and module.bias is not None:
- module.bias.data.zero_()
- elif isinstance(module, nn.LayerNorm):
- module.bias.data.zero_()
- module.weight.data.fill_(1.0)
-
- def forward(self, idx, embeddings=None, targets=None):
- # forward the GPT model
- token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
-
- if embeddings is not None: # prepend explicit embeddings
- token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
-
- t = token_embeddings.shape[1]
- assert t <= self.block_size, "Cannot forward, model block size is exhausted."
- position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector
- x = self.drop(token_embeddings + position_embeddings)
- x = self.blocks(x)
- x = self.taming_cinln_f(x)
- logits = self.head(x)
-
- # if we are given some desired targets also calculate the loss
- loss = None
- if targets is not None:
- loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
-
- return logits, loss
-
-
-
-#### sampling utils
-
-def top_k_logits(logits, k):
- v, ix = torch.topk(logits, k)
- out = logits.clone()
- out[out < v[:, [-1]]] = -float('Inf')
- return out
-
-@torch.no_grad()
-def sample(model, x, steps, temperature=1.0, sample=False, top_k=None):
- """
- take a conditioning sequence of indices in x (of shape (b,t)) and predict the next token in
- the sequence, feeding the predictions back into the model each time. Clearly the sampling
- has quadratic complexity unlike an RNN that is only linear, and has a finite context window
- of block_size, unlike an RNN that has an infinite context window.
- """
- block_size = model.get_block_size()
- model.eval()
- for k in range(steps):
- x_cond = x if x.size(1) <= block_size else x[:, -block_size:] # crop context if needed
- logits, _ = model(x_cond)
- # pluck the logits at the final step and scale by temperature
- logits = logits[:, -1, :] / temperature
- # optionally crop probabilities to only the top k options
- if top_k is not None:
- logits = top_k_logits(logits, top_k)
- # apply softmax to convert to probabilities
- probs = F.softmax(logits, dim=-1)
- # sample from the distribution or take the most likely
- if sample:
- ix = torch.multinomial(probs, num_samples=1)
- else:
- _, ix = torch.topk(probs, k=1, dim=-1)
- # append to the sequence and continue
- x = torch.cat((x, ix), dim=1)
-
- return x
-
-
-@torch.no_grad()
-def sample_with_past(x, model, steps, temperature=1., sample_logits=True,
- top_k=None, top_p=None, callback=None):
- # x is conditioning
- sample = x
- cond_len = x.shape[1]
- past = None
- for n in range(steps):
- if callback is not None:
- callback(n)
- logits, _, present = model.forward_with_past(x, past=past, past_length=(n+cond_len-1))
- if past is None:
- past = [present]
- else:
- past.append(present)
- logits = logits[:, -1, :] / temperature
- if top_k is not None:
- logits = top_k_top_p_filtering(logits, top_k=top_k, top_p=top_p)
-
- probs = F.softmax(logits, dim=-1)
- if not sample_logits:
- _, x = torch.topk(probs, k=1, dim=-1)
- else:
- x = torch.multinomial(probs, num_samples=1)
- # append to the sequence and continue
- sample = torch.cat((sample, x), dim=1)
- del past
- sample = sample[:, cond_len:] # cut conditioning off
- return sample
-
-
-#### clustering utils
-
-class KMeans(nn.Module):
- def __init__(self, ncluster=512, nc=3, niter=10):
- super().__init__()
- self.ncluster = ncluster
- self.nc = nc
- self.niter = niter
- self.shape = (3,32,32)
- self.register_buffer("C", torch.zeros(self.ncluster,nc))
- self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8))
-
- def is_initialized(self):
- return self.initialized.item() == 1
-
- @torch.no_grad()
- def initialize(self, x):
- N, D = x.shape
- assert D == self.nc, D
- c = x[torch.randperm(N)[:self.ncluster]] # init clusters at random
- for i in range(self.niter):
- # assign all pixels to the closest codebook element
- a = ((x[:, None, :] - c[None, :, :])**2).sum(-1).argmin(1)
- # move each codebook element to be the mean of the pixels that assigned to it
- c = torch.stack([x[a==k].mean(0) for k in range(self.ncluster)])
- # re-assign any poorly positioned codebook elements
- nanix = torch.any(torch.isnan(c), dim=1)
- ndead = nanix.sum().item()
- print('done step %d/%d, re-initialized %d dead clusters' % (i+1, self.niter, ndead))
- c[nanix] = x[torch.randperm(N)[:ndead]] # re-init dead clusters
-
- self.C.copy_(c)
- self.initialized.fill_(1)
-
-
- def forward(self, x, reverse=False, shape=None):
- if not reverse:
- # flatten
- bs,c,h,w = x.shape
- assert c == self.nc
- x = x.reshape(bs,c,h*w,1)
- C = self.C.permute(1,0)
- C = C.reshape(1,c,1,self.ncluster)
- a = ((x-C)**2).sum(1).argmin(-1) # bs, h*w indices
- return a
- else:
- # flatten
- bs, HW = x.shape
- """
- c = self.C.reshape( 1, self.nc, 1, self.ncluster)
- c = c[bs*[0],:,:,:]
- c = c[:,:,HW*[0],:]
- x = x.reshape(bs, 1, HW, 1)
- x = x[:,3*[0],:,:]
- x = torch.gather(c, dim=3, index=x)
- """
- x = self.C[x]
- x = x.permute(0,2,1)
- shape = shape if shape is not None else self.shape
- x = x.reshape(bs, *shape)
-
- return x
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/utils/__init__.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/utils/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/cachecontrol/heuristics.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/cachecontrol/heuristics.py
deleted file mode 100644
index ebe4a96f589474f6f441858de2bb961c5e473c6d..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/cachecontrol/heuristics.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# SPDX-FileCopyrightText: 2015 Eric Larson
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import calendar
-import time
-
-from email.utils import formatdate, parsedate, parsedate_tz
-
-from datetime import datetime, timedelta
-
-TIME_FMT = "%a, %d %b %Y %H:%M:%S GMT"
-
-
-def expire_after(delta, date=None):
- date = date or datetime.utcnow()
- return date + delta
-
-
-def datetime_to_header(dt):
- return formatdate(calendar.timegm(dt.timetuple()))
-
-
-class BaseHeuristic(object):
-
- def warning(self, response):
- """
- Return a valid 1xx warning header value describing the cache
- adjustments.
-
- The response is provided too allow warnings like 113
- http://tools.ietf.org/html/rfc7234#section-5.5.4 where we need
- to explicitly say response is over 24 hours old.
- """
- return '110 - "Response is Stale"'
-
- def update_headers(self, response):
- """Update the response headers with any new headers.
-
- NOTE: This SHOULD always include some Warning header to
- signify that the response was cached by the client, not
- by way of the provided headers.
- """
- return {}
-
- def apply(self, response):
- updated_headers = self.update_headers(response)
-
- if updated_headers:
- response.headers.update(updated_headers)
- warning_header_value = self.warning(response)
- if warning_header_value is not None:
- response.headers.update({"Warning": warning_header_value})
-
- return response
-
-
-class OneDayCache(BaseHeuristic):
- """
- Cache the response by providing an expires 1 day in the
- future.
- """
-
- def update_headers(self, response):
- headers = {}
-
- if "expires" not in response.headers:
- date = parsedate(response.headers["date"])
- expires = expire_after(timedelta(days=1), date=datetime(*date[:6]))
- headers["expires"] = datetime_to_header(expires)
- headers["cache-control"] = "public"
- return headers
-
-
-class ExpiresAfter(BaseHeuristic):
- """
- Cache **all** requests for a defined time period.
- """
-
- def __init__(self, **kw):
- self.delta = timedelta(**kw)
-
- def update_headers(self, response):
- expires = expire_after(self.delta)
- return {"expires": datetime_to_header(expires), "cache-control": "public"}
-
- def warning(self, response):
- tmpl = "110 - Automatically cached for %s. Response might be stale"
- return tmpl % self.delta
-
-
-class LastModified(BaseHeuristic):
- """
- If there is no Expires header already, fall back on Last-Modified
- using the heuristic from
- http://tools.ietf.org/html/rfc7234#section-4.2.2
- to calculate a reasonable value.
-
- Firefox also does something like this per
- https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching_FAQ
- http://lxr.mozilla.org/mozilla-release/source/netwerk/protocol/http/nsHttpResponseHead.cpp#397
- Unlike mozilla we limit this to 24-hr.
- """
- cacheable_by_default_statuses = {
- 200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501
- }
-
- def update_headers(self, resp):
- headers = resp.headers
-
- if "expires" in headers:
- return {}
-
- if "cache-control" in headers and headers["cache-control"] != "public":
- return {}
-
- if resp.status not in self.cacheable_by_default_statuses:
- return {}
-
- if "date" not in headers or "last-modified" not in headers:
- return {}
-
- date = calendar.timegm(parsedate_tz(headers["date"]))
- last_modified = parsedate(headers["last-modified"])
- if date is None or last_modified is None:
- return {}
-
- now = time.time()
- current_age = max(0, now - date)
- delta = date - calendar.timegm(last_modified)
- freshness_lifetime = max(0, min(delta / 10, 24 * 3600))
- if freshness_lifetime <= current_age:
- return {}
-
- expires = date + freshness_lifetime
- return {"expires": time.strftime(TIME_FMT, time.gmtime(expires))}
-
- def warning(self, resp):
- return None
diff --git a/spaces/Blessin/one-liners/app.py b/spaces/Blessin/one-liners/app.py
deleted file mode 100644
index 5554e7e46473978e1c133fe3e3fd5cb3b16cc2cf..0000000000000000000000000000000000000000
--- a/spaces/Blessin/one-liners/app.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import gradio as gr
-import random
-from datasets import load_dataset
-
-# Load the dataset from Hugging Face
-dataset = load_dataset("Blessin/dialogues-one-liners")
-
-# Extract the dialogues from the dataset
-DIALOGUES = dataset["train"]["dialogues"]
-
-def generate_statement():
- """Return a random dialogue from the dataset."""
- # Pick a random sublist from the dataset
- random_dialogue_list = random.choice(DIALOGUES)
- # Pick a random dialogue from the sublist
- return random.choice(random_dialogue_list)
-
-
-def main():
- # Define the UI using gr.Interface
- interface = gr.Interface(
- fn=generate_statement, # Function to call on button press
- inputs=[], # No inputs required
- outputs="text", # Output is a text area
- live=False, # Only generate statement after button press
- description="Press the button to generate a random statement from the dataset."
- )
-
- # Launch the UI
- interface.launch(share=True)
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/CVPR/GFPGAN-example/tests/test_arcface_arch.py b/spaces/CVPR/GFPGAN-example/tests/test_arcface_arch.py
deleted file mode 100644
index b4b28d33800ae78a354e078e14373d2ee159dc7b..0000000000000000000000000000000000000000
--- a/spaces/CVPR/GFPGAN-example/tests/test_arcface_arch.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import torch
-
-from gfpgan.archs.arcface_arch import BasicBlock, Bottleneck, ResNetArcFace
-
-
-def test_resnetarcface():
- """Test arch: ResNetArcFace."""
-
- # model init and forward (gpu)
- if torch.cuda.is_available():
- net = ResNetArcFace(block='IRBlock', layers=(2, 2, 2, 2), use_se=True).cuda().eval()
- img = torch.rand((1, 1, 128, 128), dtype=torch.float32).cuda()
- output = net(img)
- assert output.shape == (1, 512)
-
- # -------------------- without SE block ----------------------- #
- net = ResNetArcFace(block='IRBlock', layers=(2, 2, 2, 2), use_se=False).cuda().eval()
- output = net(img)
- assert output.shape == (1, 512)
-
-
-def test_basicblock():
- """Test the BasicBlock in arcface_arch"""
- block = BasicBlock(1, 3, stride=1, downsample=None).cuda()
- img = torch.rand((1, 1, 12, 12), dtype=torch.float32).cuda()
- output = block(img)
- assert output.shape == (1, 3, 12, 12)
-
- # ----------------- use the downsmaple module--------------- #
- downsample = torch.nn.UpsamplingNearest2d(scale_factor=0.5).cuda()
- block = BasicBlock(1, 3, stride=2, downsample=downsample).cuda()
- img = torch.rand((1, 1, 12, 12), dtype=torch.float32).cuda()
- output = block(img)
- assert output.shape == (1, 3, 6, 6)
-
-
-def test_bottleneck():
- """Test the Bottleneck in arcface_arch"""
- block = Bottleneck(1, 1, stride=1, downsample=None).cuda()
- img = torch.rand((1, 1, 12, 12), dtype=torch.float32).cuda()
- output = block(img)
- assert output.shape == (1, 4, 12, 12)
-
- # ----------------- use the downsmaple module--------------- #
- downsample = torch.nn.UpsamplingNearest2d(scale_factor=0.5).cuda()
- block = Bottleneck(1, 1, stride=2, downsample=downsample).cuda()
- img = torch.rand((1, 1, 12, 12), dtype=torch.float32).cuda()
- output = block(img)
- assert output.shape == (1, 4, 6, 6)
diff --git a/spaces/CVPR/LIVE/pybind11/tests/test_multiple_inheritance.cpp b/spaces/CVPR/LIVE/pybind11/tests/test_multiple_inheritance.cpp
deleted file mode 100644
index 70e34178540d210770fc862b5520a3b3c9d91a5c..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/pybind11/tests/test_multiple_inheritance.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- tests/test_multiple_inheritance.cpp -- multiple inheritance,
- implicit MI casts
-
- Copyright (c) 2016 Wenzel Jakob
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-
-// Many bases for testing that multiple inheritance from many classes (i.e. requiring extra
-// space for holder constructed flags) works.
-template struct BaseN {
- BaseN(int i) : i(i) { }
- int i;
-};
-
-// test_mi_static_properties
-struct Vanilla {
- std::string vanilla() { return "Vanilla"; };
-};
-struct WithStatic1 {
- static std::string static_func1() { return "WithStatic1"; };
- static int static_value1;
-};
-struct WithStatic2 {
- static std::string static_func2() { return "WithStatic2"; };
- static int static_value2;
-};
-struct VanillaStaticMix1 : Vanilla, WithStatic1, WithStatic2 {
- static std::string static_func() { return "VanillaStaticMix1"; }
- static int static_value;
-};
-struct VanillaStaticMix2 : WithStatic1, Vanilla, WithStatic2 {
- static std::string static_func() { return "VanillaStaticMix2"; }
- static int static_value;
-};
-int WithStatic1::static_value1 = 1;
-int WithStatic2::static_value2 = 2;
-int VanillaStaticMix1::static_value = 12;
-int VanillaStaticMix2::static_value = 12;
-
-TEST_SUBMODULE(multiple_inheritance, m) {
-
- // test_multiple_inheritance_mix1
- // test_multiple_inheritance_mix2
- struct Base1 {
- Base1(int i) : i(i) { }
- int foo() { return i; }
- int i;
- };
- py::class_ b1(m, "Base1");
- b1.def(py::init())
- .def("foo", &Base1::foo);
-
- struct Base2 {
- Base2(int i) : i(i) { }
- int bar() { return i; }
- int i;
- };
- py::class_ b2(m, "Base2");
- b2.def(py::init())
- .def("bar", &Base2::bar);
-
-
- // test_multiple_inheritance_cpp
- struct Base12 : Base1, Base2 {
- Base12(int i, int j) : Base1(i), Base2(j) { }
- };
- struct MIType : Base12 {
- MIType(int i, int j) : Base12(i, j) { }
- };
- py::class_(m, "Base12");
- py::class_(m, "MIType")
- .def(py::init());
-
-
- // test_multiple_inheritance_python_many_bases
- #define PYBIND11_BASEN(N) py::class_>(m, "BaseN" #N).def(py::init()).def("f" #N, [](BaseN &b) { return b.i + N; })
- PYBIND11_BASEN( 1); PYBIND11_BASEN( 2); PYBIND11_BASEN( 3); PYBIND11_BASEN( 4);
- PYBIND11_BASEN( 5); PYBIND11_BASEN( 6); PYBIND11_BASEN( 7); PYBIND11_BASEN( 8);
- PYBIND11_BASEN( 9); PYBIND11_BASEN(10); PYBIND11_BASEN(11); PYBIND11_BASEN(12);
- PYBIND11_BASEN(13); PYBIND11_BASEN(14); PYBIND11_BASEN(15); PYBIND11_BASEN(16);
- PYBIND11_BASEN(17);
-
- // Uncommenting this should result in a compile time failure (MI can only be specified via
- // template parameters because pybind has to know the types involved; see discussion in #742 for
- // details).
-// struct Base12v2 : Base1, Base2 {
-// Base12v2(int i, int j) : Base1(i), Base2(j) { }
-// };
-// py::class_(m, "Base12v2", b1, b2)
-// .def(py::init());
-
-
- // test_multiple_inheritance_virtbase
- // Test the case where not all base classes are specified, and where pybind11 requires the
- // py::multiple_inheritance flag to perform proper casting between types.
- struct Base1a {
- Base1a(int i) : i(i) { }
- int foo() { return i; }
- int i;
- };
- py::class_>(m, "Base1a")
- .def(py::init())
- .def("foo", &Base1a::foo);
-
- struct Base2a {
- Base2a(int i) : i(i) { }
- int bar() { return i; }
- int i;
- };
- py::class_>(m, "Base2a")
- .def(py::init())
- .def("bar", &Base2a::bar);
-
- struct Base12a : Base1a, Base2a {
- Base12a(int i, int j) : Base1a(i), Base2a(j) { }
- };
- py::class_>(m, "Base12a", py::multiple_inheritance())
- .def(py::init());
-
- m.def("bar_base2a", [](Base2a *b) { return b->bar(); });
- m.def("bar_base2a_sharedptr", [](std::shared_ptr b) { return b->bar(); });
-
- // test_mi_unaligned_base
- // test_mi_base_return
- // Issue #801: invalid casting to derived type with MI bases
- struct I801B1 { int a = 1; I801B1() = default; I801B1(const I801B1 &) = default; virtual ~I801B1() = default; };
- struct I801B2 { int b = 2; I801B2() = default; I801B2(const I801B2 &) = default; virtual ~I801B2() = default; };
- struct I801C : I801B1, I801B2 {};
- struct I801D : I801C {}; // Indirect MI
- // Unregistered classes:
- struct I801B3 { int c = 3; virtual ~I801B3() = default; };
- struct I801E : I801B3, I801D {};
-
- py::class_>(m, "I801B1").def(py::init<>()).def_readonly("a", &I801B1::a);
- py::class_>(m, "I801B2").def(py::init<>()).def_readonly("b", &I801B2::b);
- py::class_>(m, "I801C").def(py::init<>());
- py::class_>(m, "I801D").def(py::init<>());
-
- // Two separate issues here: first, we want to recognize a pointer to a base type as being a
- // known instance even when the pointer value is unequal (i.e. due to a non-first
- // multiple-inheritance base class):
- m.def("i801b1_c", [](I801C *c) { return static_cast(c); });
- m.def("i801b2_c", [](I801C *c) { return static_cast(c); });
- m.def("i801b1_d", [](I801D *d) { return static_cast(d); });
- m.def("i801b2_d", [](I801D *d) { return static_cast(d); });
-
- // Second, when returned a base class pointer to a derived instance, we cannot assume that the
- // pointer is `reinterpret_cast`able to the derived pointer because, like above, the base class
- // pointer could be offset.
- m.def("i801c_b1", []() -> I801B1 * { return new I801C(); });
- m.def("i801c_b2", []() -> I801B2 * { return new I801C(); });
- m.def("i801d_b1", []() -> I801B1 * { return new I801D(); });
- m.def("i801d_b2", []() -> I801B2 * { return new I801D(); });
-
- // Return a base class pointer to a pybind-registered type when the actual derived type
- // isn't pybind-registered (and uses multiple-inheritance to offset the pybind base)
- m.def("i801e_c", []() -> I801C * { return new I801E(); });
- m.def("i801e_b2", []() -> I801B2 * { return new I801E(); });
-
-
- // test_mi_static_properties
- py::class_(m, "Vanilla")
- .def(py::init<>())
- .def("vanilla", &Vanilla::vanilla);
-
- py::class_(m, "WithStatic1")
- .def(py::init<>())
- .def_static("static_func1", &WithStatic1::static_func1)
- .def_readwrite_static("static_value1", &WithStatic1::static_value1);
-
- py::class_(m, "WithStatic2")
- .def(py::init<>())
- .def_static("static_func2", &WithStatic2::static_func2)
- .def_readwrite_static("static_value2", &WithStatic2::static_value2);
-
- py::class_(
- m, "VanillaStaticMix1")
- .def(py::init<>())
- .def_static("static_func", &VanillaStaticMix1::static_func)
- .def_readwrite_static("static_value", &VanillaStaticMix1::static_value);
-
- py::class_(
- m, "VanillaStaticMix2")
- .def(py::init<>())
- .def_static("static_func", &VanillaStaticMix2::static_func)
- .def_readwrite_static("static_value", &VanillaStaticMix2::static_value);
-
-
-#if !(defined(PYPY_VERSION) && (PYPY_VERSION_NUM < 0x06000000))
- struct WithDict { };
- struct VanillaDictMix1 : Vanilla, WithDict { };
- struct VanillaDictMix2 : WithDict, Vanilla { };
- py::class_(m, "WithDict", py::dynamic_attr()).def(py::init<>());
- py::class_(m, "VanillaDictMix1").def(py::init<>());
- py::class_(m, "VanillaDictMix2").def(py::init<>());
-#endif
-
- // test_diamond_inheritance
- // Issue #959: segfault when constructing diamond inheritance instance
- // All of these have int members so that there will be various unequal pointers involved.
- struct B { int b; B() = default; B(const B&) = default; virtual ~B() = default; };
- struct C0 : public virtual B { int c0; };
- struct C1 : public virtual B { int c1; };
- struct D : public C0, public C1 { int d; };
- py::class_(m, "B")
- .def("b", [](B *self) { return self; });
- py::class_(m, "C0")
- .def("c0", [](C0 *self) { return self; });
- py::class_(m, "C1")
- .def("c1", [](C1 *self) { return self; });
- py::class_(m, "D")
- .def(py::init<>());
-}
diff --git a/spaces/CVPR/LIVE/thrust/thrust/detail/complex/catrig.h b/spaces/CVPR/LIVE/thrust/thrust/detail/complex/catrig.h
deleted file mode 100644
index 6549fbb2eea699078da00b5d93e346ac93c6f73e..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/detail/complex/catrig.h
+++ /dev/null
@@ -1,785 +0,0 @@
-/*
- * Copyright 2008-2013 NVIDIA Corporation
- * Copyright 2013 Filipe RNC Maia
- *
- * 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.
- */
-
-/*-
- * Copyright (c) 2012 Stephen Montgomery-Smith
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * Adapted from FreeBSD by Filipe Maia :
- * freebsd/lib/msun/src/catrig.c
- */
-
-#pragma once
-
-#include
-#include
-#include
-#include
-#include
-
-namespace thrust{
-namespace detail{
-namespace complex{
-
-using thrust::complex;
-
-__host__ __device__
-inline void raise_inexact(){
- const volatile float tiny = 7.888609052210118054117286e-31; /* 0x1p-100; */
- // needs the volatile to prevent compiler from ignoring it
- volatile float junk = 1 + tiny;
- (void)junk;
-}
-
-__host__ __device__ inline complex clog_for_large_values(complex z);
-
-/*
- * Testing indicates that all these functions are accurate up to 4 ULP.
- * The functions casin(h) and cacos(h) are about 2.5 times slower than asinh.
- * The functions catan(h) are a little under 2 times slower than atanh.
- *
- * The code for casinh, casin, cacos, and cacosh comes first. The code is
- * rather complicated, and the four functions are highly interdependent.
- *
- * The code for catanh and catan comes at the end. It is much simpler than
- * the other functions, and the code for these can be disconnected from the
- * rest of the code.
- */
-
-/*
- * ================================
- * | casinh, casin, cacos, cacosh |
- * ================================
- */
-
-/*
- * The algorithm is very close to that in "Implementing the complex arcsine
- * and arccosine functions using exception handling" by T. E. Hull, Thomas F.
- * Fairgrieve, and Ping Tak Peter Tang, published in ACM Transactions on
- * Mathematical Software, Volume 23 Issue 3, 1997, Pages 299-335,
- * http://dl.acm.org/citation.cfm?id=275324.
- *
- * Throughout we use the convention z = x + I*y.
- *
- * casinh(z) = sign(x)*log(A+sqrt(A*A-1)) + I*asin(B)
- * where
- * A = (|z+I| + |z-I|) / 2
- * B = (|z+I| - |z-I|) / 2 = y/A
- *
- * These formulas become numerically unstable:
- * (a) for Re(casinh(z)) when z is close to the line segment [-I, I] (that
- * is, Re(casinh(z)) is close to 0);
- * (b) for Im(casinh(z)) when z is close to either of the intervals
- * [I, I*infinity) or (-I*infinity, -I] (that is, |Im(casinh(z))| is
- * close to PI/2).
- *
- * These numerical problems are overcome by defining
- * f(a, b) = (hypot(a, b) - b) / 2 = a*a / (hypot(a, b) + b) / 2
- * Then if A < A_crossover, we use
- * log(A + sqrt(A*A-1)) = log1p((A-1) + sqrt((A-1)*(A+1)))
- * A-1 = f(x, 1+y) + f(x, 1-y)
- * and if B > B_crossover, we use
- * asin(B) = atan2(y, sqrt(A*A - y*y)) = atan2(y, sqrt((A+y)*(A-y)))
- * A-y = f(x, y+1) + f(x, y-1)
- * where without loss of generality we have assumed that x and y are
- * non-negative.
- *
- * Much of the difficulty comes because the intermediate computations may
- * produce overflows or underflows. This is dealt with in the paper by Hull
- * et al by using exception handling. We do this by detecting when
- * computations risk underflow or overflow. The hardest part is handling the
- * underflows when computing f(a, b).
- *
- * Note that the function f(a, b) does not appear explicitly in the paper by
- * Hull et al, but the idea may be found on pages 308 and 309. Introducing the
- * function f(a, b) allows us to concentrate many of the clever tricks in this
- * paper into one function.
- */
-
-/*
- * Function f(a, b, hypot_a_b) = (hypot(a, b) - b) / 2.
- * Pass hypot(a, b) as the third argument.
- */
-__host__ __device__
-inline double
-f(double a, double b, double hypot_a_b)
-{
- if (b < 0)
- return ((hypot_a_b - b) / 2);
- if (b == 0)
- return (a / 2);
- return (a * a / (hypot_a_b + b) / 2);
-}
-
-/*
- * All the hard work is contained in this function.
- * x and y are assumed positive or zero, and less than RECIP_EPSILON.
- * Upon return:
- * rx = Re(casinh(z)) = -Im(cacos(y + I*x)).
- * B_is_usable is set to 1 if the value of B is usable.
- * If B_is_usable is set to 0, sqrt_A2my2 = sqrt(A*A - y*y), and new_y = y.
- * If returning sqrt_A2my2 has potential to result in an underflow, it is
- * rescaled, and new_y is similarly rescaled.
- */
-__host__ __device__
-inline void
-do_hard_work(double x, double y, double *rx, int *B_is_usable, double *B,
- double *sqrt_A2my2, double *new_y)
-{
- double R, S, A; /* A, B, R, and S are as in Hull et al. */
- double Am1, Amy; /* A-1, A-y. */
- const double A_crossover = 10; /* Hull et al suggest 1.5, but 10 works better */
- const double FOUR_SQRT_MIN = 5.966672584960165394632772e-154; /* =0x1p-509; >= 4 * sqrt(DBL_MIN) */
- const double B_crossover = 0.6417; /* suggested by Hull et al */
-
- R = hypot(x, y + 1); /* |z+I| */
- S = hypot(x, y - 1); /* |z-I| */
-
- /* A = (|z+I| + |z-I|) / 2 */
- A = (R + S) / 2;
- /*
- * Mathematically A >= 1. There is a small chance that this will not
- * be so because of rounding errors. So we will make certain it is
- * so.
- */
- if (A < 1)
- A = 1;
-
- if (A < A_crossover) {
- /*
- * Am1 = fp + fm, where fp = f(x, 1+y), and fm = f(x, 1-y).
- * rx = log1p(Am1 + sqrt(Am1*(A+1)))
- */
- if (y == 1 && x < DBL_EPSILON * DBL_EPSILON / 128) {
- /*
- * fp is of order x^2, and fm = x/2.
- * A = 1 (inexactly).
- */
- *rx = sqrt(x);
- } else if (x >= DBL_EPSILON * fabs(y - 1)) {
- /*
- * Underflow will not occur because
- * x >= DBL_EPSILON^2/128 >= FOUR_SQRT_MIN
- */
- Am1 = f(x, 1 + y, R) + f(x, 1 - y, S);
- *rx = log1p(Am1 + sqrt(Am1 * (A + 1)));
- } else if (y < 1) {
- /*
- * fp = x*x/(1+y)/4, fm = x*x/(1-y)/4, and
- * A = 1 (inexactly).
- */
- *rx = x / sqrt((1 - y) * (1 + y));
- } else { /* if (y > 1) */
- /*
- * A-1 = y-1 (inexactly).
- */
- *rx = log1p((y - 1) + sqrt((y - 1) * (y + 1)));
- }
- } else {
- *rx = log(A + sqrt(A * A - 1));
- }
-
- *new_y = y;
-
- if (y < FOUR_SQRT_MIN) {
- /*
- * Avoid a possible underflow caused by y/A. For casinh this
- * would be legitimate, but will be picked up by invoking atan2
- * later on. For cacos this would not be legitimate.
- */
- *B_is_usable = 0;
- *sqrt_A2my2 = A * (2 / DBL_EPSILON);
- *new_y = y * (2 / DBL_EPSILON);
- return;
- }
-
- /* B = (|z+I| - |z-I|) / 2 = y/A */
- *B = y / A;
- *B_is_usable = 1;
-
- if (*B > B_crossover) {
- *B_is_usable = 0;
- /*
- * Amy = fp + fm, where fp = f(x, y+1), and fm = f(x, y-1).
- * sqrt_A2my2 = sqrt(Amy*(A+y))
- */
- if (y == 1 && x < DBL_EPSILON / 128) {
- /*
- * fp is of order x^2, and fm = x/2.
- * A = 1 (inexactly).
- */
- *sqrt_A2my2 = sqrt(x) * sqrt((A + y) / 2);
- } else if (x >= DBL_EPSILON * fabs(y - 1)) {
- /*
- * Underflow will not occur because
- * x >= DBL_EPSILON/128 >= FOUR_SQRT_MIN
- * and
- * x >= DBL_EPSILON^2 >= FOUR_SQRT_MIN
- */
- Amy = f(x, y + 1, R) + f(x, y - 1, S);
- *sqrt_A2my2 = sqrt(Amy * (A + y));
- } else if (y > 1) {
- /*
- * fp = x*x/(y+1)/4, fm = x*x/(y-1)/4, and
- * A = y (inexactly).
- *
- * y < RECIP_EPSILON. So the following
- * scaling should avoid any underflow problems.
- */
- *sqrt_A2my2 = x * (4 / DBL_EPSILON / DBL_EPSILON) * y /
- sqrt((y + 1) * (y - 1));
- *new_y = y * (4 / DBL_EPSILON / DBL_EPSILON);
- } else { /* if (y < 1) */
- /*
- * fm = 1-y >= DBL_EPSILON, fp is of order x^2, and
- * A = 1 (inexactly).
- */
- *sqrt_A2my2 = sqrt((1 - y) * (1 + y));
- }
- }
-}
-
-/*
- * casinh(z) = z + O(z^3) as z -> 0
- *
- * casinh(z) = sign(x)*clog(sign(x)*z) + O(1/z^2) as z -> infinity
- * The above formula works for the imaginary part as well, because
- * Im(casinh(z)) = sign(x)*atan2(sign(x)*y, fabs(x)) + O(y/z^3)
- * as z -> infinity, uniformly in y
- */
-__host__ __device__ inline
-complex casinh(complex z)
-{
- double x, y, ax, ay, rx, ry, B, sqrt_A2my2, new_y;
- int B_is_usable;
- complex w;
- const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
- const double m_ln2 = 6.9314718055994531e-1; /* 0x162e42fefa39ef.0p-53 */
- x = z.real();
- y = z.imag();
- ax = fabs(x);
- ay = fabs(y);
-
- if (isnan(x) || isnan(y)) {
- /* casinh(+-Inf + I*NaN) = +-Inf + I*NaN */
- if (isinf(x))
- return (complex(x, y + y));
- /* casinh(NaN + I*+-Inf) = opt(+-)Inf + I*NaN */
- if (isinf(y))
- return (complex(y, x + x));
- /* casinh(NaN + I*0) = NaN + I*0 */
- if (y == 0)
- return (complex(x + x, y));
- /*
- * All other cases involving NaN return NaN + I*NaN.
- * C99 leaves it optional whether to raise invalid if one of
- * the arguments is not NaN, so we opt not to raise it.
- */
- return (complex(x + 0.0 + (y + 0.0), x + 0.0 + (y + 0.0)));
- }
-
- if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
- /* clog...() will raise inexact unless x or y is infinite. */
- if (signbit(x) == 0)
- w = clog_for_large_values(z) + m_ln2;
- else
- w = clog_for_large_values(-z) + m_ln2;
- return (complex(copysign(w.real(), x), copysign(w.imag(), y)));
- }
-
- /* Avoid spuriously raising inexact for z = 0. */
- if (x == 0 && y == 0)
- return (z);
-
- /* All remaining cases are inexact. */
- raise_inexact();
-
- const double SQRT_6_EPSILON = 3.6500241499888571e-8; /* 0x13988e1409212e.0p-77 */
- if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
- return (z);
-
- do_hard_work(ax, ay, &rx, &B_is_usable, &B, &sqrt_A2my2, &new_y);
- if (B_is_usable)
- ry = asin(B);
- else
- ry = atan2(new_y, sqrt_A2my2);
- return (complex(copysign(rx, x), copysign(ry, y)));
-}
-
-/*
- * casin(z) = reverse(casinh(reverse(z)))
- * where reverse(x + I*y) = y + I*x = I*conj(z).
- */
-__host__ __device__ inline
-complex casin(complex z)
-{
- complex w = casinh(complex(z.imag(), z.real()));
-
- return (complex(w.imag(), w.real()));
-}
-
-/*
- * cacos(z) = PI/2 - casin(z)
- * but do the computation carefully so cacos(z) is accurate when z is
- * close to 1.
- *
- * cacos(z) = PI/2 - z + O(z^3) as z -> 0
- *
- * cacos(z) = -sign(y)*I*clog(z) + O(1/z^2) as z -> infinity
- * The above formula works for the real part as well, because
- * Re(cacos(z)) = atan2(fabs(y), x) + O(y/z^3)
- * as z -> infinity, uniformly in y
- */
-__host__ __device__ inline
-complex cacos(complex z)
-{
- double x, y, ax, ay, rx, ry, B, sqrt_A2mx2, new_x;
- int sx, sy;
- int B_is_usable;
- complex w;
- const double pio2_hi = 1.5707963267948966e0; /* 0x1921fb54442d18.0p-52 */
- const volatile double pio2_lo = 6.1232339957367659e-17; /* 0x11a62633145c07.0p-106 */
- const double m_ln2 = 6.9314718055994531e-1; /* 0x162e42fefa39ef.0p-53 */
-
- x = z.real();
- y = z.imag();
- sx = signbit(x);
- sy = signbit(y);
- ax = fabs(x);
- ay = fabs(y);
-
- if (isnan(x) || isnan(y)) {
- /* cacos(+-Inf + I*NaN) = NaN + I*opt(-)Inf */
- if (isinf(x))
- return (complex(y + y, -infinity()));
- /* cacos(NaN + I*+-Inf) = NaN + I*-+Inf */
- if (isinf(y))
- return (complex(x + x, -y));
- /* cacos(0 + I*NaN) = PI/2 + I*NaN with inexact */
- if (x == 0)
- return (complex(pio2_hi + pio2_lo, y + y));
- /*
- * All other cases involving NaN return NaN + I*NaN.
- * C99 leaves it optional whether to raise invalid if one of
- * the arguments is not NaN, so we opt not to raise it.
- */
- return (complex(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
- }
-
- const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
- if (ax > RECIP_EPSILON || ay > RECIP_EPSILON) {
- /* clog...() will raise inexact unless x or y is infinite. */
- w = clog_for_large_values(z);
- rx = fabs(w.imag());
- ry = w.real() + m_ln2;
- if (sy == 0)
- ry = -ry;
- return (complex(rx, ry));
- }
-
- /* Avoid spuriously raising inexact for z = 1. */
- if (x == 1.0 && y == 0.0)
- return (complex(0, -y));
-
- /* All remaining cases are inexact. */
- raise_inexact();
-
- const double SQRT_6_EPSILON = 3.6500241499888571e-8; /* 0x13988e1409212e.0p-77 */
- if (ax < SQRT_6_EPSILON / 4 && ay < SQRT_6_EPSILON / 4)
- return (complex(pio2_hi - (x - pio2_lo), -y));
-
- do_hard_work(ay, ax, &ry, &B_is_usable, &B, &sqrt_A2mx2, &new_x);
- if (B_is_usable) {
- if (sx == 0)
- rx = acos(B);
- else
- rx = acos(-B);
- } else {
- if (sx == 0)
- rx = atan2(sqrt_A2mx2, new_x);
- else
- rx = atan2(sqrt_A2mx2, -new_x);
- }
- if (sy == 0)
- ry = -ry;
- return (complex(rx, ry));
-}
-
-/*
- * cacosh(z) = I*cacos(z) or -I*cacos(z)
- * where the sign is chosen so Re(cacosh(z)) >= 0.
- */
-__host__ __device__ inline
-complex cacosh(complex z)
-{
- complex w;
- double rx, ry;
-
- w = cacos(z);
- rx = w.real();
- ry = w.imag();
- /* cacosh(NaN + I*NaN) = NaN + I*NaN */
- if (isnan(rx) && isnan(ry))
- return (complex(ry, rx));
- /* cacosh(NaN + I*+-Inf) = +Inf + I*NaN */
- /* cacosh(+-Inf + I*NaN) = +Inf + I*NaN */
- if (isnan(rx))
- return (complex(fabs(ry), rx));
- /* cacosh(0 + I*NaN) = NaN + I*NaN */
- if (isnan(ry))
- return (complex(ry, ry));
- return (complex(fabs(ry), copysign(rx, z.imag())));
-}
-
-/*
- * Optimized version of clog() for |z| finite and larger than ~RECIP_EPSILON.
- */
-__host__ __device__ inline
-complex clog_for_large_values(complex z)
-{
- double x, y;
- double ax, ay, t;
- const double m_e = 2.7182818284590452e0; /* 0x15bf0a8b145769.0p-51 */
-
- x = z.real();
- y = z.imag();
- ax = fabs(x);
- ay = fabs(y);
- if (ax < ay) {
- t = ax;
- ax = ay;
- ay = t;
- }
-
- /*
- * Avoid overflow in hypot() when x and y are both very large.
- * Divide x and y by E, and then add 1 to the logarithm. This depends
- * on E being larger than sqrt(2).
- * Dividing by E causes an insignificant loss of accuracy; however
- * this method is still poor since it is uneccessarily slow.
- */
- if (ax > DBL_MAX / 2)
- return (complex(log(hypot(x / m_e, y / m_e)) + 1, atan2(y, x)));
-
- /*
- * Avoid overflow when x or y is large. Avoid underflow when x or
- * y is small.
- */
- const double QUARTER_SQRT_MAX = 5.966672584960165394632772e-154; /* = 0x1p509; <= sqrt(DBL_MAX) / 4 */
- const double SQRT_MIN = 1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
- if (ax > QUARTER_SQRT_MAX || ay < SQRT_MIN)
- return (complex(log(hypot(x, y)), atan2(y, x)));
-
- return (complex(log(ax * ax + ay * ay) / 2, atan2(y, x)));
-}
-
-/*
- * =================
- * | catanh, catan |
- * =================
- */
-
-/*
- * sum_squares(x,y) = x*x + y*y (or just x*x if y*y would underflow).
- * Assumes x*x and y*y will not overflow.
- * Assumes x and y are finite.
- * Assumes y is non-negative.
- * Assumes fabs(x) >= DBL_EPSILON.
- */
-__host__ __device__
-inline double sum_squares(double x, double y)
-{
- const double SQRT_MIN = 1.491668146240041348658193e-154; /* = 0x1p-511; >= sqrt(DBL_MIN) */
- /* Avoid underflow when y is small. */
- if (y < SQRT_MIN)
- return (x * x);
-
- return (x * x + y * y);
-}
-
-/*
- * real_part_reciprocal(x, y) = Re(1/(x+I*y)) = x/(x*x + y*y).
- * Assumes x and y are not NaN, and one of x and y is larger than
- * RECIP_EPSILON. We avoid unwarranted underflow. It is important to not use
- * the code creal(1/z), because the imaginary part may produce an unwanted
- * underflow.
- * This is only called in a context where inexact is always raised before
- * the call, so no effort is made to avoid or force inexact.
- */
-__host__ __device__
-inline double real_part_reciprocal(double x, double y)
-{
- double scale;
- uint32_t hx, hy;
- int32_t ix, iy;
-
- /*
- * This code is inspired by the C99 document n1124.pdf, Section G.5.1,
- * example 2.
- */
- get_high_word(hx, x);
- ix = hx & 0x7ff00000;
- get_high_word(hy, y);
- iy = hy & 0x7ff00000;
- //#define BIAS (DBL_MAX_EXP - 1)
- const int BIAS = DBL_MAX_EXP - 1;
- /* XXX more guard digits are useful iff there is extra precision. */
- //#define CUTOFF (DBL_MANT_DIG / 2 + 1) /* just half or 1 guard digit */
- const int CUTOFF = (DBL_MANT_DIG / 2 + 1);
- if (ix - iy >= CUTOFF << 20 || isinf(x))
- return (1 / x); /* +-Inf -> +-0 is special */
- if (iy - ix >= CUTOFF << 20)
- return (x / y / y); /* should avoid double div, but hard */
- if (ix <= (BIAS + DBL_MAX_EXP / 2 - CUTOFF) << 20)
- return (x / (x * x + y * y));
- scale = 1;
- set_high_word(scale, 0x7ff00000 - ix); /* 2**(1-ilogb(x)) */
- x *= scale;
- y *= scale;
- return (x / (x * x + y * y) * scale);
-}
-
-
-/*
- * catanh(z) = log((1+z)/(1-z)) / 2
- * = log1p(4*x / |z-1|^2) / 4
- * + I * atan2(2*y, (1-x)*(1+x)-y*y) / 2
- *
- * catanh(z) = z + O(z^3) as z -> 0
- *
- * catanh(z) = 1/z + sign(y)*I*PI/2 + O(1/z^3) as z -> infinity
- * The above formula works for the real part as well, because
- * Re(catanh(z)) = x/|z|^2 + O(x/z^4)
- * as z -> infinity, uniformly in x
- */
-#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
-__host__ __device__ inline
-complex catanh(complex z)
-{
- double x, y, ax, ay, rx, ry;
- const volatile double pio2_lo = 6.1232339957367659e-17; /* 0x11a62633145c07.0p-106 */
- const double pio2_hi = 1.5707963267948966e0;/* 0x1921fb54442d18.0p-52 */
-
-
- x = z.real();
- y = z.imag();
- ax = fabs(x);
- ay = fabs(y);
-
- /* This helps handle many cases. */
- if (y == 0 && ax <= 1)
- return (complex(atanh(x), y));
-
- /* To ensure the same accuracy as atan(), and to filter out z = 0. */
- if (x == 0)
- return (complex(x, atan(y)));
-
- if (isnan(x) || isnan(y)) {
- /* catanh(+-Inf + I*NaN) = +-0 + I*NaN */
- if (isinf(x))
- return (complex(copysign(0.0, x), y + y));
- /* catanh(NaN + I*+-Inf) = sign(NaN)0 + I*+-PI/2 */
- if (isinf(y))
- return (complex(copysign(0.0, x),
- copysign(pio2_hi + pio2_lo, y)));
- /*
- * All other cases involving NaN return NaN + I*NaN.
- * C99 leaves it optional whether to raise invalid if one of
- * the arguments is not NaN, so we opt not to raise it.
- */
- return (complex(x + 0.0 + (y + 0), x + 0.0 + (y + 0)));
- }
-
- const double RECIP_EPSILON = 1.0 / DBL_EPSILON;
- if (ax > RECIP_EPSILON || ay > RECIP_EPSILON)
- return (complex(real_part_reciprocal(x, y),
- copysign(pio2_hi + pio2_lo, y)));
-
- const double SQRT_3_EPSILON = 2.5809568279517849e-8; /* 0x1bb67ae8584caa.0p-78 */
- if (ax < SQRT_3_EPSILON / 2 && ay < SQRT_3_EPSILON / 2) {
- /*
- * z = 0 was filtered out above. All other cases must raise
- * inexact, but this is the only only that needs to do it
- * explicitly.
- */
- raise_inexact();
- return (z);
- }
-
- const double m_ln2 = 6.9314718055994531e-1; /* 0x162e42fefa39ef.0p-53 */
- if (ax == 1 && ay < DBL_EPSILON)
- rx = (m_ln2 - log(ay)) / 2;
- else
- rx = log1p(4 * ax / sum_squares(ax - 1, ay)) / 4;
-
- if (ax == 1)
- ry = atan2(2.0, -ay) / 2;
- else if (ay < DBL_EPSILON)
- ry = atan2(2 * ay, (1 - ax) * (1 + ax)) / 2;
- else
- ry = atan2(2 * ay, (1 - ax) * (1 + ax) - ay * ay) / 2;
-
- return (complex(copysign(rx, x), copysign(ry, y)));
-}
-
-/*
- * catan(z) = reverse(catanh(reverse(z)))
- * where reverse(x + I*y) = y + I*x = I*conj(z).
- */
-__host__ __device__ inline
-complexcatan(complex z)
-{
- complex w = catanh(complex(z.imag(), z.real()));
- return (complex(w.imag(), w.real()));
-}
-
-#endif
-
-} // namespace complex
-
-} // namespace detail
-
-
-template
-__host__ __device__
-inline complex acos(const complex& z){
- const complex ret = thrust::asin(z);
- const ValueType pi = ValueType(3.14159265358979323846);
- return complex(pi/2 - ret.real(),-ret.imag());
-}
-
-
-template
-__host__ __device__
-inline complex asin(const complex& z){
- const complex i(0,1);
- return -i*asinh(i*z);
-}
-
-template
-__host__ __device__
-inline complex atan(const complex& z){
- const complex i(0,1);
- return -i*thrust::atanh(i*z);
-}
-
-
-template
-__host__ __device__
-inline complex acosh(const complex& z){
- thrust::complex ret((z.real() - z.imag()) * (z.real() + z.imag()) - ValueType(1.0),
- ValueType(2.0) * z.real() * z.imag());
- ret = thrust::sqrt(ret);
- if (z.real() < ValueType(0.0)){
- ret = -ret;
- }
- ret += z;
- ret = thrust::log(ret);
- if (ret.real() < ValueType(0.0)){
- ret = -ret;
- }
- return ret;
-}
-
-template
-__host__ __device__
-inline complex asinh(const complex& z){
- return thrust::log(thrust::sqrt(z*z+ValueType(1))+z);
-}
-
-template
-__host__ __device__
-inline complex atanh(const complex& z){
- ValueType imag2 = z.imag() * z.imag();
- ValueType n = ValueType(1.0) + z.real();
- n = imag2 + n * n;
-
- ValueType d = ValueType(1.0) - z.real();
- d = imag2 + d * d;
- complex ret(ValueType(0.25) * (std::log(n) - std::log(d)),0);
-
- d = ValueType(1.0) - z.real() * z.real() - imag2;
-
- ret.imag(ValueType(0.5) * std::atan2(ValueType(2.0) * z.imag(), d));
- return ret;
-}
-
-template <>
-__host__ __device__
-inline complex acos(const complex& z){
- return detail::complex::cacos(z);
-}
-
-template <>
-__host__ __device__
-inline complex asin(const complex& z){
- return detail::complex::casin(z);
-}
-
-#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
-template <>
-__host__ __device__
-inline complex atan(const complex& z){
- return detail::complex::catan(z);
-}
-#endif
-
-template <>
-__host__ __device__
-inline complex acosh(const complex& z){
- return detail::complex::cacosh(z);
-}
-
-
-template <>
-__host__ __device__
-inline complex asinh(const complex& z){
- return detail::complex::casinh(z);
-}
-
-#if THRUST_CPP_DIALECT >= 2011 || THRUST_HOST_COMPILER != THRUST_HOST_COMPILER_MSVC
-template <>
-__host__ __device__
-inline complex atanh(const complex& z){
- return detail::complex::catanh(z);
-}
-#endif
-
-} // namespace thrust
diff --git a/spaces/CVPR/LIVE/thrust/thrust/optional.h b/spaces/CVPR/LIVE/thrust/thrust/optional.h
deleted file mode 100644
index 133deab56600d22f831be271888d643786f51011..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/optional.h
+++ /dev/null
@@ -1,2886 +0,0 @@
-///
-// optional - An implementation of std::optional with extensions
-// Written in 2017 by Simon Brand (@TartanLlama)
-//
-// To the extent possible under law, the author(s) have dedicated all
-// copyright and related and neighboring rights to this software to the
-// public domain worldwide. This software is distributed without any warranty.
-//
-// You should have received a copy of the CC0 Public Domain Dedication
-// along with this software. If not, see
-// .
-///
-
-#pragma once
-
-#include
-#include
-
-#if THRUST_CPP_DIALECT >= 2011
-
-#include
-#include
-
-#define THRUST_OPTIONAL_VERSION_MAJOR 0
-#define THRUST_OPTIONAL_VERSION_MINOR 2
-
-#include
-#include
-#include
-#include
-#include
-
-#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && _MSC_VER == 1900)
-#define THRUST_OPTIONAL_MSVC2015
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \
- !defined(__clang__))
-#define THRUST_OPTIONAL_GCC49
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && \
- !defined(__clang__))
-#define THRUST_OPTIONAL_GCC54
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && \
- !defined(__clang__))
-#define THRUST_OPTIONAL_GCC55
-#endif
-
-#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \
- !defined(__clang__))
-// GCC < 5 doesn't support overloading on const&& for member functions
-#define THRUST_OPTIONAL_NO_CONSTRR
-
-// GCC < 5 doesn't support some standard C++11 type traits
-#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
- std::has_trivial_copy_constructor::value
-#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign::value
-
-// GCC < 5 doesn't provide a way to emulate std::is_trivially_move_*,
-// so don't enable any optimizations that rely on them:
-#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) false
-#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) false
-
-// This one will be different for GCC 5.7 if it's ever supported
-#define THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible::value
-
-// GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks std::vector
-// for non-copyable types
-#elif (defined(__GNUC__) && __GNUC__ < 8 && \
- !defined(__clang__))
-#ifndef THRUST_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
-#define THRUST_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
-namespace thrust
-{
- namespace detail {
- template
- struct is_trivially_copy_constructible : std::is_trivially_copy_constructible{};
-#ifdef _GLIBCXX_VECTOR
- template
- struct is_trivially_copy_constructible>
- : std::is_trivially_copy_constructible{};
-#endif
- }
-} // end namespace thrust
-#endif
-
-#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
- thrust::detail::is_trivially_copy_constructible::value
-#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
- std::is_trivially_copy_assignable::value
-#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) \
- std::is_trivially_move_constructible::value
-#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) \
- std::is_trivially_move_assignable::value
-#define THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible::value
-#else
-
-// To support clang + old libstdc++ without type traits, check for equivalent
-// clang built-ins and use them if present. See note above
-// is_trivially_copyable_impl in
-// thrust/type_traits/is_trivially_relocatable.h for more details.
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if defined(__GLIBCXX__) && __has_feature(is_trivially_constructible)
-#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
- __is_trivially_constructible(T, T const&)
-#else
-#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
- std::is_trivially_copy_constructible::value
-#endif
-
-#if defined(__GLIBCXX__) && __has_feature(is_trivially_assignable)
-#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
- __is_trivially_assignable(T, T const&)
-#else
-#define THRUST_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
- std::is_trivially_copy_assignable::value
-#endif
-
-#if defined(__GLIBCXX__) && __has_feature(is_trivially_constructible)
-#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) \
- __is_trivially_constructible(T, T&&)
-#else
-#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE(T) \
- std::is_trivially_move_constructible::value
-#endif
-
-#if defined(__GLIBCXX__) && __has_feature(is_trivially_assignable)
-#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) \
- __is_trivially_assignable(T, T&&)
-#else
-#define THRUST_OPTIONAL_IS_TRIVIALLY_MOVE_ASSIGNABLE(T) \
- std::is_trivially_move_assignable::value
-#endif
-
-#if defined(__GLIBCXX__) && __has_feature(is_trivially_destructible)
-#define THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) \
- __is_trivially_destructible(T)
-#else
-#define THRUST_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) \
- std::is_trivially_destructible::value
-#endif
-
-#endif
-
-#if THRUST_CPP_DIALECT > 2011
-#define THRUST_OPTIONAL_CPP14
-#endif
-
-// constexpr implies const in C++11, not C++14
-#if (THRUST_CPP_DIALECT == 2011 || defined(THRUST_OPTIONAL_MSVC2015) || \
- defined(THRUST_OPTIONAL_GCC49))
-/// \exclude
-#define THRUST_OPTIONAL_CPP11_CONSTEXPR
-#else
-/// \exclude
-#define THRUST_OPTIONAL_CPP11_CONSTEXPR constexpr
-#endif
-
-namespace thrust
-{
-#ifndef THRUST_MONOSTATE_INPLACE_MUTEX
-#define THRUST_MONOSTATE_INPLACE_MUTEX
-/// \brief Used to represent an optional with no data; essentially a bool
-class monostate {};
-
-/// \brief A tag type to tell optional to construct its value in-place
-struct in_place_t {
- explicit in_place_t() = default;
-};
-/// \brief A tag to tell optional to construct its value in-place
-static constexpr in_place_t in_place{};
-#endif
-
-template class optional;
-
-/// \exclude
-namespace detail {
-#ifndef THRUST_TRAITS_MUTEX
-#define THRUST_TRAITS_MUTEX
-// C++14-style aliases for brevity
-template using remove_const_t = typename std::remove_const::type;
-template
-using remove_reference_t = typename std::remove_reference::type;
-template using decay_t = typename std::decay::type;
-template
-using enable_if_t = typename std::enable_if::type;
-template
-using conditional_t = typename std::conditional::type;
-
-// std::conjunction from C++17
-template struct conjunction : std::true_type {};
-template struct conjunction : B {};
-template
-struct conjunction
- : std::conditional, B>::type {};
-
-#if defined(_LIBCPP_VERSION) && THRUST_CPP_DIALECT == 2011
-#define THRUST_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
-#endif
-
-// In C++11 mode, there's an issue in libc++'s std::mem_fn
-// which results in a hard-error when using it in a noexcept expression
-// in some cases. This is a check to workaround the common failing case.
-#ifdef THRUST_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
-template struct is_pointer_to_non_const_member_func : std::false_type{};
-template
-struct is_pointer_to_non_const_member_func : std::true_type{};
-template
-struct is_pointer_to_non_const_member_func : std::true_type{};
-template
-struct is_pointer_to_non_const_member_func : std::true_type{};
-template
-struct is_pointer_to_non_const_member_func : std::true_type{};
-template
-struct is_pointer_to_non_const_member_func : std::true_type{};
-template
-struct is_pointer_to_non_const_member_func : std::true_type{};
-
-template struct is_const_or_const_ref : std::false_type{};
-template struct is_const_or_const_ref : std::true_type{};
-template struct is_const_or_const_ref : std::true_type{};
-#endif
-
-// std::invoke from C++17
-// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
-__thrust_exec_check_disable__
-template ::value
- && is_const_or_const_ref::value)>,
-#endif
- typename = enable_if_t>::value>,
- int = 0>
-__host__ __device__
-constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
- noexcept(std::mem_fn(f)(std::forward(args)...)))
- -> decltype(std::mem_fn(f)(std::forward(args)...)) {
- return std::mem_fn(f)(std::forward(args)...);
-}
-
-__thrust_exec_check_disable__
-template >::value>>
-__host__ __device__
-constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
- noexcept(std::forward(f)(std::forward(args)...)))
- -> decltype(std::forward(f)(std::forward