-
-
- How to Download Jigsaw Puzzles for Free on Your Device
-Now that you know what are jigsaw puzzles and why you should play them, you might be wondering how to download them for free on your device. Well, the good news is that there are many apps that offer free jigsaw puzzles for different devices and platforms. Here are some of the best apps for jigsaw puzzles on Android and Windows.
-The Best Apps for Jigsaw Puzzles on Android
-If you have an Android device, such as a phone or a tablet, you can download these apps for free from the Google Play Store and enjoy thousands of jigsaw puzzles with various themes and difficulty levels.
-Jigsaw Puzzles - puzzle games by Easybrain
-This app is one of the most popular and highly rated apps for jigsaw puzzles on Android. It has over 10,000 puzzles with stunning HD images of animals, nature, art, and more. You can choose from 9 to 400 pieces and adjust the rotation and zoom options. You can also create your own custom puzzles with your photos and share them with your friends. The app also has daily challenges, hints, and achievements to keep you motivated and entertained.
-Jigsawscapes - Jigsaw Puzzles by Banana Games
-This app is another great option for jigsaw puzzles on Android. It has over 5,000 puzzles with beautiful images of landscapes, cities, animals, and more. You can choose from 6 to 1,024 pieces and customize the shape and size of the pieces. You can also create your own custom puzzles with your photos and edit them with filters and stickers. The app also has daily quests, leaderboards, and rewards to make your puzzle experience more fun and exciting.
-The Best Apps for Jigsaw Puzzles on Windows
-If you have a Windows device, such as a PC or a laptop, you can download these apps for free from the Microsoft Store and enjoy hundreds of jigsaw puzzles with amazing graphics and sound effects.
-How to download jigsaw puzzles for free
-Best jigsaw puzzle games for Windows 10
-Download Microsoft Jigsaw from the Microsoft Store
-Jigsaw Puzzles - puzzle games by Easybrain
-Jigsawscapes - Jigsaw Puzzles by Banana Games
-Where to find HD jigsaw puzzle images
-Download jigsaw puzzles for offline play
-Jigsaw puzzle apps with daily challenges
-Create your own custom jigsaw puzzles
-Jigsaw puzzle games with rotation mode
-Jigsaw puzzles for adults and kids
-Download jigsaw puzzles with different difficulty levels
-Jigsaw puzzles with beautiful scenery and landscapes
-Jigsaw puzzles with animals, flowers, and nature
-Jigsaw puzzles with art, colors, and patterns
-Jigsaw Jam - a fun and fast-paced jigsaw game mode
-Download jigsaw puzzles with coins and rewards
-Jigsaw puzzles with hints and trays
-Jigsaw puzzles with zoom and auto arrange features
-Jigsaw puzzles with sound effects and music
-Download jigsaw puzzles from Google Play Store
-Jigsaw puzzles with no ads and in-app purchases
-Jigsaw puzzles with realistic physics and graphics
-Jigsaw puzzles with themes and collections
-Jigsaw puzzles with mystery and hidden pictures
-Download jigsaw puzzles for PC and tablet
-Jigsaw puzzles with Xbox Live integration
-Jigsaw puzzles with achievements and leaderboards
-Jigsaw puzzles with cloud save and sync
-Jigsaw puzzles with online and multiplayer modes
-Download jigsaw puzzles for Android and iOS devices
-Jigsaw puzzles with timer and score system
-Jigsaw puzzles with unlimited pieces and shapes
-Jigsaw puzzles with 3D and VR effects
-Jigsaw puzzles with celebrities and famous landmarks
-Download jigsaw puzzles for relaxation and stress relief
-Jigsaw puzzles with educational and trivia content
-Jigsaw puzzles with seasonal and holiday themes
-Jigsaw puzzles with cartoons and comics characters
-Jigsaw puzzles with movies and TV shows references
-Download jigsaw puzzles for fun and entertainment
-Jigsaw puzzles with brain teasers and logic problems
-Jigsaw puzzles with word search and crossword clues
-Jigsaw puzzles with sudoku and mahjong tiles
-Jigsaw puzzles with chess and checkers pieces
-Download jigsaw puzzles for learning and creativity
-Jigsaw puzzles with history and culture facts
-Jigsaw puzzles with science and technology topics
-Jigsaw puzzles with sports and hobbies images
Microsoft Jigsaw by Xbox Game Studios
-This app is one of the best apps for jigsaw puzzles on Windows. It has over 500 puzzles with stunning images of nature, art, animals, and more. You can choose from 4 to 400 pieces and adjust the difficulty level. You can also create your own custom puzzles with your photos and videos and save them to your personal collection. The app also has daily challenges, achievements, and leaderboards to challenge yourself and compete with other players.
How to Create Your Own Custom Jigsaw Puzzles
-If you want to make your jigsaw puzzle experience more personal and unique, you can create your own custom jigsaw puzzles with your photos or images. You can use the apps we mentioned above or you can use online tools that allow you to create and print your own jigsaw puzzles. Here are the steps and tips to create your own custom jigsaw puzzles.
-The Steps to Create Your Own Custom Jigsaw Puzzles
-Here are the basic steps to create your own custom jigsaw puzzles:
--
-
- Choose a photo or an image that you want to use for your puzzle. You can use your own photos or you can download free images from websites like Unsplash or Pixabay. -
- Upload your photo or image to an app or a website that allows you to create custom jigsaw puzzles. Some of the apps and websites that you can use are Jigsaw Puzzles - puzzle games by Easybrain, Jigsawscapes - Jigsaw Puzzles by Banana Games, Microsoft Jigsaw by Xbox Game Studios, Jigsaw Planet, and The Jigsaw Puzzles. -
- Select the number of pieces, the shape of the pieces, and the difficulty level for your puzzle. You can also add filters, stickers, text, or other effects to your photo or image if you want. -
- Preview your puzzle and make sure it looks good. You can also save it to your device or share it with your friends online. -
- If you want to print your puzzle, you can download it as a PDF file and print it on a thick paper or a cardboard. You can also order it online from websites like Shutterfly or Zazzle and have it delivered to your address. -
The Tips to Make Your Custom Jigsaw Puzzles More Fun and Challenging
-Here are some tips to make your custom jigsaw puzzles more fun and challenging:
--
-
- Choose a photo or an image that has a lot of details, colors, and contrast. This will make your puzzle more interesting and difficult to solve. -
- Choose a large number of pieces and a small size of pieces. This will make your puzzle more complex and time-consuming. -
- Choose an irregular shape of pieces and a random rotation of pieces. This will make your puzzle more unpredictable and tricky. -
- Do not look at the original photo or image while solving your puzzle. This will make your puzzle more challenging and rewarding. -
- Invite your friends or family to join you in solving your puzzle. This will make your puzzle more fun and social. -
Conclusion
-Jigsaw puzzles are great games that can provide you with hours of entertainment and relaxation. They can also improve your memory, concentration, creativity, problem-solving skills, stress relief, self-esteem, and satisfaction. You can download jigsaw puzzles for free on your device from various apps and websites, or you can create your own custom jigsaw puzzles with your photos or images. We hope this article has helped you to learn how to download jigsaw puzzles for free on your device and how to create your own custom jigsaw puzzles. Now, go ahead and enjoy some jigsaw puzzles!
-FAQs
-Here are some frequently asked questions about jigsaw puzzles:
--
-
- Q: How many pieces are in a typical jigsaw puzzle? -
- A: The number of pieces in a typical jigsaw puzzle can vary from 9 to 400 or more, depending on the size, shape, and difficulty level of the puzzle. The most common number of pieces is 100 for children's puzzles, 300 for medium puzzles, and 1000 for large puzzles. -
- Q: How long does it take to solve a jigsaw puzzle? -
- A: The time it takes to solve a jigsaw puzzle depends on several factors, such as the number of pieces, the shape of the pieces, the difficulty level of the puzzle, the image of the puzzle, the skill level of the solver, and the availability of hints. It can take anywhere from a few minutes to several hours or days to solve a jigsaw puzzle. -
- Q: What is the world record for solving a jigsaw puzzle? -
- A: The world record for solving a jigsaw puzzle is held by Joellen Beifuss from USA, who solved a 40,320-piece Disney-themed puzzle in 150 hours in 2019. The puzzle measured 6.8 x 1.9 meters (22 x 6 feet) and featured images from 10 Disney movies. -
- Q: What Q: What are some tips to solve jigsaw puzzles faster and easier? -
- A: Some tips to solve jigsaw puzzles faster and easier are: -
- Sort the pieces by color, shape, and edge. This will help you to organize the pieces and find the ones that match. -
- Start with the edge pieces and work your way inward. This will help you to create a frame and a reference for the puzzle. -
- Look at the picture of the puzzle frequently. This will help you to visualize the puzzle and remember the details. -
- Use a large and flat surface to work on. This will help you to spread out the pieces and see them clearly. -
- Take breaks and have fun. This will help you to avoid frustration and boredom and enjoy the puzzle. -
- Q: Where can I find more jigsaw puzzles to play online or offline? -
- A: You can find more jigsaw puzzles to play online or offline from various sources, such as: -
- Apps and websites that offer free or paid jigsaw puzzles, such as Jigsaw Puzzles - puzzle games by Easybrain, Jigsawscapes - Jigsaw Puzzles by Banana Games, Microsoft Jigsaw by Xbox Game Studios, Jigsaw Planet, and The Jigsaw Puzzles. -
- Online platforms that allow you to play jigsaw puzzles with other players, such as Jigsaw Explorer, Jigidi, and Puzzle Club. -
- Physical stores or online shops that sell jigsaw puzzles, such as Amazon, Walmart, Target, Barnes & Noble, and Puzzle Warehouse. -
-
-
-
-
-
-
\ No newline at end of file diff --git a/spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_inpaint_legacy.py b/spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_inpaint_legacy.py deleted file mode 100644 index 19a2e526372515520df679ff6e1ef6674dd2e95c..0000000000000000000000000000000000000000 --- a/spaces/1toTree/lora_test/ppdiffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_inpaint_legacy.py +++ /dev/null @@ -1,527 +0,0 @@ -# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved. -# Copyright 2022 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. - -import inspect -from typing import Callable, List, Optional, Union - -import numpy as np -import paddle -import PIL - -from paddlenlp.transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer - -from ...configuration_utils import FrozenDict -from ...models import AutoencoderKL, UNet2DConditionModel -from ...pipeline_utils import DiffusionPipeline -from ...schedulers import ( - DDIMScheduler, - DPMSolverMultistepScheduler, - EulerAncestralDiscreteScheduler, - EulerDiscreteScheduler, - LMSDiscreteScheduler, - PNDMScheduler, -) -from ...utils import PIL_INTERPOLATION, deprecate, logging -from . import StableDiffusionPipelineOutput -from .safety_checker import StableDiffusionSafetyChecker - -logger = logging.get_logger(__name__) - - -def preprocess_image(image): - w, h = image.size - w, h = map(lambda x: x - x % 32, (w, h)) # resize to integer multiple of 32 - image = image.resize((w, h), resample=PIL_INTERPOLATION["lanczos"]) - image = np.array(image).astype(np.float32) / 255.0 - image = image[None].transpose(0, 3, 1, 2) - image = paddle.to_tensor(image) - return 2.0 * image - 1.0 - - -def preprocess_mask(mask, scale_factor=8): - mask = mask.convert("L") - w, h = mask.size - w, h = map(lambda x: x - x % 32, (w, h)) # resize to integer multiple of 32 - mask = mask.resize((w // scale_factor, h // scale_factor), resample=PIL_INTERPOLATION["nearest"]) - mask = np.array(mask).astype(np.float32) / 255.0 - mask = np.tile(mask, (4, 1, 1)) - mask = mask[None].transpose(0, 1, 2, 3) # what does this step do? - mask = 1 - mask # repaint white, keep black - mask = paddle.to_tensor(mask) - return mask - - -class StableDiffusionInpaintPipelineLegacy(DiffusionPipeline): - r""" - Pipeline for text-guided image inpainting using Stable Diffusion. *This is an experimental feature*. - - 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 xxxx, etc.) - - Args: - vae ([`AutoencoderKL`]): - Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations. - text_encoder ([`CLIPTextModel`]): - Frozen text-encoder. Stable Diffusion uses the text portion of - [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically - the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant. - tokenizer (`CLIPTokenizer`): - Tokenizer of class - [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). - unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents. - scheduler ([`SchedulerMixin`]): - A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of - [`DDIMScheduler`], [`LMSDiscreteScheduler`], [`PNDMScheduler`], [`EulerDiscreteScheduler`], [`EulerAncestralDiscreteScheduler`] - or [`DPMSolverMultistepScheduler`]. - safety_checker ([`StableDiffusionSafetyChecker`]): - Classification module that estimates whether generated images could be considered offensive or harmful. - Please, refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for details. - feature_extractor ([`CLIPFeatureExtractor`]): - Model that extracts features from generated images to be used as inputs for the `safety_checker`. - """ - _optional_components = ["safety_checker", "feature_extractor"] - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.__init__ - def __init__( - self, - vae: AutoencoderKL, - text_encoder: CLIPTextModel, - tokenizer: CLIPTokenizer, - unet: UNet2DConditionModel, - scheduler: Union[ - DDIMScheduler, - PNDMScheduler, - LMSDiscreteScheduler, - EulerDiscreteScheduler, - EulerAncestralDiscreteScheduler, - DPMSolverMultistepScheduler, - ], - safety_checker: StableDiffusionSafetyChecker, - feature_extractor: CLIPFeatureExtractor, - requires_safety_checker: bool = True, - ): - super().__init__() - - if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1: - deprecation_message = ( - f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`" - f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure " - "to update the config accordingly as leaving `steps_offset` might led to incorrect results" - " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub," - " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`" - " file" - ) - deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False) - new_config = dict(scheduler.config) - new_config["steps_offset"] = 1 - scheduler._internal_dict = FrozenDict(new_config) - - if hasattr(scheduler.config, "clip_sample") and scheduler.config.clip_sample is True: - deprecation_message = ( - f"The configuration file of this scheduler: {scheduler} has not set the configuration `clip_sample`." - " `clip_sample` should be set to False in the configuration file. Please make sure to update the" - " config accordingly as not setting `clip_sample` in the config might lead to incorrect results in" - " future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very" - " nice if you could open a Pull request for the `scheduler/scheduler_config.json` file" - ) - deprecate("clip_sample not set", "1.0.0", deprecation_message, standard_warn=False) - new_config = dict(scheduler.config) - new_config["clip_sample"] = False - scheduler._internal_dict = FrozenDict(new_config) - - if safety_checker is None and requires_safety_checker: - logger.warning( - f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure" - " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered" - " results in services or applications open to the public. PaddleNLP team, diffusers team and Hugging Face" - " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling" - " it only for use-cases that involve analyzing network behavior or auditing its results. For more" - " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ." - ) - if safety_checker is not None and feature_extractor is None: - raise ValueError( - "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety" - " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead." - ) - - self.register_modules( - vae=vae, - text_encoder=text_encoder, - tokenizer=tokenizer, - unet=unet, - scheduler=scheduler, - safety_checker=safety_checker, - feature_extractor=feature_extractor, - ) - self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) - self.register_to_config(requires_safety_checker=requires_safety_checker) - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._encode_prompt - def _encode_prompt(self, prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt): - r""" - Encodes the prompt into text encoder hidden states. - - Args: - prompt (`str` or `list(int)`): - prompt to be encoded - num_images_per_prompt (`int`): - number of images that should be generated per prompt - do_classifier_free_guidance (`bool`): - whether to use classifier free guidance or not - negative_prompt (`str` or `List[str]`): - The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored - if `guidance_scale` is less than `1`). - """ - batch_size = len(prompt) if isinstance(prompt, list) else 1 - - text_inputs = self.tokenizer( - prompt, - padding="max_length", - max_length=self.tokenizer.model_max_length, - truncation=True, - return_tensors="pd", - ) - text_input_ids = text_inputs.input_ids - untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pd").input_ids - - if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not paddle.equal_all( - text_input_ids, untruncated_ids - ): - removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]) - logger.warning( - "The following part of your input was truncated because CLIP can only handle sequences up to" - f" {self.tokenizer.model_max_length} tokens: {removed_text}" - ) - - config = ( - self.text_encoder.config - if isinstance(self.text_encoder.config, dict) - else self.text_encoder.config.to_dict() - ) - if config.get("use_attention_mask", None) is not None and config["use_attention_mask"]: - attention_mask = text_inputs.attention_mask - else: - attention_mask = None - - text_embeddings = self.text_encoder( - text_input_ids, - attention_mask=attention_mask, - ) - text_embeddings = text_embeddings[0] - - # duplicate text embeddings for each generation per prompt, using mps friendly method - bs_embed, seq_len, _ = text_embeddings.shape - text_embeddings = text_embeddings.tile([1, num_images_per_prompt, 1]) - text_embeddings = text_embeddings.reshape([bs_embed * num_images_per_prompt, seq_len, -1]) - - # get unconditional embeddings for classifier free guidance - if do_classifier_free_guidance: - uncond_tokens: List[str] - if negative_prompt is None: - uncond_tokens = [""] * batch_size - elif type(prompt) is not type(negative_prompt): - raise TypeError( - f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !=" - f" {type(prompt)}." - ) - elif isinstance(negative_prompt, str): - uncond_tokens = [negative_prompt] * batch_size - elif batch_size != len(negative_prompt): - raise ValueError( - f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:" - f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches" - " the batch size of `prompt`." - ) - else: - uncond_tokens = negative_prompt - - max_length = text_input_ids.shape[-1] - uncond_input = self.tokenizer( - uncond_tokens, - padding="max_length", - max_length=max_length, - truncation=True, - return_tensors="pd", - ) - - if config.get("use_attention_mask", None) is not None and config["use_attention_mask"]: - attention_mask = uncond_input.attention_mask - else: - attention_mask = None - - uncond_embeddings = self.text_encoder( - uncond_input.input_ids, - attention_mask=attention_mask, - ) - uncond_embeddings = uncond_embeddings[0] - - # duplicate unconditional embeddings for each generation per prompt, using mps friendly method - seq_len = uncond_embeddings.shape[1] - uncond_embeddings = uncond_embeddings.tile([1, num_images_per_prompt, 1]) - uncond_embeddings = uncond_embeddings.reshape([batch_size * num_images_per_prompt, seq_len, -1]) - - # For classifier free guidance, we need to do two forward passes. - # Here we concatenate the unconditional and text embeddings into a single batch - # to avoid doing two forward passes - text_embeddings = paddle.concat([uncond_embeddings, text_embeddings]) - - return text_embeddings - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.run_safety_checker - def run_safety_checker(self, image, dtype): - if self.safety_checker is not None: - safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pd") - image, has_nsfw_concept = self.safety_checker( - images=image, clip_input=safety_checker_input.pixel_values.cast(dtype) - ) - else: - has_nsfw_concept = None - return image, has_nsfw_concept - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.decode_latents - def decode_latents(self, latents): - latents = 1 / 0.18215 * latents - image = self.vae.decode(latents).sample - image = (image / 2 + 0.5).clip(0, 1) - # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16 - image = image.transpose([0, 2, 3, 1]).cast("float32").numpy() - return image - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs - def prepare_extra_step_kwargs(self, generator, eta): - # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature - # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. - # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 - # and should be between [0, 1] - - accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys()) - extra_step_kwargs = {} - if accepts_eta: - extra_step_kwargs["eta"] = eta - - # check if the scheduler accepts generator - accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys()) - if accepts_generator: - extra_step_kwargs["generator"] = generator - return extra_step_kwargs - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.check_inputs - def check_inputs(self, prompt, strength, callback_steps): - if not isinstance(prompt, str) and not isinstance(prompt, list): - raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") - - if strength < 0 or strength > 1: - raise ValueError(f"The value of strength should in [1.0, 1.0] but is {strength}") - - if (callback_steps is None) or ( - callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0) - ): - raise ValueError( - f"`callback_steps` has to be a positive integer but is {callback_steps} of type" - f" {type(callback_steps)}." - ) - - # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.get_timesteps - def get_timesteps(self, num_inference_steps, strength): - # get the original timestep using init_timestep - init_timestep = min(int(num_inference_steps * strength), num_inference_steps) - - t_start = max(num_inference_steps - init_timestep, 0) - timesteps = self.scheduler.timesteps[t_start:] - - return timesteps, num_inference_steps - t_start - - def prepare_latents(self, image, timestep, batch_size, num_images_per_prompt, dtype, generator): - image = image.cast(dtype) - init_latent_dist = self.vae.encode(image).latent_dist - init_latents = init_latent_dist.sample(generator=generator) - init_latents = 0.18215 * init_latents - - # Expand init_latents for batch_size and num_images_per_prompt - init_latents = paddle.concat([init_latents] * batch_size * num_images_per_prompt, axis=0) - init_latents_orig = init_latents - - # add noise to latents using the timesteps - noise = paddle.randn(init_latents.shape, generator=generator, dtype=dtype) - init_latents = self.scheduler.add_noise(init_latents, noise, timestep) - latents = init_latents - return latents, init_latents_orig, noise - - @paddle.no_grad() - def __call__( - self, - prompt: Union[str, List[str]], - image: Union[paddle.Tensor, PIL.Image.Image] = None, - mask_image: Union[paddle.Tensor, PIL.Image.Image] = None, - strength: float = 0.8, - num_inference_steps: Optional[int] = 50, - guidance_scale: Optional[float] = 7.5, - negative_prompt: Optional[Union[str, List[str]]] = None, - num_images_per_prompt: Optional[int] = 1, - add_predicted_noise: Optional[bool] = False, - eta: Optional[float] = 0.0, - generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None, - output_type: Optional[str] = "pil", - return_dict: bool = True, - callback: Optional[Callable[[int, int, paddle.Tensor], None]] = None, - callback_steps: Optional[int] = 1, - ): - r""" - Function invoked when calling the pipeline for generation. - - Args: - prompt (`str` or `List[str]`): - The prompt or prompts to guide the image generation. - image (`paddle.Tensor` or `PIL.Image.Image`): - `Image`, or tensor representing an image batch, that will be used as the starting point for the - process. This is the image whose masked region will be inpainted. - mask_image (`paddle.Tensor` or `PIL.Image.Image`): - `Image`, or tensor representing an image batch, to mask `image`. White pixels in the mask will be - replaced by noise and therefore repainted, while black pixels will be preserved. If `mask_image` is a - PIL image, it will be converted to a single channel (luminance) before use. If it's a tensor, it should - contain one color channel (L) instead of 3, so the expected shape would be `(B, H, W, 1)`. - strength (`float`, *optional*, defaults to 0.8): - Conceptually, indicates how much to inpaint the masked area. Must be between 0 and 1. When `strength` - is 1, the denoising process will be run on the masked area for the full number of iterations specified - in `num_inference_steps`. `image` will be used as a reference for the masked area, adding more - noise to that region the larger the `strength`. If `strength` is 0, no inpainting will occur. - num_inference_steps (`int`, *optional*, defaults to 50): - The reference number of denoising steps. More denoising steps usually lead to a higher quality image at - the expense of slower inference. This parameter will be modulated by `strength`, as explained above. - guidance_scale (`float`, *optional*, defaults to 7.5): - Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). - `guidance_scale` is defined as `w` of equation 2. of [Imagen - Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > - 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, - usually at the expense of lower image quality. - negative_prompt (`str` or `List[str]`, *optional*): - The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored - if `guidance_scale` is less than `1`). - num_images_per_prompt (`int`, *optional*, defaults to 1): - The number of images to generate per prompt. - add_predicted_noise (`bool`, *optional*, defaults to True): - Use predicted noise instead of random noise when constructing noisy versions of the original image in - the reverse diffusion process - eta (`float`, *optional*, defaults to 0.0): - Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to - [`schedulers.DDIMScheduler`], will be ignored for others. - generator (`paddle.Generator`, *optional*): - One or a list of paddle generator(s) to make generation deterministic. - 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.stable_diffusion.StableDiffusionPipelineOutput`] instead of a - plain tuple. - callback (`Callable`, *optional*): - A function that will be called every `callback_steps` steps during inference. The function will be - called with the following arguments: `callback(step: int, timestep: int, latents: paddle.Tensor)`. - callback_steps (`int`, *optional*, defaults to 1): - The frequency at which the `callback` function will be called. If not specified, the callback will be - called at every step. - - Returns: - [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`: - [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple. - When returning a tuple, the first element is a list with the generated images, and the second element is a - list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" - (nsfw) content, according to the `safety_checker`. - """ - # 1. Check inputs - self.check_inputs(prompt, strength, callback_steps) - - # 2. Define call parameters - batch_size = 1 if isinstance(prompt, str) else len(prompt) - # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) - # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` - # corresponds to doing no classifier free guidance. - do_classifier_free_guidance = guidance_scale > 1.0 - - # 3. Encode input prompt - text_embeddings = self._encode_prompt( - prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt - ) - - # 4. Preprocess image and mask - if not isinstance(image, paddle.Tensor): - image = preprocess_image(image) - - if not isinstance(mask_image, paddle.Tensor): - mask_image = preprocess_mask(mask_image, self.vae_scale_factor) - - # 5. set timesteps - self.scheduler.set_timesteps(num_inference_steps) - timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength) - latent_timestep = timesteps[:1].tile([batch_size * num_images_per_prompt]) - - # 6. Prepare latent variables - # encode the init image into latents and scale the latents - latents, init_latents_orig, noise = self.prepare_latents( - image, latent_timestep, batch_size, num_images_per_prompt, text_embeddings.dtype, generator - ) - - # 7. Prepare mask latent - mask = mask_image.cast(latents.dtype) - mask = paddle.concat([mask] * batch_size * num_images_per_prompt) - - # 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline - extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) - - # 9. Denoising loop - num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order - with self.progress_bar(total=num_inference_steps) as progress_bar: - for i, t in enumerate(timesteps): - # expand the latents if we are doing classifier free guidance - latent_model_input = paddle.concat([latents] * 2) if do_classifier_free_guidance else latents - latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) - - # predict the noise residual - noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample - - # perform guidance - if do_classifier_free_guidance: - noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) - noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) - - # compute the previous noisy sample x_t -> x_t-1 - latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample - # masking - if add_predicted_noise: - init_latents_proper = self.scheduler.add_noise(init_latents_orig, noise_pred_uncond, t) - else: - init_latents_proper = self.scheduler.add_noise(init_latents_orig, noise, t) - - latents = (init_latents_proper * mask) + (latents * (1 - mask)) - - # call the callback, if provided - if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): - progress_bar.update() - if callback is not None and i % callback_steps == 0: - callback(i, t, latents) - - # 10. Post-processing - image = self.decode_latents(latents) - - # 11. Run safety checker - image, has_nsfw_concept = self.run_safety_checker(image, text_embeddings.dtype) - - # 12. Convert to PIL - if output_type == "pil": - image = self.numpy_to_pil(image) - - if not return_dict: - return (image, has_nsfw_concept) - - return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept) diff --git a/spaces/4F22/text_generator/app.py b/spaces/4F22/text_generator/app.py deleted file mode 100644 index f1d4beb0a8f3cee27903f527b6bf8daa485a75a0..0000000000000000000000000000000000000000 --- a/spaces/4F22/text_generator/app.py +++ /dev/null @@ -1,3 +0,0 @@ -import gradio as gr - -gr.Interface.load("huggingface/gpt2").launch() \ No newline at end of file diff --git a/spaces/4Taps/SadTalker/src/face3d/options/base_options.py b/spaces/4Taps/SadTalker/src/face3d/options/base_options.py deleted file mode 100644 index d8f921d5a43434ae802a55a0fa3889c4b7ab9f6d..0000000000000000000000000000000000000000 --- a/spaces/4Taps/SadTalker/src/face3d/options/base_options.py +++ /dev/null @@ -1,169 +0,0 @@ -"""This script contains base options for Deep3DFaceRecon_pytorch -""" - -import argparse -import os -from util import util -import numpy as np -import torch -import face3d.models as models -import face3d.data as data - - -class BaseOptions(): - """This class defines options used during both training and test time. - - It also implements several helper functions such as parsing, printing, and saving the options. - It also gathers additional options defined in
-
-YOLOv5-l-P5 model structure
-
-
-
-YOLOv5-l-P5 model structure
-
-
-YOLOv5-l-P6 model structure
-
-
-## Results and models
-
-### COCO
-
-| Backbone | Arch | size | SyncBN | AMP | Mem (GB) | box AP | TTA box AP | Config | Download |
-| :------: | :--: | :--: | :----: | :-: | :------: | :----: | :--------: | :--------------------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-| YOLOv5-n | P5 | 640 | Yes | Yes | 1.5 | 28.0 | 30.7 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco/yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739-b804c1ad.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_syncbn_fast_8xb16-300e_coco/yolov5_n-v61_syncbn_fast_8xb16-300e_coco_20220919_090739.log.json) |
-| YOLOv5-s | P5 | 640 | Yes | Yes | 2.7 | 37.7 | 40.2 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700-86e02187.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_syncbn_fast_8xb16-300e_coco/yolov5_s-v61_syncbn_fast_8xb16-300e_coco_20220918_084700.log.json) |
-| YOLOv5-m | P5 | 640 | Yes | Yes | 5.0 | 45.3 | 46.9 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944-516a710f.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_syncbn_fast_8xb16-300e_coco/yolov5_m-v61_syncbn_fast_8xb16-300e_coco_20220917_204944.log.json) |
-| YOLOv5-l | P5 | 640 | Yes | Yes | 8.1 | 48.8 | 49.9 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco/yolov5_l-v61_syncbn_fast_8xb16-300e_coco_20220917_031007-096ef0eb.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_syncbn_fast_8xb16-300e_coco/yolov5_l-v61_syncbn_fast_8xb16-300e_coco_20220917_031007.log.json) |
-| YOLOv5-n | P6 | 1280 | Yes | Yes | 5.8 | 35.9 | | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_224705-d493c5f3.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_n-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_224705.log.json) |
-| YOLOv5-s | P6 | 1280 | Yes | Yes | 10.5 | 44.4 | | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_215044-58865c19.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_215044.log.json) |
-| YOLOv5-m | P6 | 1280 | Yes | Yes | 19.1 | 51.3 | | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_230453-49564d58.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_m-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_230453.log.json) |
-| YOLOv5-l | P6 | 1280 | Yes | Yes | 30.5 | 53.7 | | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_234308-7a2ba6bf.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco/yolov5_l-p6-v62_syncbn_fast_8xb16-300e_coco_20221027_234308.log.json) |
-
-**Note**:
-In the official YOLOv5 code, the `random_perspective` data augmentation in COCO object detection task training uses mask annotation information, which leads to higher performance. Object detection should not use mask annotation, so only box annotation information is used in `MMYOLO`. We will use the mask annotation information in the instance segmentation task. See https://github.com/ultralytics/yolov5/issues/9917 for details.
-
-1. `fast` means that `YOLOv5DetDataPreprocessor` and `yolov5_collate` are used for data preprocessing, which is faster for training, but less flexible for multitasking. Recommended to use fast version config if you only care about object detection.
-2. `detect` means that the network input is fixed to `640x640` and the post-processing thresholds is modified.
-3. `SyncBN` means use SyncBN, `AMP` indicates training with mixed precision.
-4. We use 8x A100 for training, and the single-GPU batch size is 16. This is different from the official code.
-5. The performance is unstable and may fluctuate by about 0.4 mAP and the highest performance weight in `COCO` training in `YOLOv5` may not be the last epoch.
-6. `TTA` means that Test Time Augmentation. It's perform 3 multi-scaling transformations on the image, followed by 2 flipping transformations (flipping and not flipping). You only need to specify `--tta` when testing to enable. see [TTA](https://github.com/open-mmlab/mmyolo/blob/dev/docs/en/common_usage/tta.md) for details.
-
-### VOC
-
-| Backbone | size | Batchsize | AMP | Mem (GB) | box AP(COCO metric) | Config | Download |
-| :------: | :--: | :-------: | :-: | :------: | :-----------------: | :------------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-| YOLOv5-n | 512 | 64 | Yes | 3.5 | 51.2 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/voc/yolov5_n-v61_fast_1xb64-50e_voc.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_fast_1xb64-50e_voc/yolov5_n-v61_fast_1xb64-50e_voc_20221017_234254-f1493430.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_n-v61_fast_1xb64-50e_voc/yolov5_n-v61_fast_1xb64-50e_voc_20221017_234254.log.json) |
-| YOLOv5-s | 512 | 64 | Yes | 6.5 | 62.7 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/voc/yolov5_s-v61_fast_1xb64-50e_voc.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_fast_1xb64-50e_voc/yolov5_s-v61_fast_1xb64-50e_voc_20221017_234156-0009b33e.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_s-v61_fast_1xb64-50e_voc/yolov5_s-v61_fast_1xb64-50e_voc_20221017_234156.log.json) |
-| YOLOv5-m | 512 | 64 | Yes | 12.0 | 70.1 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/voc/yolov5_m-v61_fast_1xb64-50e_voc.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_fast_1xb64-50e_voc/yolov5_m-v61_fast_1xb64-50e_voc_20221017_114138-815c143a.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_m-v61_fast_1xb64-50e_voc/yolov5_m-v61_fast_1xb64-50e_voc_20221017_114138.log.json) |
-| YOLOv5-l | 512 | 32 | Yes | 10.0 | 73.1 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/voc/yolov5_l-v61_fast_1xb32-50e_voc.py) | [model](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_fast_1xb32-50e_voc/yolov5_l-v61_fast_1xb32-50e_voc_20221017_045500-edc7e0d8.pth) \| [log](https://download.openmmlab.com/mmyolo/v0/yolov5/yolov5_l-v61_fast_1xb32-50e_voc/yolov5_l-v61_fast_1xb32-50e_voc_20221017_045500.log.json) |
-
-**Note**:
-
-1. Training on VOC dataset need pretrained model which trained on COCO.
-2. The performance is unstable and may fluctuate by about 0.4 mAP.
-3. Official YOLOv5 use COCO metric, while training VOC dataset.
-4. We converted the VOC test dataset to COCO format offline, while reproducing mAP result as shown above. We will support to use COCO metric while training VOC dataset in later version.
-5. Hyperparameter reference from `https://wandb.ai/glenn-jocher/YOLOv5_VOC_official`.
-
-### CrowdHuman
-
-Since the `iscrowd` annotation of the COCO dataset is not equivalent to `ignore`, we use the CrowdHuman dataset to verify that the YOLOv5 ignore logic is correct.
-
-| Backbone | size | SyncBN | AMP | Mem (GB) | ignore_iof_thr | box AP50(CrowDHuman Metric) | MR | JI | Config | Download |
-| :------: | :--: | :----: | :-: | :------: | :------------: | :-------------------------: | :--: | :---: | :-----------------------------------------------------------------------------------------------------------------------------: | :------: |
-| YOLOv5-s | 640 | Yes | Yes | 2.6 | -1 | 85.79 | 48.7 | 75.33 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/crowdhuman/yolov5_s-v61_fast_8xb16-300e_crowdhuman.py) | |
-| YOLOv5-s | 640 | Yes | Yes | 2.6 | 0.5 | 86.17 | 48.8 | 75.87 | [config](https://github.com/open-mmlab/mmyolo/tree/main/configs/yolov5/crowdhuman/yolov5_s-v61_8xb16-300e_ignore_crowdhuman.py) | |
-
-**Note**:
-
-1. `ignore_iof_thr` is -1 indicating that the ignore tag is not considered. We adjusted with `ignore_iof_thr` thresholds of 0.5, 0.8, 0.9, and the results show that 0.5 has the best performance.
-2. The above table shows the performance of the model with the best performance on the validation set. The best performing models are around 160+ epoch which means that there is no need to train so many epochs.
-3. This is a very simple implementation that simply replaces COCO's anchor with the `tools/analysis_tools/optimize_anchors.py` script. We'll adjust other parameters later to improve performance.
-
-## Citation
-
-```latex
-@software{glenn_jocher_2022_7002879,
- author = {Glenn Jocher and
- Ayush Chaurasia and
- Alex Stoken and
- Jirka Borovec and
- NanoCode012 and
- Yonghye Kwon and
- TaoXie and
- Kalen Michael and
- Jiacong Fang and
- imyhxy and
- Lorna and
- Colin Wong and
- 曾逸夫(Zeng Yifu) and
- Abhiram V and
- Diego Montes and
- Zhiqiang Wang and
- Cristi Fati and
- Jebastin Nadar and
- Laughing and
- UnglvKitDe and
- tkianai and
- yxNONG and
- Piotr Skalski and
- Adam Hogan and
- Max Strobel and
- Mrinal Jain and
- Lorenzo Mammana and
- xylieong},
- title = {{ultralytics/yolov5: v6.2 - YOLOv5 Classification
- Models, Apple M1, Reproducibility, ClearML and
- Deci.ai integrations}},
- month = aug,
- year = 2022,
- publisher = {Zenodo},
- version = {v6.2},
- doi = {10.5281/zenodo.7002879},
- url = {https://doi.org/10.5281/zenodo.7002879}
-}
-```
diff --git a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet34_8xb16_cifar10.py b/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet34_8xb16_cifar10.py
deleted file mode 100644
index 7f5cd517d505ea479b506b6e4756c117c392dabd..0000000000000000000000000000000000000000
--- a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/resnet/resnet34_8xb16_cifar10.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = [
- '../_base_/models/resnet34_cifar.py', '../_base_/datasets/cifar10_bs16.py',
- '../_base_/schedules/cifar10_bs128.py', '../_base_/default_runtime.py'
-]
diff --git a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/Dfehub.py b/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/Dfehub.py
deleted file mode 100644
index 2f66f19b50b6b4ab79c012f123c47241141942eb..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/Dfehub.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import os
-import requests
-from ...typing import sha256, Dict, get_type_hints
-
-url = "https://chat.dfehub.com"
-model = ['gpt-3.5-turbo', 'gpt-3.5-turbo-16k', 'gpt-4']
-supports_stream = True
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- headers = {
- 'Authority': 'chat.dfehub.com',
- 'Content-Type': 'application/json',
- 'Method': 'POST',
- 'Path': '/api/openai/v1/chat/completions',
- 'Scheme': 'https',
- 'Accept': 'text/event-stream',
- 'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7,zh-CN;q=0.6,zh;q=0.5',
- 'Content-Type': 'application/json',
- 'Origin': 'https://chat.dfehub.com',
- 'Referer': 'https://chat.dfehub.com/',
- 'Sec-Ch-Ua': '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
- 'Sec-Ch-Ua-Mobile': '?0',
- 'Sec-Ch-Ua-Platform': '"Windows"',
- 'Sec-Fetch-Dest': 'empty',
- 'Sec-Fetch-Mode': 'cors',
- 'Sec-Fetch-Site': 'same-origin',
- 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
- 'X-Requested-With': 'XMLHttpRequest',
- }
-
- data = {
- 'model': model,
- 'temperature': 0.7,
- 'max_tokens': '8000',
- 'presence_penalty': 0,
- 'messages': messages,
- }
-
- response = requests.post(url + '/api/openai/v1/chat/completions',
- headers=headers, json=data, stream=stream)
-
- yield response.json()['choices'][0]['message']['content']
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
- '(%s)' % ', '.join(
- [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])
diff --git a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/deprecated/CodeLinkAva.py b/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/deprecated/CodeLinkAva.py
deleted file mode 100644
index 8407ebb91a91019eabe338a23837d9efa467fcaa..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/deprecated/CodeLinkAva.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession
-import json
-
-from ...typing import AsyncGenerator
-from ..base_provider import AsyncGeneratorProvider
-
-
-class CodeLinkAva(AsyncGeneratorProvider):
- url = "https://ava-ai-ef611.web.app"
- supports_gpt_35_turbo = True
- working = False
-
- @classmethod
- async def create_async_generator(
- cls,
- model: str,
- messages: list[dict[str, str]],
- **kwargs
- ) -> AsyncGenerator:
- headers = {
- "User-Agent" : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
- "Accept" : "*/*",
- "Accept-language" : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
- "Origin" : cls.url,
- "Referer" : cls.url + "/",
- "Sec-Fetch-Dest" : "empty",
- "Sec-Fetch-Mode" : "cors",
- "Sec-Fetch-Site" : "same-origin",
- }
- async with ClientSession(
- headers=headers
- ) as session:
- data = {
- "messages": messages,
- "temperature": 0.6,
- "stream": True,
- **kwargs
- }
- async with session.post("https://ava-alpha-api.codelink.io/api/chat", json=data) as response:
- response.raise_for_status()
- async for line in response.content:
- line = line.decode()
- if line.startswith("data: "):
- if line.startswith("data: [DONE]"):
- break
- line = json.loads(line[6:-1])
- content = line["choices"][0]["delta"].get("content")
- if content:
- yield content
-
-
- @classmethod
- @property
- def params(cls):
- params = [
- ("model", "str"),
- ("messages", "list[dict[str, str]]"),
- ("stream", "bool"),
- ("temperature", "float"),
- ]
- param = ", ".join([": ".join(p) for p in params])
- return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/radio/Factory.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/radio/Factory.js
deleted file mode 100644
index a6f52cb02f4632c401342ad938966af9f5d9fe34..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/radio/Factory.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import Radio from './Radio.js';
-import ObjectFactory from '../ObjectFactory.js';
-import SetValue from '../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('radio', function (config) {
- var gameObject = new Radio(this.scene, config);
- this.scene.add.existing(gameObject);
- return gameObject;
-});
-
-SetValue(window, 'RexPlugins.Spinner.Radio', Radio);
-
-export default Radio;
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/gridtable/Factory.js b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/gridtable/Factory.js
deleted file mode 100644
index ae03ac32ca207ddd95b4bb6638a06ce554db40cb..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/gridtable/Factory.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import GridTable from './GridTable.js';
-import ObjectFactory from '../ObjectFactory.js';
-import SetValue from '../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('gridTable', function (config) {
- var gameObject = new GridTable(this.scene, config);
- this.scene.add.existing(gameObject);
- return gameObject;
-});
-
-SetValue(window, 'RexPlugins.UI.GridTable', GridTable);
-
-export default GridTable;
\ No newline at end of file
diff --git a/spaces/Ajaxon6255/Emerald_Isle/app.py b/spaces/Ajaxon6255/Emerald_Isle/app.py
deleted file mode 100644
index 85dc00ec95fc8257f94ab31dc2287bf745471d57..0000000000000000000000000000000000000000
--- a/spaces/Ajaxon6255/Emerald_Isle/app.py
+++ /dev/null
@@ -1,147 +0,0 @@
-import time
-
-from theme_dropdown import create_theme_dropdown # noqa: F401
-
-import gradio as gr
-
-dropdown, js = create_theme_dropdown()
-
-with gr.Blocks(theme='Ajaxon6255/Emerald_Isle') as demo:
- with gr.Row().style(equal_height=True):
- with gr.Column(scale=10):
- gr.Markdown(
- """
- # Theme preview: `Emerald_Isle`
- To use this theme, set `theme='Ajaxon6255/Emerald_Isle'` in `gr.Blocks()` or `gr.Interface()`.
- You can append an `@` and a semantic version expression, e.g. @>=1.0.0,<2.0.0 to pin to a given version
- of this theme.
- """
- )
- with gr.Column(scale=3):
- with gr.Box():
- dropdown.render()
- toggle_dark = gr.Button(value="Toggle Dark").style(full_width=True)
-
- dropdown.change(None, dropdown, None, _js=js)
- toggle_dark.click(
- None,
- _js="""
- () => {
- document.body.classList.toggle('dark');
- document.querySelector('gradio-app').style.backgroundColor = 'var(--color-background-primary)'
- }
- """,
- )
-
- name = gr.Textbox(
- label="Name",
- info="Full name, including middle name. No special characters.",
- placeholder="John Doe",
- value="John Doe",
- interactive=True,
- )
-
- with gr.Row():
- slider1 = gr.Slider(label="Slider 1")
- slider2 = gr.Slider(label="Slider 2")
- gr.CheckboxGroup(["A", "B", "C"], label="Checkbox Group")
-
- with gr.Row():
- with gr.Column(variant="panel", scale=1):
- gr.Markdown("## Panel 1")
- radio = gr.Radio(
- ["A", "B", "C"],
- label="Radio",
- info="Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.",
- )
- drop = gr.Dropdown(["Option 1", "Option 2", "Option 3"], show_label=False)
- drop_2 = gr.Dropdown(
- ["Option A", "Option B", "Option C"],
- multiselect=True,
- value=["Option A"],
- label="Dropdown",
- interactive=True,
- )
- check = gr.Checkbox(label="Go")
- with gr.Column(variant="panel", scale=2):
- img = gr.Image(
- "https://gradio.app/assets/img/header-image.jpg", label="Image"
- ).style(height=320)
- with gr.Row():
- go_btn = gr.Button("Go", label="Primary Button", variant="primary")
- clear_btn = gr.Button(
- "Clear", label="Secondary Button", variant="secondary"
- )
-
- def go(*args):
- time.sleep(3)
- return "https://gradio.app/assets/img/header-image.jpg"
-
- go_btn.click(go, [radio, drop, drop_2, check, name], img, api_name="go")
-
- def clear():
- time.sleep(0.2)
- return None
-
- clear_btn.click(clear, None, img)
-
- with gr.Row():
- btn1 = gr.Button("Button 1").style(size="sm")
- btn2 = gr.UploadButton().style(size="sm")
- stop_btn = gr.Button("Stop", label="Stop Button", variant="stop").style(
- size="sm"
- )
-
- with gr.Row():
- gr.Dataframe(value=[[1, 2, 3], [4, 5, 6], [7, 8, 9]], label="Dataframe")
- gr.JSON(
- value={"a": 1, "b": 2, "c": {"test": "a", "test2": [1, 2, 3]}}, label="JSON"
- )
- gr.Label(value={"cat": 0.7, "dog": 0.2, "fish": 0.1})
- gr.File()
- with gr.Row():
- gr.ColorPicker()
- gr.Video("https://gradio-static-files.s3.us-west-2.amazonaws.com/world.mp4")
- gr.Gallery(
- [
- (
- "https://gradio-static-files.s3.us-west-2.amazonaws.com/lion.jpg",
- "lion",
- ),
- (
- "https://gradio-static-files.s3.us-west-2.amazonaws.com/logo.png",
- "logo",
- ),
- (
- "https://gradio-static-files.s3.us-west-2.amazonaws.com/tower.jpg",
- "tower",
- ),
- ]
- ).style(height="200px", grid=2)
-
- with gr.Row():
- with gr.Column(scale=2):
- chatbot = gr.Chatbot([("Hello", "Hi")], label="Chatbot")
- chat_btn = gr.Button("Add messages")
-
- def chat(history):
- time.sleep(2)
- yield [["How are you?", "I am good."]]
-
- chat_btn.click(
- lambda history: history
- + [["How are you?", "I am good."]]
- + (time.sleep(2) or []),
- chatbot,
- chatbot,
- )
- with gr.Column(scale=1):
- with gr.Accordion("Advanced Settings"):
- gr.Markdown("Hello")
- gr.Number(label="Chatbot control 1")
- gr.Number(label="Chatbot control 2")
- gr.Number(label="Chatbot control 3")
-
-
-if __name__ == "__main__":
- demo.queue().launch()
diff --git a/spaces/AlexWang/lama/models/ade20k/segm_lib/utils/data/__init__.py b/spaces/AlexWang/lama/models/ade20k/segm_lib/utils/data/__init__.py
deleted file mode 100644
index f3b008fb13c5e8a84b1b785056e8c4f5226dc976..0000000000000000000000000000000000000000
--- a/spaces/AlexWang/lama/models/ade20k/segm_lib/utils/data/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-
-from .dataset import Dataset, TensorDataset, ConcatDataset
-from .dataloader import DataLoader
diff --git a/spaces/Amrrs/DragGan-Inversion/scripts/download_model.sh b/spaces/Amrrs/DragGan-Inversion/scripts/download_model.sh
deleted file mode 100644
index 4d2dcccd256f5a6b941ebb8b8e99e4f68e001875..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/scripts/download_model.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-mkdir checkpoints
-cd checkpoints
-
-wget https://storage.googleapis.com/self-distilled-stylegan/lions_512_pytorch.pkl
-mv lions_512_pytorch.pkl stylegan2_lions_512_pytorch.pkl
-
-wget https://storage.googleapis.com/self-distilled-stylegan/dogs_1024_pytorch.pkl
-mv dogs_1024_pytorch.pkl stylegan2_dogs_1024_pytorch.pkl
-
-wget https://storage.googleapis.com/self-distilled-stylegan/horses_256_pytorch.pkl
-mv horses_256_pytorch.pkl stylegan2_horses_256_pytorch.pkl
-
-wget https://storage.googleapis.com/self-distilled-stylegan/elephants_512_pytorch.pkl
-mv elephants_512_pytorch.pkl stylegan2_elephants_512_pytorch.pkl
-
-wget https://api.ngc.nvidia.com/v2/models/nvidia/research/stylegan2/versions/1/files/stylegan2-ffhq-512x512.pkl
-wget https://api.ngc.nvidia.com/v2/models/nvidia/research/stylegan2/versions/1/files/stylegan2-afhqcat-512x512.pkl
-wget http://d36zk2xti64re0.cloudfront.net/stylegan2/networks/stylegan2-car-config-f.pkl
-wget http://d36zk2xti64re0.cloudfront.net/stylegan2/networks/stylegan2-cat-config-f.pkl
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/README.md b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/README.md
deleted file mode 100644
index e6408dc976fde0a6016363281082f4095e1f3cae..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/README.md
+++ /dev/null
@@ -1,271 +0,0 @@
-
-
-# Generating the documentation
-
-To generate the documentation, you first have to build it. Several packages are necessary to build the doc,
-you can install them with the following command, at the root of the code repository:
-
-```bash
-pip install -e ".[docs]"
-```
-
-Then you need to install our open source documentation builder tool:
-
-```bash
-pip install git+https://github.com/huggingface/doc-builder
-```
-
----
-**NOTE**
-
-You only need to generate the documentation to inspect it locally (if you're planning changes and want to
-check how they look before committing for instance). You don't have to commit the built documentation.
-
----
-
-## Previewing the documentation
-
-To preview the docs, first install the `watchdog` module with:
-
-```bash
-pip install watchdog
-```
-
-Then run the following command:
-
-```bash
-doc-builder preview {package_name} {path_to_docs}
-```
-
-For example:
-
-```bash
-doc-builder preview diffusers docs/source/en
-```
-
-The docs will be viewable at [http://localhost:3000](http://localhost:3000). You can also preview the docs once you have opened a PR. You will see a bot add a comment to a link where the documentation with your changes lives.
-
----
-**NOTE**
-
-The `preview` command only works with existing doc files. When you add a completely new file, you need to update `_toctree.yml` & restart `preview` command (`ctrl-c` to stop it & call `doc-builder preview ...` again).
-
----
-
-## Adding a new element to the navigation bar
-
-Accepted files are Markdown (.md).
-
-Create a file with its extension and put it in the source directory. You can then link it to the toc-tree by putting
-the filename without the extension in the [`_toctree.yml`](https://github.com/huggingface/diffusers/blob/main/docs/source/_toctree.yml) file.
-
-## Renaming section headers and moving sections
-
-It helps to keep the old links working when renaming the section header and/or moving sections from one document to another. This is because the old links are likely to be used in Issues, Forums, and Social media and it'd make for a much more superior user experience if users reading those months later could still easily navigate to the originally intended information.
-
-Therefore, we simply keep a little map of moved sections at the end of the document where the original section was. The key is to preserve the original anchor.
-
-So if you renamed a section from: "Section A" to "Section B", then you can add at the end of the file:
-
-```
-Sections that were moved:
-
-[ Section A ]
-```
-and of course, if you moved it to another file, then:
-
-```
-Sections that were moved:
-
-[ Section A ]
-```
-
-Use the relative style to link to the new file so that the versioned docs continue to work.
-
-For an example of a rich moved section set please see the very end of [the transformers Trainer doc](https://github.com/huggingface/transformers/blob/main/docs/source/en/main_classes/trainer.md).
-
-
-## Writing Documentation - Specification
-
-The `huggingface/diffusers` documentation follows the
-[Google documentation](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html) style for docstrings,
-although we can write them directly in Markdown.
-
-### Adding a new tutorial
-
-Adding a new tutorial or section is done in two steps:
-
-- Add a new file under `docs/source`. This file can either be ReStructuredText (.rst) or Markdown (.md).
-- Link that file in `docs/source/_toctree.yml` on the correct toc-tree.
-
-Make sure to put your new file under the proper section. It's unlikely to go in the first section (*Get Started*), so
-depending on the intended targets (beginners, more advanced users, or researchers) it should go in sections two, three, or four.
-
-### Adding a new pipeline/scheduler
-
-When adding a new pipeline:
-
-- create a file `xxx.md` under `docs/source/api/pipelines` (don't hesitate to copy an existing file as template).
-- Link that file in (*Diffusers Summary*) section in `docs/source/api/pipelines/overview.md`, along with the link to the paper, and a colab notebook (if available).
-- Write a short overview of the diffusion model:
- - Overview with paper & authors
- - Paper abstract
- - Tips and tricks and how to use it best
- - Possible an end-to-end example of how to use it
-- Add all the pipeline classes that should be linked in the diffusion model. These classes should be added using our Markdown syntax. By default as follows:
-
-```
-## XXXPipeline
-
-[[autodoc]] XXXPipeline
- - all
- - __call__
-```
-
-This will include every public method of the pipeline that is documented, as well as the `__call__` method that is not documented by default. If you just want to add additional methods that are not documented, you can put the list of all methods to add in a list that contains `all`.
-
-```
-[[autodoc]] XXXPipeline
- - all
- - __call__
- - enable_attention_slicing
- - disable_attention_slicing
- - enable_xformers_memory_efficient_attention
- - disable_xformers_memory_efficient_attention
-```
-
-You can follow the same process to create a new scheduler under the `docs/source/api/schedulers` folder
-
-### Writing source documentation
-
-Values that should be put in `code` should either be surrounded by backticks: \`like so\`. Note that argument names
-and objects like True, None, or any strings should usually be put in `code`.
-
-When mentioning a class, function, or method, it is recommended to use our syntax for internal links so that our tool
-adds a link to its documentation with this syntax: \[\`XXXClass\`\] or \[\`function\`\]. This requires the class or
-function to be in the main package.
-
-If you want to create a link to some internal class or function, you need to
-provide its path. For instance: \[\`pipelines.ImagePipelineOutput\`\]. This will be converted into a link with
-`pipelines.ImagePipelineOutput` in the description. To get rid of the path and only keep the name of the object you are
-linking to in the description, add a ~: \[\`~pipelines.ImagePipelineOutput\`\] will generate a link with `ImagePipelineOutput` in the description.
-
-The same works for methods so you can either use \[\`XXXClass.method\`\] or \[~\`XXXClass.method\`\].
-
-#### Defining arguments in a method
-
-Arguments should be defined with the `Args:` (or `Arguments:` or `Parameters:`) prefix, followed by a line return and
-an indentation. The argument should be followed by its type, with its shape if it is a tensor, a colon, and its
-description:
-
-```
- Args:
- n_layers (`int`): The number of layers of the model.
-```
-
-If the description is too long to fit in one line, another indentation is necessary before writing the description
-after the argument.
-
-Here's an example showcasing everything so far:
-
-```
- Args:
- input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
- Indices of input sequence tokens in the vocabulary.
-
- Indices can be obtained using [`AlbertTokenizer`]. See [`~PreTrainedTokenizer.encode`] and
- [`~PreTrainedTokenizer.__call__`] for details.
-
- [What are input IDs?](../glossary#input-ids)
-```
-
-For optional arguments or arguments with defaults we follow the following syntax: imagine we have a function with the
-following signature:
-
-```
-def my_function(x: str = None, a: float = 1):
-```
-
-then its documentation should look like this:
-
-```
- Args:
- x (`str`, *optional*):
- This argument controls ...
- a (`float`, *optional*, defaults to 1):
- This argument is used to ...
-```
-
-Note that we always omit the "defaults to \`None\`" when None is the default for any argument. Also note that even
-if the first line describing your argument type and its default gets long, you can't break it on several lines. You can
-however write as many lines as you want in the indented description (see the example above with `input_ids`).
-
-#### Writing a multi-line code block
-
-Multi-line code blocks can be useful for displaying examples. They are done between two lines of three backticks as usual in Markdown:
-
-
-````
-```
-# first line of code
-# second line
-# etc
-```
-````
-
-#### Writing a return block
-
-The return block should be introduced with the `Returns:` prefix, followed by a line return and an indentation.
-The first line should be the type of the return, followed by a line return. No need to indent further for the elements
-building the return.
-
-Here's an example of a single value return:
-
-```
- Returns:
- `List[int]`: A list of integers in the range [0, 1] --- 1 for a special token, 0 for a sequence token.
-```
-
-Here's an example of a tuple return, comprising several objects:
-
-```
- Returns:
- `tuple(torch.FloatTensor)` comprising various elements depending on the configuration ([`BertConfig`]) and inputs:
- - ** loss** (*optional*, returned when `masked_lm_labels` is provided) `torch.FloatTensor` of shape `(1,)` --
- Total loss is the sum of the masked language modeling loss and the next sequence prediction (classification) loss.
- - **prediction_scores** (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`) --
- Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).
-```
-
-#### Adding an image
-
-Due to the rapidly growing repository, it is important to make sure that no files that would significantly weigh down the repository are added. This includes images, videos, and other non-text files. We prefer to leverage a hf.co hosted `dataset` like
-the ones hosted on [`hf-internal-testing`](https://huggingface.co/hf-internal-testing) in which to place these files and reference
-them by URL. We recommend putting them in the following dataset: [huggingface/documentation-images](https://huggingface.co/datasets/huggingface/documentation-images).
-If an external contribution, feel free to add the images to your PR and ask a Hugging Face member to migrate your images
-to this dataset.
-
-## Styling the docstring
-
-We have an automatic script running with the `make style` command that will make sure that:
-- the docstrings fully take advantage of the line width
-- all code examples are formatted using black, like the code of the Transformers library
-
-This script may have some weird failures if you made a syntax mistake or if you uncover a bug. Therefore, it's
-recommended to commit your changes before running `make style`, so you can revert the changes done by that script
-easily.
-
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/models/modeling_pytorch_flax_utils.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/models/modeling_pytorch_flax_utils.py
deleted file mode 100644
index a61638ad02f7a38a1439f35dea5966c7c7d519d8..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/models/modeling_pytorch_flax_utils.py
+++ /dev/null
@@ -1,161 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# 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.
-""" PyTorch - Flax general utilities."""
-
-from pickle import UnpicklingError
-
-import jax
-import jax.numpy as jnp
-import numpy as np
-from flax.serialization import from_bytes
-from flax.traverse_util import flatten_dict
-
-from ..utils import logging
-
-
-logger = logging.get_logger(__name__)
-
-
-#####################
-# Flax => PyTorch #
-#####################
-
-
-# from https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_pytorch_utils.py#L224-L352
-def load_flax_checkpoint_in_pytorch_model(pt_model, model_file):
- try:
- with open(model_file, "rb") as flax_state_f:
- flax_state = from_bytes(None, flax_state_f.read())
- except UnpicklingError as e:
- try:
- with open(model_file) as f:
- if f.read().startswith("version"):
- raise OSError(
- "You seem to have cloned a repository without having git-lfs installed. Please"
- " install git-lfs and run `git lfs install` followed by `git lfs pull` in the"
- " folder you cloned."
- )
- else:
- raise ValueError from e
- except (UnicodeDecodeError, ValueError):
- raise EnvironmentError(f"Unable to convert {model_file} to Flax deserializable object. ")
-
- return load_flax_weights_in_pytorch_model(pt_model, flax_state)
-
-
-def load_flax_weights_in_pytorch_model(pt_model, flax_state):
- """Load flax checkpoints in a PyTorch model"""
-
- try:
- import torch # noqa: F401
- except ImportError:
- logger.error(
- "Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see"
- " https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"
- " instructions."
- )
- raise
-
- # check if we have bf16 weights
- is_type_bf16 = flatten_dict(jax.tree_util.tree_map(lambda x: x.dtype == jnp.bfloat16, flax_state)).values()
- if any(is_type_bf16):
- # convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16
-
- # and bf16 is not fully supported in PT yet.
- logger.warning(
- "Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` "
- "before loading those in PyTorch model."
- )
- flax_state = jax.tree_util.tree_map(
- lambda params: params.astype(np.float32) if params.dtype == jnp.bfloat16 else params, flax_state
- )
-
- pt_model.base_model_prefix = ""
-
- flax_state_dict = flatten_dict(flax_state, sep=".")
- pt_model_dict = pt_model.state_dict()
-
- # keep track of unexpected & missing keys
- unexpected_keys = []
- missing_keys = set(pt_model_dict.keys())
-
- for flax_key_tuple, flax_tensor in flax_state_dict.items():
- flax_key_tuple_array = flax_key_tuple.split(".")
-
- if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
- flax_key_tuple_array = flax_key_tuple_array[:-1] + ["weight"]
- flax_tensor = jnp.transpose(flax_tensor, (3, 2, 0, 1))
- elif flax_key_tuple_array[-1] == "kernel":
- flax_key_tuple_array = flax_key_tuple_array[:-1] + ["weight"]
- flax_tensor = flax_tensor.T
- elif flax_key_tuple_array[-1] == "scale":
- flax_key_tuple_array = flax_key_tuple_array[:-1] + ["weight"]
-
- if "time_embedding" not in flax_key_tuple_array:
- for i, flax_key_tuple_string in enumerate(flax_key_tuple_array):
- flax_key_tuple_array[i] = (
- flax_key_tuple_string.replace("_0", ".0")
- .replace("_1", ".1")
- .replace("_2", ".2")
- .replace("_3", ".3")
- .replace("_4", ".4")
- .replace("_5", ".5")
- .replace("_6", ".6")
- .replace("_7", ".7")
- .replace("_8", ".8")
- .replace("_9", ".9")
- )
-
- flax_key = ".".join(flax_key_tuple_array)
-
- if flax_key in pt_model_dict:
- if flax_tensor.shape != pt_model_dict[flax_key].shape:
- raise ValueError(
- f"Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected "
- f"to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}."
- )
- else:
- # add weight to pytorch dict
- flax_tensor = np.asarray(flax_tensor) if not isinstance(flax_tensor, np.ndarray) else flax_tensor
- pt_model_dict[flax_key] = torch.from_numpy(flax_tensor)
- # remove from missing keys
- missing_keys.remove(flax_key)
- else:
- # weight is not expected by PyTorch model
- unexpected_keys.append(flax_key)
-
- pt_model.load_state_dict(pt_model_dict)
-
- # re-transform missing_keys to list
- missing_keys = list(missing_keys)
-
- if len(unexpected_keys) > 0:
- logger.warning(
- "Some weights of the Flax model were not used when initializing the PyTorch model"
- f" {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing"
- f" {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture"
- " (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This"
- f" IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect"
- " to be exactly identical (e.g. initializing a BertForSequenceClassification model from a"
- " FlaxBertForSequenceClassification model)."
- )
- if len(missing_keys) > 0:
- logger.warning(
- f"Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly"
- f" initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to"
- " use it for predictions and inference."
- )
-
- return pt_model
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco.py
deleted file mode 100644
index b1ddbee3b4b79e79bb2a3faf30604f2465612728..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/gcnet/mask_rcnn_x101_32x4d_fpn_syncbn-backbone_r4_gcb_c3-c5_1x_coco.py
+++ /dev/null
@@ -1,11 +0,0 @@
-_base_ = '../mask_rcnn/mask_rcnn_x101_32x4d_fpn_1x_coco.py'
-model = dict(
- backbone=dict(
- norm_cfg=dict(type='SyncBN', requires_grad=True),
- norm_eval=False,
- plugins=[
- dict(
- cfg=dict(type='ContextBlock', ratio=1. / 4),
- stages=(False, True, True, True),
- position='after_conv3')
- ]))
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/swin/mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_3x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/swin/mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_3x_coco.py
deleted file mode 100644
index c58057747d7d922293b6838e6eb1e13aa520aa3a..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/swin/mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_3x_coco.py
+++ /dev/null
@@ -1,80 +0,0 @@
-_base_ = [
- '../_base_/models/mask_rcnn_swin_fpn.py',
- '../_base_/datasets/coco_instance.py',
- '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
-]
-
-model = dict(
- backbone=dict(
- embed_dim=96,
- depths=[2, 2, 6, 2],
- num_heads=[3, 6, 12, 24],
- window_size=7,
- ape=False,
- drop_path_rate=0.2,
- patch_norm=True,
- use_checkpoint=False
- ),
- neck=dict(in_channels=[96, 192, 384, 768]))
-
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-
-# augmentation strategy originates from DETR / Sparse RCNN
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
- dict(type='RandomFlip', flip_ratio=0.5),
- dict(type='AutoAugment',
- policies=[
- [
- dict(type='Resize',
- img_scale=[(480, 1333), (512, 1333), (544, 1333), (576, 1333),
- (608, 1333), (640, 1333), (672, 1333), (704, 1333),
- (736, 1333), (768, 1333), (800, 1333)],
- multiscale_mode='value',
- keep_ratio=True)
- ],
- [
- dict(type='Resize',
- img_scale=[(400, 1333), (500, 1333), (600, 1333)],
- multiscale_mode='value',
- keep_ratio=True),
- dict(type='RandomCrop',
- crop_type='absolute_range',
- crop_size=(384, 600),
- allow_negative_crop=True),
- dict(type='Resize',
- img_scale=[(480, 1333), (512, 1333), (544, 1333),
- (576, 1333), (608, 1333), (640, 1333),
- (672, 1333), (704, 1333), (736, 1333),
- (768, 1333), (800, 1333)],
- multiscale_mode='value',
- override=True,
- keep_ratio=True)
- ]
- ]),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']),
-]
-data = dict(train=dict(pipeline=train_pipeline))
-
-optimizer = dict(_delete_=True, type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05,
- paramwise_cfg=dict(custom_keys={'absolute_pos_embed': dict(decay_mult=0.),
- 'relative_position_bias_table': dict(decay_mult=0.),
- 'norm': dict(decay_mult=0.)}))
-lr_config = dict(step=[27, 33])
-runner = dict(type='EpochBasedRunnerAmp', max_epochs=36)
-
-# do not use mmdet version fp16
-fp16 = None
-optimizer_config = dict(
- type="DistOptimizerHook",
- update_interval=1,
- grad_clip=None,
- coalesce=True,
- bucket_size_mb=-1,
- use_fp16=True,
-)
diff --git a/spaces/Anthony7906/MengHuiMXD_GPT/chatgpt - windows.bat b/spaces/Anthony7906/MengHuiMXD_GPT/chatgpt - windows.bat
deleted file mode 100644
index 0b78fdc3a559abd692e3a9e9af5e482124d13a99..0000000000000000000000000000000000000000
--- a/spaces/Anthony7906/MengHuiMXD_GPT/chatgpt - windows.bat
+++ /dev/null
@@ -1,14 +0,0 @@
-@echo off
-echo Opening ChuanhuChatGPT...
-
-REM Open powershell via bat
-start powershell.exe -NoExit -Command "python ./ChuanhuChatbot.py"
-
-REM The web page can be accessed with delayed start http://127.0.0.1:7860/
-ping -n 5 127.0.0.1>nul
-
-REM access chargpt via your default browser
-start "" "http://127.0.0.1:7860/"
-
-
-echo Finished opening ChuanhuChatGPT (http://127.0.0.1:7860/).
\ No newline at end of file
diff --git a/spaces/Arthur678/vits-uma-genshin-honkai/utils.py b/spaces/Arthur678/vits-uma-genshin-honkai/utils.py
deleted file mode 100644
index ee4b01ddfbe8173965371b29f770f3e87615fe71..0000000000000000000000000000000000000000
--- a/spaces/Arthur678/vits-uma-genshin-honkai/utils.py
+++ /dev/null
@@ -1,225 +0,0 @@
-import os
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import numpy as np
-import librosa
-import torch
-
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
-logger = logging
-
-
-def load_checkpoint(checkpoint_path, model, optimizer=None):
- assert os.path.isfile(checkpoint_path)
- checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
- iteration = checkpoint_dict['iteration']
- learning_rate = checkpoint_dict['learning_rate']
- if optimizer is not None:
- optimizer.load_state_dict(checkpoint_dict['optimizer'])
- saved_state_dict = checkpoint_dict['model']
- if hasattr(model, 'module'):
- state_dict = model.module.state_dict()
- else:
- state_dict = model.state_dict()
- new_state_dict= {}
- for k, v in state_dict.items():
- try:
- new_state_dict[k] = saved_state_dict[k]
- except:
- logger.info("%s is not in the checkpoint" % k)
- new_state_dict[k] = v
- if hasattr(model, 'module'):
- model.module.load_state_dict(new_state_dict)
- else:
- model.load_state_dict(new_state_dict)
- logger.info("Loaded checkpoint '{}' (iteration {})" .format(
- checkpoint_path, iteration))
- return model, optimizer, learning_rate, iteration
-
-
-def plot_spectrogram_to_numpy(spectrogram):
- global MATPLOTLIB_FLAG
- if not MATPLOTLIB_FLAG:
- import matplotlib
- matplotlib.use("Agg")
- MATPLOTLIB_FLAG = True
- mpl_logger = logging.getLogger('matplotlib')
- mpl_logger.setLevel(logging.WARNING)
- import matplotlib.pylab as plt
- import numpy as np
-
- fig, ax = plt.subplots(figsize=(10,2))
- im = ax.imshow(spectrogram, aspect="auto", origin="lower",
- interpolation='none')
- plt.colorbar(im, ax=ax)
- plt.xlabel("Frames")
- plt.ylabel("Channels")
- plt.tight_layout()
-
- fig.canvas.draw()
- data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
- data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
- plt.close()
- return data
-
-
-def plot_alignment_to_numpy(alignment, info=None):
- global MATPLOTLIB_FLAG
- if not MATPLOTLIB_FLAG:
- import matplotlib
- matplotlib.use("Agg")
- MATPLOTLIB_FLAG = True
- mpl_logger = logging.getLogger('matplotlib')
- mpl_logger.setLevel(logging.WARNING)
- import matplotlib.pylab as plt
- import numpy as np
-
- fig, ax = plt.subplots(figsize=(6, 4))
- im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
- interpolation='none')
- fig.colorbar(im, ax=ax)
- xlabel = 'Decoder timestep'
- if info is not None:
- xlabel += '\n\n' + info
- plt.xlabel(xlabel)
- plt.ylabel('Encoder timestep')
- plt.tight_layout()
-
- fig.canvas.draw()
- data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
- data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
- plt.close()
- return data
-
-
-def load_audio_to_torch(full_path, target_sampling_rate):
- audio, sampling_rate = librosa.load(full_path, sr=target_sampling_rate, mono=True)
- return torch.FloatTensor(audio.astype(np.float32))
-
-
-def load_filepaths_and_text(filename, split="|"):
- with open(filename, encoding='utf-8') as f:
- filepaths_and_text = [line.strip().split(split) for line in f]
- return filepaths_and_text
-
-
-def get_hparams(init=True):
- parser = argparse.ArgumentParser()
- parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
- help='JSON file for configuration')
- parser.add_argument('-m', '--model', type=str, required=True,
- help='Model name')
-
- args = parser.parse_args()
- model_dir = os.path.join("./logs", args.model)
-
- if not os.path.exists(model_dir):
- os.makedirs(model_dir)
-
- config_path = args.config
- config_save_path = os.path.join(model_dir, "config.json")
- if init:
- with open(config_path, "r") as f:
- data = f.read()
- with open(config_save_path, "w") as f:
- f.write(data)
- else:
- with open(config_save_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams = HParams(**config)
- hparams.model_dir = model_dir
- return hparams
-
-
-def get_hparams_from_dir(model_dir):
- config_save_path = os.path.join(model_dir, "config.json")
- with open(config_save_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams =HParams(**config)
- hparams.model_dir = model_dir
- return hparams
-
-
-def get_hparams_from_file(config_path):
- with open(config_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams =HParams(**config)
- return hparams
-
-
-def check_git_hash(model_dir):
- source_dir = os.path.dirname(os.path.realpath(__file__))
- if not os.path.exists(os.path.join(source_dir, ".git")):
- logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
- source_dir
- ))
- return
-
- cur_hash = subprocess.getoutput("git rev-parse HEAD")
-
- path = os.path.join(model_dir, "githash")
- if os.path.exists(path):
- saved_hash = open(path).read()
- if saved_hash != cur_hash:
- logger.warn("git hash values are different. {}(saved) != {}(current)".format(
- saved_hash[:8], cur_hash[:8]))
- else:
- open(path, "w").write(cur_hash)
-
-
-def get_logger(model_dir, filename="train.log"):
- global logger
- logger = logging.getLogger(os.path.basename(model_dir))
- logger.setLevel(logging.DEBUG)
-
- formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
- if not os.path.exists(model_dir):
- os.makedirs(model_dir)
- h = logging.FileHandler(os.path.join(model_dir, filename))
- h.setLevel(logging.DEBUG)
- h.setFormatter(formatter)
- logger.addHandler(h)
- return logger
-
-
-class HParams():
- def __init__(self, **kwargs):
- for k, v in kwargs.items():
- if type(v) == dict:
- v = HParams(**v)
- self[k] = v
-
- def keys(self):
- return self.__dict__.keys()
-
- def items(self):
- return self.__dict__.items()
-
- def values(self):
- return self.__dict__.values()
-
- def __len__(self):
- return len(self.__dict__)
-
- def __getitem__(self, key):
- return getattr(self, key)
-
- def __setitem__(self, key, value):
- return setattr(self, key, value)
-
- def __contains__(self, key):
- return key in self.__dict__
-
- def __repr__(self):
- return self.__dict__.__repr__()
diff --git a/spaces/Avator/gradio-hugging-face/app.py b/spaces/Avator/gradio-hugging-face/app.py
deleted file mode 100644
index 6b44ece73c07bfb7feef56f585323ea742f2f386..0000000000000000000000000000000000000000
--- a/spaces/Avator/gradio-hugging-face/app.py
+++ /dev/null
@@ -1,14 +0,0 @@
-import gradio as gr
-from transformers import pipeline
-sentiment = pipeline("sentiment-analysis")
-def get_sentiment(input_text):
- return sentiment(input_text)
-result = get_sentiment("The movie was very bad")
-result
-iface = gr.Interface(fn=get_sentiment,
- inputs='text',
- outputs=['text'],
- title='Sentiment Analysis',
- description="Get Sentiment Negative/Positive for the given Input",
- theme='huggingface')
-iface.launch(inline=False)
\ No newline at end of file
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/evaluation/coco_evaluation.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/evaluation/coco_evaluation.py
deleted file mode 100644
index aad7f5a6e79a9047e7eea623ecc761ea9655b8d6..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/evaluation/coco_evaluation.py
+++ /dev/null
@@ -1,710 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import contextlib
-import copy
-import io
-import itertools
-import json
-import logging
-import numpy as np
-import os
-import pickle
-from collections import OrderedDict
-import pycocotools.mask as mask_util
-import torch
-from pycocotools.coco import COCO
-from pycocotools.cocoeval import COCOeval
-from tabulate import tabulate
-
-import detectron2.utils.comm as comm
-from detectron2.config import CfgNode
-from detectron2.data import MetadataCatalog
-from detectron2.data.datasets.coco import convert_to_coco_json
-from detectron2.evaluation.fast_eval_api import COCOeval_opt
-from detectron2.structures import Boxes, BoxMode, pairwise_iou
-from detectron2.utils.file_io import PathManager
-from detectron2.utils.logger import create_small_table
-
-from .evaluator import DatasetEvaluator
-
-
-class COCOEvaluator(DatasetEvaluator):
- """
- Evaluate AR for object proposals, AP for instance detection/segmentation, AP
- for keypoint detection outputs using COCO's metrics.
- See http://cocodataset.org/#detection-eval and
- http://cocodataset.org/#keypoints-eval to understand its metrics.
- The metrics range from 0 to 100 (instead of 0 to 1), where a -1 or NaN means
- the metric cannot be computed (e.g. due to no predictions made).
-
- In addition to COCO, this evaluator is able to support any bounding box detection,
- instance segmentation, or keypoint detection dataset.
- """
-
- def __init__(
- self,
- dataset_name,
- tasks=None,
- distributed=True,
- output_dir=None,
- *,
- max_dets_per_image=None,
- use_fast_impl=True,
- kpt_oks_sigmas=(),
- ):
- """
- Args:
- dataset_name (str): name of the dataset to be evaluated.
- It must have either the following corresponding metadata:
-
- "json_file": the path to the COCO format annotation
-
- Or it must be in detectron2's standard dataset format
- so it can be converted to COCO format automatically.
- tasks (tuple[str]): tasks that can be evaluated under the given
- configuration. A task is one of "bbox", "segm", "keypoints".
- By default, will infer this automatically from predictions.
- distributed (True): if True, will collect results from all ranks and run evaluation
- in the main process.
- Otherwise, will only evaluate the results in the current process.
- output_dir (str): optional, an output directory to dump all
- results predicted on the dataset. The dump contains two files:
-
- 1. "instances_predictions.pth" a file that can be loaded with `torch.load` and
- contains all the results in the format they are produced by the model.
- 2. "coco_instances_results.json" a json file in COCO's result format.
- max_dets_per_image (int): limit on the maximum number of detections per image.
- By default in COCO, this limit is to 100, but this can be customized
- to be greater, as is needed in evaluation metrics AP fixed and AP pool
- (see https://arxiv.org/pdf/2102.01066.pdf)
- This doesn't affect keypoint evaluation.
- use_fast_impl (bool): use a fast but **unofficial** implementation to compute AP.
- Although the results should be very close to the official implementation in COCO
- API, it is still recommended to compute results with the official API for use in
- papers. The faster implementation also uses more RAM.
- kpt_oks_sigmas (list[float]): The sigmas used to calculate keypoint OKS.
- See http://cocodataset.org/#keypoints-eval
- When empty, it will use the defaults in COCO.
- Otherwise it should be the same length as ROI_KEYPOINT_HEAD.NUM_KEYPOINTS.
- """
- self._logger = logging.getLogger(__name__)
- self._distributed = distributed
- self._output_dir = output_dir
- self._use_fast_impl = use_fast_impl
-
- # COCOeval requires the limit on the number of detections per image (maxDets) to be a list
- # with at least 3 elements. The default maxDets in COCOeval is [1, 10, 100], in which the
- # 3rd element (100) is used as the limit on the number of detections per image when
- # evaluating AP. COCOEvaluator expects an integer for max_dets_per_image, so for COCOeval,
- # we reformat max_dets_per_image into [1, 10, max_dets_per_image], based on the defaults.
- if max_dets_per_image is None:
- max_dets_per_image = [1, 10, 100]
- else:
- max_dets_per_image = [1, 10, max_dets_per_image]
- self._max_dets_per_image = max_dets_per_image
-
- if tasks is not None and isinstance(tasks, CfgNode):
- kpt_oks_sigmas = (
- tasks.TEST.KEYPOINT_OKS_SIGMAS if not kpt_oks_sigmas else kpt_oks_sigmas
- )
- self._logger.warn(
- "COCO Evaluator instantiated using config, this is deprecated behavior."
- " Please pass in explicit arguments instead."
- )
- self._tasks = None # Infering it from predictions should be better
- else:
- self._tasks = tasks
-
- self._cpu_device = torch.device("cpu")
-
- self._metadata = MetadataCatalog.get(dataset_name)
- if not hasattr(self._metadata, "json_file"):
- if output_dir is None:
- raise ValueError(
- "output_dir must be provided to COCOEvaluator "
- "for datasets not in COCO format."
- )
- self._logger.info(f"Trying to convert '{dataset_name}' to COCO format ...")
-
- cache_path = os.path.join(output_dir, f"{dataset_name}_coco_format.json")
- self._metadata.json_file = cache_path
- convert_to_coco_json(dataset_name, cache_path)
-
- json_file = PathManager.get_local_path(self._metadata.json_file)
- with contextlib.redirect_stdout(io.StringIO()):
- self._coco_api = COCO(json_file)
-
- # Test set json files do not contain annotations (evaluation must be
- # performed using the COCO evaluation server).
- self._do_evaluation = "annotations" in self._coco_api.dataset
- if self._do_evaluation:
- self._kpt_oks_sigmas = kpt_oks_sigmas
-
- def reset(self):
- self._predictions = []
-
- def process(self, inputs, outputs):
- """
- Args:
- inputs: the inputs to a COCO model (e.g., GeneralizedRCNN).
- It is a list of dict. Each dict corresponds to an image and
- contains keys like "height", "width", "file_name", "image_id".
- outputs: the outputs of a COCO model. It is a list of dicts with key
- "instances" that contains :class:`Instances`.
- """
- for input, output in zip(inputs, outputs):
- prediction = {"image_id": input["image_id"]}
-
- if "instances" in output:
- instances = output["instances"].to(self._cpu_device)
- prediction["instances"] = instances_to_coco_json(instances, input["image_id"])
- if "proposals" in output:
- prediction["proposals"] = output["proposals"].to(self._cpu_device)
- if len(prediction) > 1:
- self._predictions.append(prediction)
-
- def evaluate(self, img_ids=None):
- """
- Args:
- img_ids: a list of image IDs to evaluate on. Default to None for the whole dataset
- """
- if self._distributed:
- comm.synchronize()
- predictions = comm.gather(self._predictions, dst=0)
- predictions = list(itertools.chain(*predictions))
-
- if not comm.is_main_process():
- return {}
- else:
- predictions = self._predictions
-
- if len(predictions) == 0:
- self._logger.warning("[COCOEvaluator] Did not receive valid predictions.")
- return {}
-
- if self._output_dir:
- PathManager.mkdirs(self._output_dir)
- file_path = os.path.join(self._output_dir, "instances_predictions.pth")
- with PathManager.open(file_path, "wb") as f:
- torch.save(predictions, f)
-
- self._results = OrderedDict()
- if "proposals" in predictions[0]:
- self._eval_box_proposals(predictions)
- if "instances" in predictions[0]:
- self._eval_predictions(predictions, img_ids=img_ids)
- # Copy so the caller can do whatever with results
- return copy.deepcopy(self._results)
-
- def _tasks_from_predictions(self, predictions):
- """
- Get COCO API "tasks" (i.e. iou_type) from COCO-format predictions.
- """
- tasks = {"bbox"}
- for pred in predictions:
- if "segmentation" in pred:
- tasks.add("segm")
- if "keypoints" in pred:
- tasks.add("keypoints")
- return sorted(tasks)
-
- def _eval_predictions(self, predictions, img_ids=None):
- """
- Evaluate predictions. Fill self._results with the metrics of the tasks.
- """
- self._logger.info("Preparing results for COCO format ...")
- coco_results = list(itertools.chain(*[x["instances"] for x in predictions]))
- tasks = self._tasks or self._tasks_from_predictions(coco_results)
-
- # unmap the category ids for COCO
- if hasattr(self._metadata, "thing_dataset_id_to_contiguous_id"):
- dataset_id_to_contiguous_id = self._metadata.thing_dataset_id_to_contiguous_id
- all_contiguous_ids = list(dataset_id_to_contiguous_id.values())
- num_classes = len(all_contiguous_ids)
- assert min(all_contiguous_ids) == 0 and max(all_contiguous_ids) == num_classes - 1
-
- reverse_id_mapping = {v: k for k, v in dataset_id_to_contiguous_id.items()}
- for result in coco_results:
- category_id = result["category_id"]
- assert category_id < num_classes, (
- f"A prediction has class={category_id}, "
- f"but the dataset only has {num_classes} classes and "
- f"predicted class id should be in [0, {num_classes - 1}]."
- )
- result["category_id"] = reverse_id_mapping[category_id]
-
- if self._output_dir:
- file_path = os.path.join(self._output_dir, "coco_instances_results.json")
- self._logger.info("Saving results to {}".format(file_path))
- with PathManager.open(file_path, "w") as f:
- f.write(json.dumps(coco_results))
- f.flush()
-
- if not self._do_evaluation:
- self._logger.info("Annotations are not available for evaluation.")
- return
-
- self._logger.info(
- "Evaluating predictions with {} COCO API...".format(
- "unofficial" if self._use_fast_impl else "official"
- )
- )
- for task in sorted(tasks):
- assert task in {"bbox", "segm", "keypoints"}, f"Got unknown task: {task}!"
- coco_eval = (
- _evaluate_predictions_on_coco(
- self._coco_api,
- coco_results,
- task,
- kpt_oks_sigmas=self._kpt_oks_sigmas,
- use_fast_impl=self._use_fast_impl,
- img_ids=img_ids,
- max_dets_per_image=self._max_dets_per_image,
- )
- if len(coco_results) > 0
- else None # cocoapi does not handle empty results very well
- )
-
- res = self._derive_coco_results(
- coco_eval, task, class_names=self._metadata.get("thing_classes")
- )
- self._results[task] = res
-
- def _eval_box_proposals(self, predictions):
- """
- Evaluate the box proposals in predictions.
- Fill self._results with the metrics for "box_proposals" task.
- """
- if self._output_dir:
- # Saving generated box proposals to file.
- # Predicted box_proposals are in XYXY_ABS mode.
- bbox_mode = BoxMode.XYXY_ABS.value
- ids, boxes, objectness_logits = [], [], []
- for prediction in predictions:
- ids.append(prediction["image_id"])
- boxes.append(prediction["proposals"].proposal_boxes.tensor.numpy())
- objectness_logits.append(prediction["proposals"].objectness_logits.numpy())
-
- proposal_data = {
- "boxes": boxes,
- "objectness_logits": objectness_logits,
- "ids": ids,
- "bbox_mode": bbox_mode,
- }
- with PathManager.open(os.path.join(self._output_dir, "box_proposals.pkl"), "wb") as f:
- pickle.dump(proposal_data, f)
-
- if not self._do_evaluation:
- self._logger.info("Annotations are not available for evaluation.")
- return
-
- self._logger.info("Evaluating bbox proposals ...")
- res = {}
- areas = {"all": "", "small": "s", "medium": "m", "large": "l"}
- for limit in [100, 1000]:
- for area, suffix in areas.items():
- stats = _evaluate_box_proposals(predictions, self._coco_api, area=area, limit=limit)
- key = "AR{}@{:d}".format(suffix, limit)
- res[key] = float(stats["ar"].item() * 100)
- self._logger.info("Proposal metrics: \n" + create_small_table(res))
- self._results["box_proposals"] = res
-
- def _derive_coco_results(self, coco_eval, iou_type, class_names=None):
- """
- Derive the desired score numbers from summarized COCOeval.
-
- Args:
- coco_eval (None or COCOEval): None represents no predictions from model.
- iou_type (str):
- class_names (None or list[str]): if provided, will use it to predict
- per-category AP.
-
- Returns:
- a dict of {metric name: score}
- """
-
- metrics = {
- "bbox": ["AP", "AP50", "AP75", "APs", "APm", "APl"],
- "segm": ["AP", "AP50", "AP75", "APs", "APm", "APl"],
- "keypoints": ["AP", "AP50", "AP75", "APm", "APl"],
- }[iou_type]
-
- if coco_eval is None:
- self._logger.warn("No predictions from the model!")
- return {metric: float("nan") for metric in metrics}
-
- # the standard metrics
- results = {
- metric: float(coco_eval.stats[idx] * 100 if coco_eval.stats[idx] >= 0 else "nan")
- for idx, metric in enumerate(metrics)
- }
- self._logger.info(
- "Evaluation results for {}: \n".format(iou_type) + create_small_table(results)
- )
- if not np.isfinite(sum(results.values())):
- self._logger.info("Some metrics cannot be computed and is shown as NaN.")
-
- if class_names is None or len(class_names) <= 1:
- return results
- # Compute per-category AP
- # from https://github.com/facebookresearch/Detectron/blob/a6a835f5b8208c45d0dce217ce9bbda915f44df7/detectron/datasets/json_dataset_evaluator.py#L222-L252 # noqa
- precisions = coco_eval.eval["precision"]
- # precision has dims (iou, recall, cls, area range, max dets)
- assert len(class_names) == precisions.shape[2]
-
- results_per_category = []
- for idx, name in enumerate(class_names):
- # area range index 0: all area ranges
- # max dets index -1: typically 100 per image
- precision = precisions[:, :, idx, 0, -1]
- precision = precision[precision > -1]
- ap = np.mean(precision) if precision.size else float("nan")
- results_per_category.append(("{}".format(name), float(ap * 100)))
-
- # tabulate it
- N_COLS = min(6, len(results_per_category) * 2)
- results_flatten = list(itertools.chain(*results_per_category))
- results_2d = itertools.zip_longest(*[results_flatten[i::N_COLS] for i in range(N_COLS)])
- table = tabulate(
- results_2d,
- tablefmt="pipe",
- floatfmt=".3f",
- headers=["category", "AP"] * (N_COLS // 2),
- numalign="left",
- )
- self._logger.info("Per-category {} AP: \n".format(iou_type) + table)
-
- results.update({"AP-" + name: ap for name, ap in results_per_category})
- return results
-
-
-def instances_to_coco_json(instances, img_id):
- """
- Dump an "Instances" object to a COCO-format json that's used for evaluation.
-
- Args:
- instances (Instances):
- img_id (int): the image id
-
- Returns:
- list[dict]: list of json annotations in COCO format.
- """
- num_instance = len(instances)
- if num_instance == 0:
- return []
-
- boxes = instances.pred_boxes.tensor.numpy()
- boxes = BoxMode.convert(boxes, BoxMode.XYXY_ABS, BoxMode.XYWH_ABS)
- boxes = boxes.tolist()
- scores = instances.scores.tolist()
- classes = instances.pred_classes.tolist()
-
- has_mask = instances.has("pred_masks")
- if has_mask:
- # use RLE to encode the masks, because they are too large and takes memory
- # since this evaluator stores outputs of the entire dataset
- rles = [
- mask_util.encode(np.array(mask[:, :, None], order="F", dtype="uint8"))[0]
- for mask in instances.pred_masks
- ]
- for rle in rles:
- # "counts" is an array encoded by mask_util as a byte-stream. Python3's
- # json writer which always produces strings cannot serialize a bytestream
- # unless you decode it. Thankfully, utf-8 works out (which is also what
- # the pycocotools/_mask.pyx does).
- rle["counts"] = rle["counts"].decode("utf-8")
-
- has_keypoints = instances.has("pred_keypoints")
- if has_keypoints:
- keypoints = instances.pred_keypoints
-
- results = []
- for k in range(num_instance):
- result = {
- "image_id": img_id,
- "category_id": classes[k],
- "bbox": boxes[k],
- "score": scores[k],
- }
- if has_mask:
- result["segmentation"] = rles[k]
- if has_keypoints:
- # In COCO annotations,
- # keypoints coordinates are pixel indices.
- # However our predictions are floating point coordinates.
- # Therefore we subtract 0.5 to be consistent with the annotation format.
- # This is the inverse of data loading logic in `datasets/coco.py`.
- keypoints[k][:, :2] -= 0.5
- result["keypoints"] = keypoints[k].flatten().tolist()
- results.append(result)
- return results
-
-
-# inspired from Detectron:
-# https://github.com/facebookresearch/Detectron/blob/a6a835f5b8208c45d0dce217ce9bbda915f44df7/detectron/datasets/json_dataset_evaluator.py#L255 # noqa
-def _evaluate_box_proposals(dataset_predictions, coco_api, thresholds=None, area="all", limit=None):
- """
- Evaluate detection proposal recall metrics. This function is a much
- faster alternative to the official COCO API recall evaluation code. However,
- it produces slightly different results.
- """
- # Record max overlap value for each gt box
- # Return vector of overlap values
- areas = {
- "all": 0,
- "small": 1,
- "medium": 2,
- "large": 3,
- "96-128": 4,
- "128-256": 5,
- "256-512": 6,
- "512-inf": 7,
- }
- area_ranges = [
- [0 ** 2, 1e5 ** 2], # all
- [0 ** 2, 32 ** 2], # small
- [32 ** 2, 96 ** 2], # medium
- [96 ** 2, 1e5 ** 2], # large
- [96 ** 2, 128 ** 2], # 96-128
- [128 ** 2, 256 ** 2], # 128-256
- [256 ** 2, 512 ** 2], # 256-512
- [512 ** 2, 1e5 ** 2],
- ] # 512-inf
- assert area in areas, "Unknown area range: {}".format(area)
- area_range = area_ranges[areas[area]]
- gt_overlaps = []
- num_pos = 0
-
- for prediction_dict in dataset_predictions:
- predictions = prediction_dict["proposals"]
-
- # sort predictions in descending order
- # TODO maybe remove this and make it explicit in the documentation
- inds = predictions.objectness_logits.sort(descending=True)[1]
- predictions = predictions[inds]
-
- ann_ids = coco_api.getAnnIds(imgIds=prediction_dict["image_id"])
- anno = coco_api.loadAnns(ann_ids)
- gt_boxes = [
- BoxMode.convert(obj["bbox"], BoxMode.XYWH_ABS, BoxMode.XYXY_ABS)
- for obj in anno
- if obj["iscrowd"] == 0
- ]
- gt_boxes = torch.as_tensor(gt_boxes).reshape(-1, 4) # guard against no boxes
- gt_boxes = Boxes(gt_boxes)
- gt_areas = torch.as_tensor([obj["area"] for obj in anno if obj["iscrowd"] == 0])
-
- if len(gt_boxes) == 0 or len(predictions) == 0:
- continue
-
- valid_gt_inds = (gt_areas >= area_range[0]) & (gt_areas <= area_range[1])
- gt_boxes = gt_boxes[valid_gt_inds]
-
- num_pos += len(gt_boxes)
-
- if len(gt_boxes) == 0:
- continue
-
- if limit is not None and len(predictions) > limit:
- predictions = predictions[:limit]
-
- overlaps = pairwise_iou(predictions.proposal_boxes, gt_boxes)
-
- _gt_overlaps = torch.zeros(len(gt_boxes))
- for j in range(min(len(predictions), len(gt_boxes))):
- # find which proposal box maximally covers each gt box
- # and get the iou amount of coverage for each gt box
- max_overlaps, argmax_overlaps = overlaps.max(dim=0)
-
- # find which gt box is 'best' covered (i.e. 'best' = most iou)
- gt_ovr, gt_ind = max_overlaps.max(dim=0)
- assert gt_ovr >= 0
- # find the proposal box that covers the best covered gt box
- box_ind = argmax_overlaps[gt_ind]
- # record the iou coverage of this gt box
- _gt_overlaps[j] = overlaps[box_ind, gt_ind]
- assert _gt_overlaps[j] == gt_ovr
- # mark the proposal box and the gt box as used
- overlaps[box_ind, :] = -1
- overlaps[:, gt_ind] = -1
-
- # append recorded iou coverage level
- gt_overlaps.append(_gt_overlaps)
- gt_overlaps = (
- torch.cat(gt_overlaps, dim=0) if len(gt_overlaps) else torch.zeros(0, dtype=torch.float32)
- )
- gt_overlaps, _ = torch.sort(gt_overlaps)
-
- if thresholds is None:
- step = 0.05
- thresholds = torch.arange(0.5, 0.95 + 1e-5, step, dtype=torch.float32)
- recalls = torch.zeros_like(thresholds)
- # compute recall for each iou threshold
- for i, t in enumerate(thresholds):
- recalls[i] = (gt_overlaps >= t).float().sum() / float(num_pos)
- # ar = 2 * np.trapz(recalls, thresholds)
- ar = recalls.mean()
- return {
- "ar": ar,
- "recalls": recalls,
- "thresholds": thresholds,
- "gt_overlaps": gt_overlaps,
- "num_pos": num_pos,
- }
-
-
-def _evaluate_predictions_on_coco(
- coco_gt,
- coco_results,
- iou_type,
- kpt_oks_sigmas=None,
- use_fast_impl=True,
- img_ids=None,
- max_dets_per_image=None,
-):
- """
- Evaluate the coco results using COCOEval API.
- """
- assert len(coco_results) > 0
-
- if iou_type == "segm":
- coco_results = copy.deepcopy(coco_results)
- # When evaluating mask AP, if the results contain bbox, cocoapi will
- # use the box area as the area of the instance, instead of the mask area.
- # This leads to a different definition of small/medium/large.
- # We remove the bbox field to let mask AP use mask area.
- for c in coco_results:
- c.pop("bbox", None)
-
- coco_dt = coco_gt.loadRes(coco_results)
- coco_eval = (COCOeval_opt if use_fast_impl else COCOeval)(coco_gt, coco_dt, iou_type)
- # For COCO, the default max_dets_per_image is [1, 10, 100].
- if max_dets_per_image is None:
- max_dets_per_image = [1, 10, 100] # Default from COCOEval
- else:
- assert (
- len(max_dets_per_image) >= 3
- ), "COCOeval requires maxDets (and max_dets_per_image) to have length at least 3"
- # In the case that user supplies a custom input for max_dets_per_image,
- # apply COCOevalMaxDets to evaluate AP with the custom input.
- if max_dets_per_image[2] != 100:
- coco_eval = COCOevalMaxDets(coco_gt, coco_dt, iou_type)
- if iou_type != "keypoints":
- coco_eval.params.maxDets = max_dets_per_image
-
- if img_ids is not None:
- coco_eval.params.imgIds = img_ids
-
- if iou_type == "keypoints":
- # Use the COCO default keypoint OKS sigmas unless overrides are specified
- if kpt_oks_sigmas:
- assert hasattr(coco_eval.params, "kpt_oks_sigmas"), "pycocotools is too old!"
- coco_eval.params.kpt_oks_sigmas = np.array(kpt_oks_sigmas)
- # COCOAPI requires every detection and every gt to have keypoints, so
- # we just take the first entry from both
- num_keypoints_dt = len(coco_results[0]["keypoints"]) // 3
- num_keypoints_gt = len(next(iter(coco_gt.anns.values()))["keypoints"]) // 3
- num_keypoints_oks = len(coco_eval.params.kpt_oks_sigmas)
- assert num_keypoints_oks == num_keypoints_dt == num_keypoints_gt, (
- f"[COCOEvaluator] Prediction contain {num_keypoints_dt} keypoints. "
- f"Ground truth contains {num_keypoints_gt} keypoints. "
- f"The length of cfg.TEST.KEYPOINT_OKS_SIGMAS is {num_keypoints_oks}. "
- "They have to agree with each other. For meaning of OKS, please refer to "
- "http://cocodataset.org/#keypoints-eval."
- )
-
- coco_eval.evaluate()
- coco_eval.accumulate()
- coco_eval.summarize()
-
- return coco_eval
-
-
-class COCOevalMaxDets(COCOeval):
- """
- Modified version of COCOeval for evaluating AP with a custom
- maxDets (by default for COCO, maxDets is 100)
- """
-
- def summarize(self):
- """
- Compute and display summary metrics for evaluation results given
- a custom value for max_dets_per_image
- """
-
- def _summarize(ap=1, iouThr=None, areaRng="all", maxDets=100):
- p = self.params
- iStr = " {:<18} {} @[ IoU={:<9} | area={:>6s} | maxDets={:>3d} ] = {:0.3f}"
- titleStr = "Average Precision" if ap == 1 else "Average Recall"
- typeStr = "(AP)" if ap == 1 else "(AR)"
- iouStr = (
- "{:0.2f}:{:0.2f}".format(p.iouThrs[0], p.iouThrs[-1])
- if iouThr is None
- else "{:0.2f}".format(iouThr)
- )
-
- aind = [i for i, aRng in enumerate(p.areaRngLbl) if aRng == areaRng]
- mind = [i for i, mDet in enumerate(p.maxDets) if mDet == maxDets]
- if ap == 1:
- # dimension of precision: [TxRxKxAxM]
- s = self.eval["precision"]
- # IoU
- if iouThr is not None:
- t = np.where(iouThr == p.iouThrs)[0]
- s = s[t]
- s = s[:, :, :, aind, mind]
- else:
- # dimension of recall: [TxKxAxM]
- s = self.eval["recall"]
- if iouThr is not None:
- t = np.where(iouThr == p.iouThrs)[0]
- s = s[t]
- s = s[:, :, aind, mind]
- if len(s[s > -1]) == 0:
- mean_s = -1
- else:
- mean_s = np.mean(s[s > -1])
- print(iStr.format(titleStr, typeStr, iouStr, areaRng, maxDets, mean_s))
- return mean_s
-
- def _summarizeDets():
- stats = np.zeros((12,))
- # Evaluate AP using the custom limit on maximum detections per image
- stats[0] = _summarize(1, maxDets=self.params.maxDets[2])
- stats[1] = _summarize(1, iouThr=0.5, maxDets=self.params.maxDets[2])
- stats[2] = _summarize(1, iouThr=0.75, maxDets=self.params.maxDets[2])
- stats[3] = _summarize(1, areaRng="small", maxDets=self.params.maxDets[2])
- stats[4] = _summarize(1, areaRng="medium", maxDets=self.params.maxDets[2])
- stats[5] = _summarize(1, areaRng="large", maxDets=self.params.maxDets[2])
- stats[6] = _summarize(0, maxDets=self.params.maxDets[0])
- stats[7] = _summarize(0, maxDets=self.params.maxDets[1])
- stats[8] = _summarize(0, maxDets=self.params.maxDets[2])
- stats[9] = _summarize(0, areaRng="small", maxDets=self.params.maxDets[2])
- stats[10] = _summarize(0, areaRng="medium", maxDets=self.params.maxDets[2])
- stats[11] = _summarize(0, areaRng="large", maxDets=self.params.maxDets[2])
- return stats
-
- def _summarizeKps():
- stats = np.zeros((10,))
- stats[0] = _summarize(1, maxDets=20)
- stats[1] = _summarize(1, maxDets=20, iouThr=0.5)
- stats[2] = _summarize(1, maxDets=20, iouThr=0.75)
- stats[3] = _summarize(1, maxDets=20, areaRng="medium")
- stats[4] = _summarize(1, maxDets=20, areaRng="large")
- stats[5] = _summarize(0, maxDets=20)
- stats[6] = _summarize(0, maxDets=20, iouThr=0.5)
- stats[7] = _summarize(0, maxDets=20, iouThr=0.75)
- stats[8] = _summarize(0, maxDets=20, areaRng="medium")
- stats[9] = _summarize(0, maxDets=20, areaRng="large")
- return stats
-
- if not self.eval:
- raise Exception("Please run accumulate() first")
- iouType = self.params.iouType
- if iouType == "segm" or iouType == "bbox":
- summarize = _summarizeDets
- elif iouType == "keypoints":
- summarize = _summarizeKps
- self.stats = summarize()
-
- def __str__(self):
- self.summarize()
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/sampling.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/sampling.py
deleted file mode 100644
index a2d0f6648b349c5ea39fd29785b77c961a58fa22..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/modeling/sampling.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import torch
-
-from detectron2.layers import nonzero_tuple
-
-__all__ = ["subsample_labels"]
-
-
-def subsample_labels(
- labels: torch.Tensor, num_samples: int, positive_fraction: float, bg_label: int
-):
- """
- Return `num_samples` (or fewer, if not enough found)
- random samples from `labels` which is a mixture of positives & negatives.
- It will try to return as many positives as possible without
- exceeding `positive_fraction * num_samples`, and then try to
- fill the remaining slots with negatives.
-
- Args:
- labels (Tensor): (N, ) label vector with values:
- * -1: ignore
- * bg_label: background ("negative") class
- * otherwise: one or more foreground ("positive") classes
- num_samples (int): The total number of labels with value >= 0 to return.
- Values that are not sampled will be filled with -1 (ignore).
- positive_fraction (float): The number of subsampled labels with values > 0
- is `min(num_positives, int(positive_fraction * num_samples))`. The number
- of negatives sampled is `min(num_negatives, num_samples - num_positives_sampled)`.
- In order words, if there are not enough positives, the sample is filled with
- negatives. If there are also not enough negatives, then as many elements are
- sampled as is possible.
- bg_label (int): label index of background ("negative") class.
-
- Returns:
- pos_idx, neg_idx (Tensor):
- 1D vector of indices. The total length of both is `num_samples` or fewer.
- """
- positive = nonzero_tuple((labels != -1) & (labels != bg_label))[0]
- negative = nonzero_tuple(labels == bg_label)[0]
-
- num_pos = int(num_samples * positive_fraction)
- # protect against not enough positive examples
- num_pos = min(positive.numel(), num_pos)
- num_neg = num_samples - num_pos
- # protect against not enough negative examples
- num_neg = min(negative.numel(), num_neg)
-
- # randomly select positive and negative examples
- perm1 = torch.randperm(positive.numel(), device=positive.device)[:num_pos]
- perm2 = torch.randperm(negative.numel(), device=negative.device)[:num_neg]
-
- pos_idx = positive[perm1]
- neg_idx = negative[perm2]
- return pos_idx, neg_idx
diff --git a/spaces/Banbri/zcvzcv/src/components/ui/collapsible.tsx b/spaces/Banbri/zcvzcv/src/components/ui/collapsible.tsx
deleted file mode 100644
index 9fa48946afd1eb56bd932377fd888e3986304676..0000000000000000000000000000000000000000
--- a/spaces/Banbri/zcvzcv/src/components/ui/collapsible.tsx
+++ /dev/null
@@ -1,11 +0,0 @@
-"use client"
-
-import * as CollapsiblePrimitive from "@radix-ui/react-collapsible"
-
-const Collapsible = CollapsiblePrimitive.Root
-
-const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger
-
-const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent
-
-export { Collapsible, CollapsibleTrigger, CollapsibleContent }
diff --git a/spaces/Benson/text-generation/Examples/Bgc Apk.md b/spaces/Benson/text-generation/Examples/Bgc Apk.md
deleted file mode 100644
index c6b02005a5a30beb109cfbb0e5b3793ebb1ea4b9..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Bgc Apk.md
+++ /dev/null
@@ -1,119 +0,0 @@
-
-
-YOLOv5-l-P6 model structure
-¿Qué es BGC APK y cómo descargarlo?
-Si usted está buscando una manera divertida y emocionante para pasar su tiempo con sus amigos y familiares, es posible que desee echa un vistazo BGC APK. BGC APK es una colección de mini-juegos que pueden ser jugados por 2, 3, o 4 jugadores en el mismo dispositivo o a través de una red Wi-Fi. También puedes jugar online con otros jugadores de todo el mundo. En este artículo, le diremos qué es BGC APK, cuáles son sus características, por qué debe descargarlo, y cómo descargarlo para diferentes dispositivos. También te mostraremos cómo jugar juegos de BGC con tus amigos y familiares.
-Introducción
-¿Qué es BGC APK?
-BGC APK es una aplicación para Android que contiene una variedad de minijuegos que están diseñados para la atención, reacción, pensamiento y precisión. Algunos de los minijuegos incluyen carreras, disparos, rompecabezas, árcade, deportes y más. Puedes jugar a estos juegos con 2, 3 o 4 jugadores en el mismo dispositivo o a través de una red Wi-Fi. También puedes jugar online con otros jugadores de todo el mundo. Los juegos son sencillos y claros de entender, pero desafiantes y divertidos de jugar. Puedes competir con tus amigos y familiares y ver quién es el mejor.
-bgc apk
Download File https://bltlly.com/2v6MJP
-
¿Cuáles son las características de BGC APK?
-Algunas de las características de BGC APK son:
--
-
- Tiene una gran colección de mini-juegos que atienden a diferentes gustos y preferencias. -
- Soporta el modo multijugador para 2, 3 o 4 jugadores en el mismo dispositivo o a través de una red Wi-Fi. -
- También es compatible con el modo en línea donde se puede jugar con otros jugadores de todo el mundo. -
- Tiene un modo de juego con bots donde puedes practicar tus habilidades y mejorar tu rendimiento. -
- Tiene gráficos y efectos de sonido de alta calidad que mejoran su experiencia de juego. -
- Tiene una interfaz fácil de usar que es fácil de navegar y usar. -
- Es gratis para descargar y jugar, pero contiene anuncios que se pueden eliminar mediante la compra de una versión premium. -
Usted debe descargar BGC APK porque:
--
-
- Es una gran manera de divertirse y divertirse con sus amigos y familiares. -
- Es una buena manera de poner a prueba tus habilidades y habilidades en diferentes minijuegos. -
- Es una buena manera de desafiarse a sí mismo y a otros en una competencia amistosa. -
- Es una buena manera de matar el aburrimiento y pasar el tiempo cuando no tienes nada más que hacer. -
- Es una buena manera de descubrir nuevos juegos y géneros que te pueden gustar. -
Cómo Cómo descargar BGC APK para dispositivos Android
-
Si usted tiene un dispositivo Android, puede descargar BGC APK fácilmente siguiendo estos pasos:
--
-
- Ir a la página web oficial de BGC APK y haga clic en el botón de descarga. Verá una ventana emergente que le pide que confirme la descarga. Haz clic en Aceptar y espera a que el archivo APK se descargue en tu dispositivo. -
- Una vez completada la descarga, vaya a la configuración del dispositivo y habilite fuentes desconocidas. Esto le permitirá instalar aplicaciones desde fuentes distintas de Google Play Store. Para hacer esto, vaya a Configuración > Seguridad > Fuentes desconocidas y conéctelo. -
- Ahora, busque el archivo APK descargado en su dispositivo utilizando una aplicación de administrador de archivos. Toque en el archivo y haga clic en Instalar. Verá una pantalla que le pide que conceda permisos a la aplicación. Haga clic en Aceptar y espere a que finalice la instalación. -
- Después de la instalación se hace, puede iniciar la aplicación desde el cajón de aplicaciones o pantalla de inicio. Verás una pantalla de bienvenida con algunas instrucciones sobre cómo jugar a los juegos de BGC. También puede acceder al menú de configuración desde la esquina superior derecha de la pantalla. -
- Disfruta jugando juegos BGC con tus amigos y familiares en tu dispositivo Android. -
Cómo descargar BGC APK para otros dispositivos
-Si usted tiene un dispositivo que no sea Android, todavía se puede descargar BGC APK mediante el uso de un emulador o un navegador. Aquí hay algunas maneras de hacer eso:
-Cómo descargar BGC APK para dispositivos iOS
- --
-
- Descargar iAndroid desde la App Store e instalarlo en su dispositivo. -
- Inicie iAndroid y toque en el icono + en la parte inferior de la pantalla. Verá una lista de opciones para agregar una aplicación. Elija Agregar URL e introduzca la URL del sitio web oficial de BGC APK. Toque en Añadir. -
- Verá BGC APK añadido a su pantalla de inicio iAndroid. Toque en él y esperar a que se cargue. Verá una ventana emergente pidiéndole que instale la aplicación. Toque en Instalar y espere a que termine. -
- Después de la instalación se hace, puede iniciar BGC APK desde iAndroid y jugar juegos BGC con sus amigos y familiares en su dispositivo iOS. -
Cómo descargar BGC APK para dispositivos Windows
-Si usted tiene un dispositivo de Windows, puede descargar BGC APK mediante el uso de un emulador llamado BlueStacks. Este es un software que le permite ejecutar aplicaciones Android en su PC o portátil. Para descargar BGC APK para dispositivos Windows, siga estos pasos:
--
-
- Descargar BlueStacks desde su sitio web oficial e instalarlo en su dispositivo. -
- Inicie BlueStacks e inicie sesión con su cuenta de Google. Verá una pantalla de inicio con algunas aplicaciones preinstaladas. -
- Haga clic en el icono de Google Play Store y buscar BGC APK. Verá la aplicación en los resultados de búsqueda. Haga clic en él y luego haga clic en Instalar. Espere a que la aplicación se descargue e instale en su dispositivo. -
- Después de la instalación se hace, puede iniciar BGC APK de BlueStacks y jugar juegos BGC con tus amigos y familiares en su dispositivo Windows. -
Cómo descargar BGC APK para dispositivos Mac
-Si usted tiene un dispositivo Mac, puede descargar BGC APK mediante el uso de un navegador llamado Puffin Browser. Este es un navegador que soporta Flash y le permite jugar juegos en línea sin descargarlos. Para descargar BGC APK para dispositivos Mac, siga estos pasos:
--
-
- Descargar Puffin Browser desde su sitio web oficial e instalarlo en su dispositivo. - -
- Ahora puedes jugar juegos BGC con tus amigos y familiares en tu dispositivo Mac sin descargar nada. -
Cómo jugar juegos de BGC con tus amigos y familiares
-Los juegos de BGC están diseñados para el modo multijugador, por lo que puedes jugar con tus amigos y familiares de diferentes maneras. Estos son algunos de ellos:
- -Cómo jugar juegos de BGC en el mismo dispositivo
-Si tienes un dispositivo, puedes jugar juegos de BGC en el mismo dispositivo usando el modo de pantalla dividida. Este modo divide la pantalla en dos, tres o cuatro partes dependiendo del número de jugadores. Cada jugador puede usar su propia parte de la pantalla para controlar a su personaje e interactuar con el juego. Para jugar juegos de BGC en el mismo dispositivo, siga estos pasos:
--
-
- Iniciar BGC APK y elegir el juego que desea jugar desde el menú. Verá una lista de modos de juego. Elija Pantalla dividida y seleccione el número de jugadores. -
- Verá la pantalla dividida en partes iguales. Cada jugador puede elegir su nombre, color y avatar desde la parte inferior de su parte de la pantalla. -
- Cuando todo el mundo esté listo, toca Inicio y espera a que comience el juego. Verás las instrucciones y reglas del juego en la parte superior de la pantalla. -
- Usa tu parte de la pantalla para controlar a tu personaje y jugar el juego. Puede ver su puntuación y tiempo en la esquina superior derecha de su parte de la pantalla. -
- El juego terminará cuando se acabe el tiempo o cuando uno de los jugadores gane. Verás los resultados y las clasificaciones en la pantalla. Puede optar por jugar de nuevo o salir del menú. -
Cómo jugar juegos de BGC a través de la red Wi-Fi
-Si tiene más de un dispositivo, puede jugar juegos BGC a través de una red Wi-Fi mediante el modo multijugador local. Este modo le permite conectar sus dispositivos a la misma red Wi-Fi y jugar juegos BGC entre sí. Para jugar juegos de BGC a través de una red Wi-Fi, siga estos pasos:
--
-
-
- Iniciar BGC APK y elegir el juego que desea jugar desde el menú. Verá una lista de modos de juego. Elige Multijugador local y selecciona el número de jugadores. -
- Verás una pantalla pidiéndote que crees o te unas a una habitación. Uno de los jugadores tiene que crear una habitación pulsando en Crear habitación. Verán un código de habitación en su pantalla. -
- Los otros jugadores tienen que unirse a la sala pulsando en Unirse a la sala e introduciendo el código de la sala. Verán una lista de jugadores en la sala. -
- Cuando todo el mundo esté listo, toque en Inicio y espere a que comience el juego. Verá las instrucciones y reglas del juego en su pantalla. -
- Usa tu dispositivo para controlar a tu personaje y jugar al juego. Puedes ver tu puntuación y tiempo en tu pantalla. -
- El juego terminará cuando se acabe el tiempo o cuando uno de los jugadores gane. Verás los resultados y las clasificaciones en tu pantalla. Puede optar por jugar de nuevo o salir de la habitación. -
Cómo jugar juegos de BGC en línea
-Si quieres jugar juegos de BGC con otros jugadores de todo el mundo, puedes jugar juegos de BGC online usando el modo multijugador online. Este modo le permite conectarse a Internet y jugar juegos de BGC con jugadores al azar o con sus amigos. Para jugar juegos de BGC en línea, siga estos pasos:
--
-
- Asegúrese de que su dispositivo está conectado a Internet. -
- Iniciar BGC APK y elegir el juego que desea jugar desde el menú. Verá una lista de modos de juego. Elige Multijugador en línea y selecciona el número de jugadores. -
- Verá una pantalla que le pide que inicie sesión con su cuenta de Google. Esto es necesario para jugar en línea y para guardar su progreso y logros. Toque en Iniciar sesión e introduzca sus credenciales de Google. -
- Verás una pantalla pidiéndote que elijas un modo de juego. Puedes elegir Juego rápido, que te emparejará con jugadores aleatorios, o Juego personalizado, que te permitirá crear o unirte a una habitación con tus amigos. - -
- Si eliges Custom Play, verás una pantalla pidiéndote que crees o te unas a una habitación. Puede crear una habitación pulsando en Crear habitación y estableciendo una contraseña para ella. Puedes compartir el código de la habitación y la contraseña con tus amigos para que puedan unirse a tu habitación. También puede unirse a una habitación pulsando en Unirse a la habitación e introduciendo el código de la habitación y la contraseña. -
- Cuando todo el mundo esté listo, toque en Inicio y espere a que comience el juego. Verá las instrucciones y reglas del juego en su pantalla. -
- Usa tu dispositivo para controlar a tu personaje y jugar al juego. Puedes ver tu puntuación y tiempo en tu pantalla. -
- El juego terminará cuando se acabe el tiempo o cuando uno de los jugadores gane. Verás los resultados y las clasificaciones en tu pantalla. Puede optar por jugar de nuevo o salir del menú. -
Conclusión
-BGC APK es una aplicación increíble que ofrece una variedad de minijuegos que son divertidos y emocionantes para jugar con tus amigos y familiares. Puede descargar BGC APK para diferentes dispositivos y jugar juegos de BGC en el mismo dispositivo, a través de una red Wi-Fi, o en línea. Los juegos de BGC son simples y claros de entender, pero desafiantes y divertidos de jugar. Puedes competir con tus amigos y familiares y ver quién es el mejor. BGC APK es gratis para descargar y jugar, pero contiene anuncios que pueden ser eliminados mediante la compra de una versión premium. Si usted está buscando una manera divertida y entretenida para pasar su tiempo con sus amigos y familiares, definitivamente debe descargar BGC APK y probarlo.
-Preguntas frecuentes
-¿Cuáles son algunos de los juegos populares de BGC?
-Algunos de los juegos populares de BGC son:
--
-
- carreras: un juego de ritmo rápido donde tienes que competir contra otros jugadores en diferentes pistas. -
- Disparos: Un emocionante juego donde tienes que disparar a otros jugadores o objetivos con diferentes armas. -
- rompecabezas: un juego de bromas donde tienes que resolver varios puzzles y adivinanzas. - -
- Deportes: Un juego deportivo donde tienes que jugar diferentes deportes como fútbol, baloncesto, tenis, etc. -
¿Es BGC APK seguro y seguro de usar?
-Sí, BGC APK es seguro y seguro de usar. No contiene ningún virus o malware que pueda dañar su dispositivo o datos. Tampoco requiere ningún permiso especial que pueda comprometer su privacidad o seguridad. Sin embargo, siempre debe descargar BGC APK desde su sitio web oficial o de fuentes de confianza para evitar cualquier riesgo.
-¿Cuánto espacio requiere BGC APK en su dispositivo?
-BGC APK requiere aproximadamente 50 MB de espacio en su dispositivo. Sin embargo, esto puede variar dependiendo del modelo de dispositivo y el sistema operativo. También debe asegurarse de que usted tiene suficiente espacio libre en el dispositivo antes de descargar BGC APK.
-¿Puedes jugar juegos de BGC sin conexión?
-Sí, puedes jugar juegos de BGC sin conexión usando el modo de juego con bots. Este modo le permite jugar juegos BGC con jugadores controlados por ordenador sin necesidad de una conexión a Internet. Sin embargo, no podrás guardar tu progreso o logros en este modo. Tampoco podrás acceder a algunas de las características como el modo multijugador en línea, tablas de clasificación, etc.
-¿Cómo puede ponerse en contacto con el desarrollador de BGC APK?
-Si usted tiene alguna pregunta, comentarios, sugerencias, o problemas con respecto BGC APK, puede ponerse en contacto con el desarrollador de BGC APK mediante el uso del formulario de contacto en su sitio web oficial. También puedes seguirlos en sus cuentas de redes sociales como Facebook, Twitter, Instagram, etc. para obtener las últimas actualizaciones y noticias sobre BGC APK. También puedes dejar una reseña o valoración en Google Play Store o App Store para compartir tu experiencia y comentarios con otros usuarios.
64aa2da5cf-
-
\ No newline at end of file diff --git a/spaces/Benson/text-generation/Examples/Comisin Zondo Informe Final Pdf.md b/spaces/Benson/text-generation/Examples/Comisin Zondo Informe Final Pdf.md deleted file mode 100644 index 5dcb4749b267be00d025e4a7394b68a64f8b656d..0000000000000000000000000000000000000000 --- a/spaces/Benson/text-generation/Examples/Comisin Zondo Informe Final Pdf.md +++ /dev/null @@ -1,78 +0,0 @@ - -
Informe final de la Comisión Zondo PDF Download
-La Comisión de Investigación de Zondo sobre las Acusaciones de Captura del Estado, también conocida como la Comisión de Captura del Estado, fue una comisión judicial establecida en 2017 por el ex presidente Jacob Zuma, siguiendo una recomendación del ex Protector Público Thuli Madonsela en su informe de 2016 titulado State of Capture. La comisión fue presidida por el Presidente Adjunto del Tribunal Supremo Raymond Zondo y tenía el mandato de investigar las denuncias de corrupción, fraude e influencia indebida de particulares y entidades en el Estado y sus órganos.
-La comisión llevó a cabo audiencias públicas entre agosto de 2018 y septiembre de 2021, durante las cuales escuchó las declaraciones de más de 330 testigos, incluidos ministros anteriores y actuales, altos funcionarios, ejecutivos de empresas, denunciantes, periodistas y activistas de la sociedad civil. La comisión también recibió miles de documentos, declaraciones juradas y presentaciones de diversas fuentes. El trabajo de la comisión fue ampliamente seguido por los medios de comunicación y el público, ya que expuso detalles impactantes de cómo la captura estatal operaba y afectaba a varios sectores de la sociedad.
-comisión zondo informe final pdf
Download File ——— https://bltlly.com/2v6IR1
-
La comisión presentó su informe final al presidente Cyril Ramaphosa en seis partes entre enero y junio de 2022. El informe consta de más de 900 páginas y contiene hallazgos, conclusiones y recomendaciones sobre diversos aspectos de la captura estatal. Inicialmente, la Presidencia mantuvo la confidencialidad del informe, a la espera de que el Presidente del Tribunal Supremo Zondo lo examinara para determinar las correcciones y enmiendas. Sin embargo, tras una orden judicial que autorizó la publicación de la versión modificada del informe el 12 de octubre de 2022, la Presidencia puso el informe a disposición del público en línea.
-¿Qué es la Comisión Zondo y por qué es importante?
- -La Comisión Zondo fue importante por varias razones. En primer lugar, proporcionó una plataforma para exponer y documentar el alcance y el impacto de la captura estatal en diversos sectores de la sociedad. En segundo lugar, ofreció una oportunidad para aquellos que estaban implicados o afectados por la captura estatal para dar su versión de la historia y enfrentar el contrainterrogatorio. En tercer lugar, generó conciencia pública y debate sobre las causas y consecuencias de la captura estatal y cómo prevenirla en el futuro. En cuarto lugar, formuló recomendaciones para la acción legal, la reforma institucional, el cambio de políticas y la movilización social para abordar la captura estatal y su legado.
-Las principales conclusiones y recomendaciones del informe
-El informe abarca una amplia gama de temas relacionados con la captura estatal, como las empresas estatales (EPE), los departamentos y organismos gubernamentales, los partidos políticos y el Parlamento, los servicios de seguridad e inteligencia, los medios de comunicación y la sociedad civil, entre otros. El informe contiene conclusiones sobre denuncias concretas de corrupción, fraude, mala administración, nepotismo, abuso de poder, injerencia, tráfico de influencias, blanqueo de dinero, evasión fiscal, etc., en las que participan diversas personas y entidades. El informe también hace recomendaciones sobre cómo responsabilizar a los responsables, recuperar los fondos robados, fortalecer los mecanismos de supervisión, mejorar los sistemas de gobernanza, mejorar las normas éticas, proteger a los denunciantes, promover la educación cívica, etc.
-Algunas de las principales conclusiones y recomendaciones del informe se resumen a continuación:
-Captura estatal en empresas estatales
- -El informe recomienda que las empresas estatales sean reestructuradas y reformadas para asegurar su viabilidad financiera, eficiencia operativa, alineación estratégica y responsabilidad pública. En el informe también se recomienda que las empresas estatales apliquen medidas para prevenir y combatir la corrupción, como la realización de auditorías forenses, el examen de los contratos, la recuperación de fondos, la imposición de medidas disciplinarias o el enjuiciamiento de los delincuentes, el fortalecimiento de los controles internos, mejorar la transparencia y la divulgación, etc.
-Captura estatal en departamentos y agencias gubernamentales
-El informe encuentra que varios departamentos y agencias gubernamentales fueron capturados por la misma red de actores privados que capturaron a las SOEs. El informe revela cómo la familia Gupta y sus asociados utilizaron su influencia sobre el ex presidente Zuma y su gabinete para asegurar nombramientos, contratos, licitaciones, licencias, permisos, subvenciones, etc., de varios departamentos y organismos gubernamentales. El informe también expone cómo la familia Gupta y sus asociados interfirieron con el funcionamiento y la toma de decisiones de varios departamentos y organismos gubernamentales para promover sus intereses. El informe identifica varios departamentos y organismos gubernamentales que fueron afectados por la captura estatal, como el Departamento de Recursos Minerales, el Departamento de Asuntos Internos, el Departamento de Empresas Públicas, el Departamento de Agua y Saneamiento, el Tesoro Nacional, la Fiscalía Nacional, el Servicio Fiscal de Sudáfrica, etc.
-El informe recomienda que se reformen y revitalicen los departamentos y organismos gubernamentales para garantizar su integridad, eficacia, capacidad de respuesta y responsabilidad. El informe también recomienda que los departamentos y organismos gubernamentales apliquen medidas para prevenir y combatir la corrupción, como la realización de investigaciones, la revisión de políticas, la recuperación de fondos, la imposición de medidas disciplinarias o el enjuiciamiento de delincuentes, el fortalecimiento de los mecanismos de supervisión, aumentar la participación pública, etc.
- - -El informe concluye que varios partidos políticos y el Parlamento fueron capturados por la misma red de actores privados que capturaron a las empresas estatales y los departamentos y organismos gubernamentales. El informe muestra cómo la familia Gupta y sus asociados utilizaron sus recursos financieros y conexiones políticas para influir en la selección y elección de líderes políticos, candidatos y representantes en diversos niveles de gobierno. El informe también muestra cómo la familia Gupta y sus asociados utilizaron su acceso y su influencia para influir en las políticas, posiciones y acciones de varios partidos políticos y el Parlamento en asuntos relacionados con la captura del Estado. El informe identifica varios partidos políticos y el Parlamento que fueron afectados por la captura estatal, como el ANC, el DA, el EFF, COPE
, y el IFP, así como la Asamblea Nacional y el Consejo Nacional de Provincias.
-El informe recomienda que se reformen y renueven los partidos políticos y el Parlamento para garantizar su independencia, diversidad, representación y responsabilidad. El informe también recomienda que los partidos políticos y el Parlamento apliquen medidas para prevenir y combatir la corrupción, como la realización de auditorías internas, el examen de las donaciones, la recuperación de fondos, la imposición de medidas disciplinarias o el enjuiciamiento de los delincuentes, el fortalecimiento de los códigos de ética, mejorar el escrutinio público, etc. -Captura de estado en el sector de seguridad e inteligencia
- -El informe recomienda que se reforme y restablezca el sector de seguridad e inteligencia para garantizar su profesionalismo, imparcialidad, legalidad y rendición de cuentas. El informe también recomienda que el sector de la seguridad y la inteligencia aplique medidas para prevenir y combatir la corrupción, como la realización de investigaciones, el examen de las operaciones, la recuperación de fondos, la disciplina o el enjuiciamiento de los delincuentes, el fortalecimiento de los órganos de supervisión, mejorar la confianza pública, etc.
-Cómo acceder y descargar el informe en línea
-El informe está disponible en línea para cualquiera que quiera acceder y descargarlo. Hay varias maneras de hacerlo:
-El sitio web oficial de la Presidencia
-La Presidencia ha publicado el informe en su sitio web oficial, donde se puede acceder y descargar en formato PDF. El informe se divide en seis partes, cada una de las cuales contiene varios capítulos y anexos. El sitio web también contiene un resumen del informe y una declaración del Presidente Ramaphosa sobre la publicación del informe.
-El sitio web oficial de la Comisión Zondo
-La Comisión Zondo también ha publicado el informe en su sitio web oficial, donde se puede acceder y descargar en formato PDF. El informe se divide en seis partes, cada una de las cuales contiene varios capítulos y anexos. El sitio web también proporciona los antecedentes de la comisión, una lista de testigos, una transcripción de las audiencias, un resumen de las presentaciones y una declaración del Presidente del Tribunal Supremo Zondo sobre la presentación del informe.
-Otras fuentes y plataformas en línea
- -Los desafíos y las implicaciones del informe
-El informe es un documento histórico que tiene implicaciones significativas para la democracia y el desarrollo de Sudáfrica. Sin embargo, el informe también enfrenta varios desafíos que pueden afectar su implementación y su impacto. Algunos de estos desafíos e implicaciones se discuten a continuación:
-Situación jurídica y aplicabilidad del informe
-El informe no es una sentencia judicial, sino un conjunto de conclusiones y recomendaciones de una comisión judicial. Por lo tanto, el informe no tiene fuerza de ley, sino más bien el peso de la autoridad y las pruebas. El informe no da lugar automáticamente a acusaciones penales, demandas civiles, medidas disciplinarias o cambios de política, sino que más bien proporciona una base para la adopción de nuevas medidas por las autoridades y las partes interesadas pertinentes. El informe puede ser impugnado, revisado o apelado en los tribunales por aquellos que están implicados o afectados por él. El informe también puede ser ignorado, retrasado u obstruido por aquellos que no quieren o no pueden implementarlo.
-El informe requiere voluntad política, acción legal, apoyo institucional, presión pública y movilización social para asegurar su implementación y cumplimiento. El informe también requiere coordinación, cooperación y colaboración entre diversos actores y sectores para asegurar su eficacia y eficiencia. El informe también requiere monitoreo, evaluación y supervisión para asegurar su cumplimiento y rendición de cuentas.
-La reacción pública y la respuesta al informe
- -El informe también ha suscitado debate, discusión y diálogo entre diversos interesados y sectores de la sociedad, como los partidos políticos, las organizaciones de la sociedad civil, las asociaciones empresariales, las instituciones académicas, los medios de comunicación, etc. El informe también ha sensibilizado, conciencia y educación entre el público sobre los problemas y desafíos de la captura estatal y cómo abordarlos.
-Perspectivas y acciones futuras para la rendición de cuentas y la reforma
-El informe es una oportunidad histórica para que Sudáfrica enfrente y supere el legado de la captura estatal y reconstruya y renueve su democracia y desarrollo. Sin embargo, el informe no es un fin en sí mismo, sino un medio para un fin. El informe no es una fórmula mágica, sino un catalizador para el cambio. El informe no es una garantía, sino un desafío para la rendición de cuentas y la reforma.
-El informe requiere esfuerzos sostenidos y concertados de todos los sectores de la sociedad para asegurar su implementación e impacto. El informe requiere liderazgo y compromiso por parte del gobierno y el estado para asegurar su aplicación y cumplimiento. El informe requiere la participación y el compromiso del público y la sociedad para asegurar su apoyo y supervisión. El informe requiere innovación y transformación por parte del sector privado y la economía para asegurar su alineación y contribución.
-Conclusión
-El Informe Final de la Comisión Zondo PDF Download es un recurso valioso para cualquiera que quiera aprender más sobre la captura estatal en Sudáfrica y cómo abordarla. El informe ofrece una descripción exhaustiva y creíble del alcance y el impacto de la captura estatal en diversos sectores de la sociedad. El informe también proporciona un conjunto de recomendaciones para la acción legal, la reforma institucional, el cambio de políticas y la movilización social para abordar la captura estatal y su legado.
- -El informe es un documento histórico que tiene implicaciones significativas para la democracia y el desarrollo de Sudáfrica. Sin embargo, el informe no es un fin en sí mismo, sino un medio para un fin. El informe no es una fórmula mágica, sino un catalizador para el cambio. El informe no es una garantía, sino un desafío para la rendición de cuentas y la reforma.
-Preguntas frecuentes
-Aquí hay algunas preguntas frecuentes sobre el Informe Final de la Comisión Zondo PDF Download:
--
-
\ No newline at end of file diff --git a/spaces/Benson/text-generation/Examples/Cuerda Hroe Apk Mod 3.md b/spaces/Benson/text-generation/Examples/Cuerda Hroe Apk Mod 3.md deleted file mode 100644 index b4406fd79088b8a1208cd1dcf04fe81d7f284738..0000000000000000000000000000000000000000 --- a/spaces/Benson/text-generation/Examples/Cuerda Hroe Apk Mod 3.md +++ /dev/null @@ -1,68 +0,0 @@ - -
héroe de cuerda APK Mod 3: Un juego de superhéroes con diversión ilimitada
-¿Te gustan los juegos de superhéroes? ¿Quieres balancearte como Spider-Man, luchar como Batman y volar como Superman? Si es así, entonces usted debe probar Héroe de cuerda APK Mod 3, un juego de acción en tercera persona con elementos RPG que le permite convertirse en un héroe de la súper cuerda en una ciudad llena de crimen y aventura.
-En este artículo, te diremos todo lo que necesitas saber sobre este increíble juego y su versión modificada. Te mostraremos cómo descargarlo e instalarlo en tu dispositivo, cuáles son sus características y cómo jugarlo como un profesional. También te daremos algunos consejos y trucos para que tu experiencia de juego sea más agradable. ¡Empecemos!
-cuerda héroe apk mod 3
Download Zip 🗸 https://bltlly.com/2v6Lte
-
¿Qué es el héroe de cuerda APK Mod 3?
-Rope Hero es un popular juego desarrollado por Naxeex Action & RPG Games, un estudio especializado en crear juegos de mundo abierto con temas de superhéroes. El juego tiene más de 100 millones de descargas en Google Play Store y ha recibido críticas positivas de jugadores y críticos por igual.
-El juego sigue la historia de un súper héroe azul que se despierta en una ciudad viciosa sin memoria de su pasado. Tiene una súper cuerda que le permite balancearse de un edificio a otro, saltar como una araña y realizar aterrizajes de potencia. También tiene superpoderes y armas que puede usar para luchar contra gángsters, policías y otros enemigos. También puede secuestrar coches, bicicletas, helicópteros, aviones e incluso robots.
-El juego tiene una línea de búsqueda principal que implica descubrir la verdad sobre su identidad y su papel en un experimento secreto. También tiene que enfrentar varios desafíos, como capturar distritos, derrotar jefes, completar misiones, participar en desafíos de armas, carreras de autos, batallas en arenas y mucho más.
- -Cómo descargar e instalar el héroe de cuerda APK Mod 3?
-Si desea jugar Rope Hero APK Mod 3 en su dispositivo, es necesario seguir estos sencillos pasos:
--
-
- Ir a este enlace y descargar el archivo APK de Rope Hero APK Mod 3. -
- Ir a la configuración del dispositivo y permitir la instalación de aplicaciones de fuentes desconocidas. -
- Busque el archivo descargado en su administrador de archivos y toque en él para instalarlo. -
- Espere a que el proceso de instalación termine y luego inicie el juego. -
- ¡Disfruta jugando Rope Hero APK Mod 3 con dinero y gemas ilimitadas! -
Nota: Es posible que tenga que desinstalar la versión original de Rope Hero antes de instalar la versión modificada.
-Héroe de cuerda APK Mod 3 no es solo un simple juego de superhéroes. Tiene muchas características que lo hacen destacar de otros juegos en el género. Estas son algunas de las características que puedes disfrutar en este juego:
- -Dinero ilimitado y gemas
-Como hemos mencionado antes, Héroe de cuerda APK Mod 3 le da dinero ilimitado y gemas, que son las principales monedas en el juego. Puedes usarlos para comprar armas, pieles, mejoras y otros artículos que harán a tu héroe más fuerte y más fresco. También puedes desbloquear todas las características del juego sin tener que gastar dinero real o ver anuncios.
-Por ejemplo, puedes comprar diferentes tipos de armas, como pistolas, escopetas, rifles, francotiradores, lanzacohetes y más. También puedes comprar armas cuerpo a cuerpo, como espadas, hachas, martillos y más. También puedes comprar súper armas, como láseres, lanzallamas, pistolas de plasma y más.
-También puedes comprar diferentes pieles para tu héroe, como Iron Man, Spider Man, Batman, Capitán América, Hulk y más. También puedes comprar mejoras para tu súper cuerda, como longitud, velocidad, daños y más. También puedes comprar mejoras para tus superpoderes, como velocidad de vuelo, altura de salto, daño de aterrizaje y más.
- -Héroe de cuerda APK Mod 3 no se trata solo de balanceo de un edificio a otro. También se trata de usar tus superpoderes y armas para luchar contra el crimen y los enemigos. Tienes una variedad de superpoderes y armas que puedes usar a tu favor.
-Tu superpoder principal es tu súper cuerda, que te permite balancearte como una araña, saltar como una rana y realizar aterrizajes de potencia. Puedes usarlo para moverte por la ciudad rápida y fácilmente. También puedes usarlo para agarrar enemigos y objetos y tirarlos. También se puede utilizar para subir paredes y techos.
-Tus otros superpoderes incluyen volar como un pájaro, correr como un guepardo, golpear como un boxeador, patear como un ninja, y más. Puedes usarlas para luchar contra gángsters, policías y otros enemigos. También puedes usarlas para realizar acrobacias y trucos.
-Tus armas incluyen armas, armas cuerpo a cuerpo y súper armas. Puedes usarlas para disparar a los enemigos a distancia o a corta distancia. También puedes usarlas para destruir coches, bicicletas, helicópteros, aviones, robots y más. También puedes usarlas para crear explosiones y caos.
-Mundo abierto y misiones
-Héroe de cuerda APK Mod 3 no se trata solo de luchar contra los enemigos. También se trata de explorar la ciudad y completar misiones. Tienes un enorme mundo abierto que puedes recorrer libremente y descubrir nuevos lugares y secretos.
-La ciudad está dividida en diferentes distritos que tienen diferentes niveles de dificultad y recompensas. Puedes capturar distritos derrotando a los jefes y limpiando a los enemigos. También puedes completar misiones que involucran salvar civiles, detener crímenes, perseguir criminales, entregar paquetes, autos de carreras, pelear en arenas y más.
- -Héroe de cuerda APK Mod 3 no se trata solo de juego y contenido. También se trata de gráficos y optimización. El juego ha mejorado los gráficos y el rendimiento que lo hacen más realista y suave.
-El juego tiene gráficos en 3D que son coloridos y detallados. Puedes ver los edificios, coches, personas y objetos en la ciudad clara y vívidamente. También puedes ver los efectos de tus superpoderes y armas, como fuego, humo, chispas y sangre. También puede personalizar la configuración de gráficos según su dispositivo y preferencia.
-El juego también tiene optimización que lo hace correr más rápido y más suave en su dispositivo. Puede jugar el juego sin retraso o estrellarse. También puede guardar su progreso y datos en línea o fuera de línea. También puede jugar el juego con o sin conexión a Internet.
-Consejos y trucos para jugar héroe de la cuerda APK Mod 3
-Héroe de cuerda APK Mod 3 es un juego divertido y fácil de jugar, pero también puede ser difícil y difícil a veces. Aquí hay algunos consejos y trucos que pueden ayudarte a dominar el juego y divertirte más:
--
-
- Utilice su súper cuerda sabiamente. Es su herramienta principal para moverse por la ciudad y luchar contra los enemigos. Puedes usarlo para hacer swing, saltar, agarrar, lanzar, subir y más. También puedes actualizarlo para que sea más largo, más rápido, más fuerte y más. -
- Usa tus superpoderes y armas inteligentemente. Son tus armas principales para luchar contra los enemigos y destruir objetos. Puedes usarlos para volar, correr, golpear, patear, disparar, detonar y más. También puedes actualizarlos para hacerlos más potentes, precisos y diversos. -
- Usa tu dinero y gemas con moderación. Son tus principales recursos para comprar artículos y desbloquear funciones. Puedes usarlos para comprar armas, armas cuerpo a cuerpo, súper armas, pieles, mejoras y más. También puedes ganarlos completando misiones, capturando distritos, derrotando jefes y más. - -
- Completa las misiones diligentemente. Son tu principal fuente de información y recompensas. Puedes seguir la línea de búsqueda principal para descubrir la verdad sobre tu pasado y presente. También puedes hacer misiones secundarias para ayudar a la gente, detener crímenes, perseguir criminales, entregar paquetes, coches de carreras, luchar en arenas y más. -
Conclusión
-Héroe de cuerda APK Mod 3 es un juego de superhéroes con diversión ilimitada. Usted puede convertirse en un héroe de súper cuerda en una ciudad llena de crimen y aventura. Puede utilizar sus superpoderes y armas para luchar contra los enemigos y destruir objetos. También puedes explorar la ciudad y completar misiones para descubrir la verdad sobre ti mismo.
-Si quieres jugar a este juego en tu dispositivo, puedes descargarlo desde este enlace. Obtendrá dinero y gemas ilimitadas que puede usar para comprar artículos y desbloquear funciones. También obtendrá gráficos mejorados y la optimización que hará que su experiencia de juego más realista y suave.
-Entonces, ¿qué estás esperando? Descargar Rope Hero APK Mod 3 ahora y disfrutar de ser un héroe súper cuerda!
-Preguntas frecuentes
-Aquí hay algunas preguntas y respuestas frecuentes sobre Rope Hero APK Mod 3:
--
-
- ¿Es seguro descargar Rope Hero APK Mod 3? -
- ¿Es Rope Hero APK Mod 3 compatible con mi dispositivo? -
- ¿Cómo actualizo Rope Hero APK Mod 3? - -
- ¿Cómo me pongo en contacto con el desarrollador de Rope Hero APK Mod 3? -
- ¿Cómo califico y reviso Rope Hero APK Mod 3? -
Sí, Héroe de cuerda APK Mod 3 es seguro para descargar desde este enlace. No contiene ningún virus o malware que pueda dañar su dispositivo o datos.
-Héroe de cuerda APK Mod 3 es compatible con la mayoría de los dispositivos Android que tienen Android 4.4 o versiones superiores. Sin embargo, algunos dispositivos pueden tener diferentes especificaciones que pueden afectar el rendimiento del juego.
-Para ponerse en contacto con el desarrollador de Rope Hero APK Mod 3, puede visitar su sitio web oficial info@naxeex.com. También puedes seguirlos en Facebook, Twitter, Instagram y YouTube.
-Para calificar y revisar Rope Hero APK Mod 3, puede ir a Google Play Store y buscar el juego. Luego puedes tocar las estrellas para dar tu calificación y escribir tus comentarios en la sección de comentarios. También puedes compartir tu opinión con otros jugadores y leer sus reseñas.
--
-
\ No newline at end of file diff --git a/spaces/Benson/text-generation/Examples/Descarga Gratuita De Picas Para Ventanas 7.md b/spaces/Benson/text-generation/Examples/Descarga Gratuita De Picas Para Ventanas 7.md deleted file mode 100644 index 73815c9fdac8f1256773dcb6d90b274f4e9e0b68..0000000000000000000000000000000000000000 --- a/spaces/Benson/text-generation/Examples/Descarga Gratuita De Picas Para Ventanas 7.md +++ /dev/null @@ -1,125 +0,0 @@ -
-
Descargar Oluwa E Tobi Loba: Una poderosa canción de alabanza de Sammie Okposo
-Si usted está buscando una canción de alabanza que levantará su espíritu y glorificar a Dios, usted debe descargar Oluwa E Tobi Loba por Sammie Okposo. Esta canción es un remake de la canción popular de Tope Alabi con el mismo título, que significa "Dios, Eres Grande" en idioma yoruba. En este artículo, aprenderás más sobre esta canción, por qué deberías descargarla y cómo descargarla.
-¿Qué es Oluwa E Tobi Loba?
-Oluwa E Tobi Loba es una canción de alabanza de hip-hop que expresa la grandeza y majestad de Dios. Se canta en una mezcla de dialecto yoruba e inglés, con un coro pegadizo y un ritmo animado. La canción tiene las siguientes características:
-descarga gratuita de picas para ventanas 7
Download › https://bltlly.com/2v6LY5
-
El significado del título de la canción
-El título de la canción, Oluwa E Tobi Loba, es una frase yoruba que significa "Dios, eres grande". Es una declaración de la supremacía y soberanía de Dios sobre todas las cosas. También reconoce el poder y la fuerza de Dios, que son incomparables a cualquier persona o cualquier otra cosa.
-La letra y traducción de la canción
-La letra de la canción es la siguiente:
-- -La traducción de las partes yorubas es la siguiente:
El compositor y cantante de la canción
-La canción Oluwa E Tobi Loba es un remake de una canción popular de Tope Alabi, un cantante de gospel nigeriano, compositor de música de cine y actriz. Tope Alabi es conocida por sus canciones gospel yorubas que mezclan ritmos tradicionales y modernos. Ha lanzado más de 20 álbumes y ha ganado muchos premios por su música.
-El remake fue hecho por Sammie Okposo, otro artista gospel nigeriano, que también es productor musical, salmista y CEO de Zamar Entertainment. Sammie Okposo comenzó su carrera como productor de bandas sonoras en la industria cinematográfica nigeriana antes de cambiar a la producción musical. Lanzó su álbum debut, Amor incondicional, en 2000 y su segundo álbum, Addicted, en 2004. Ha colaborado con muchos otros artistas en los campos de la música gospel y soul, como Marvellous Odiete, Jonathan Nelson y Shaggy. También ha actuado en África, Europa y América del Norte, y comisariado una serie de conciertos llamados SOPP (Sammie Okposo Praise Party). Su álbum más reciente, The Statement, fue producido por el ganador del Grammy Kevin Bond.
- -¿Por qué descargar Oluwa E Tobi Loba?
-Oluwa E Tobi Loba es una canción que te inspirará a alabar a Dios con todo tu corazón y alma. Es una canción que les recordará la grandeza y majestad de Dios, y cómo Él merece toda la gloria y el honor. Aquí hay algunas razones por las que deberías descargar esta canción:
-Los beneficios de alabar a Dios con esta canción
-Alabar a Dios con esta canción te traerá muchos beneficios, como:
-
-
-
- Aumentará tu fe y confianza en Dios, que es capaz de hacer abundantemente sobre todo lo que puedes pedir o pensar. -
- Te llenará de alegría y paz, al expresar tu gratitud y amor a Dios, que es la fuente de tu vida y felicidad. - -
- Te acercará a Dios y profundizará tu relación con Él, mientras lo adoras en espíritu y en verdad. -
- Bendecirá a otros que lo escuchen y los animará a unirse a ustedes en la alabanza a Dios, que es digno de toda alabanza. -
Los testimonios de las personas que han sido bendecidas por esta canción
-Muchas personas han compartido sus testimonios de cómo esta canción los ha bendecido y cambiado sus vidas. Aquí están algunos de ellos:
---"Esta canción es una bendición para mí. Siempre me levanta el ánimo y me hace sentir la presencia de Dios. Lo toco cada mañana y cada noche, y me da fuerza y esperanza. Gracias, Sammie Okposo, por esta maravillosa canción." - Oluwaseun desde Lagos, Nigeria.
-
--"Me encanta esta canción tanto. Me recuerda lo grande y asombroso que es Dios. Ha hecho tantos milagros en mi vida, y no puedo agradecerle lo suficiente. Esta canción me ayuda a alabarlo con todo mi corazón y alma. Dios te bendiga, Sammie Okposo, por esta poderosa canción." - Esther de Accra, Ghana.
-
--"Esta canción es un milagro para mí. Estaba pasando por un momento muy difícil en mi vida, y me sentí como renunciar. Pero un día, escuché esta canción en la radio, y me conmovió profundamente. Me hizo darme cuenta de que Dios es más grande que mis problemas, y Él puede hacer cualquier cosa. Decidí confiar en Él y alabarlo, y Él cambió mi situación. Gracias, Sammie Okposo, por esta increíble canción." - John de Nairobi, Kenia.
-
Las mejores plataformas para descargar esta canción
-Si quieres descargar esta canción, tienes muchas opciones para elegir. Puedes descargarla desde varias plataformas, como:
-Cómo descargar Oluwa E Tobi Loba?
-Ahora que sabes lo que es Oluwa E Tobi Loba y por qué deberías descargarlo, te estarás preguntando cómo descargarlo. Bueno, no es difícil en absoluto. Solo tienes que seguir estos sencillos pasos:
-Los pasos a seguir para descargar esta canción
--
-
- Elija la plataforma desde la que desea descargar la canción. Puede utilizar cualquiera de las plataformas enumeradas en la sección anterior, o cualquier otra plataforma que prefiera. -
- Haga clic en el enlace que lo llevará al sitio web o aplicación de la plataforma. Es posible que necesite registrarse o iniciar sesión para acceder a la plataforma. -
- Busque la canción escribiendo "Oluwa E Tobi Loba" o "Sammie Okposo" en la barra de búsqueda. Debería ver la canción entre los resultados. -
- Haga clic en el botón de descarga o icono que le permitirá descargar la canción. Es posible que tenga que pagar una cuota o suscribirse a un plan para descargar la canción, dependiendo de la plataforma. -
- Espere a que se complete la descarga. Debería ver una notificación o un mensaje que confirme que la descarga se ha realizado correctamente. -
- Disfruta escuchando la canción en tu dispositivo. Puedes reproducirla offline o online, tantas veces como quieras. -
Los consejos para asegurar una descarga suave y segura
-Para asegurarte de que tu descarga sea fluida y segura, debes seguir estos consejos:
--
-
-
- Utilice una plataforma confiable y legal. Esto asegurará que obtengas una versión original y de alta calidad de la canción, y que no violes ninguna ley de derechos de autor. -
- Utilice un dispositivo compatible y actualizado. Esto asegurará que puede reproducir la canción sin problemas o problemas técnicos. -
- Utilice software antivirus y protección contra cortafuegos. Esto protegerá su dispositivo de cualquier virus o malware que pueda venir con la descarga. -
Las alternativas para descargar esta canción
-Si no quieres descargar esta canción, o si no puedes descargarla por alguna razón, tienes algunas alternativas. Puedes:
--
-
- Transmitir la canción en línea. Puede utilizar cualquiera de las plataformas enumeradas en la sección anterior, o cualquier otra plataforma que ofrece servicios de transmisión. Necesitará una conexión a Internet y un plan de suscripción para transmitir la canción. -
- Ver el video de la canción en línea. Puede utilizar plataformas como YouTube o Vimeo para ver el video de la canción. Necesitará una conexión a Internet y un navegador o aplicación para ver el video. -
- Compra el CD o DVD de la canción. Puedes usar plataformas como Amazon o eBay para comprar la copia física de la canción. Necesitará un reproductor de CD o DVD y un altavoz para reproducir la canción. -
Conclusión
-Oluwa E Tobi Loba es una poderosa canción de alabanza de Sammie Okposo que te inspirará a adorar a Dios con todo tu corazón y alma. Es un remake de la canción popular de Tope Alabi con el mismo título, que significa "Dios, Eres Grande" en idioma yoruba. Se canta en una mezcla de dialecto yoruba e inglés, con un estribillo pegadizo y un ritmo animado.
- -Puedes descargar esta canción desde varias plataformas, como Apple Music, Spotify, YouTube Music, Amazon Music, Audiomack y Boomplay. Solo tiene que seguir algunos pasos simples y consejos para garantizar una descarga suave y segura. Alternativamente, puede transmitir la canción en línea, ver el video de la canción en línea, o comprar el CD o DVD de la canción.
-Si usted está buscando una canción de alabanza que levantará su espíritu y glorificar a Dios, usted debe descargar Oluwa E Tobi Loba por Sammie Okposo hoy. ¡No te arrepentirás!
-Un llamado a la acción para los lectores
-Si has disfrutado leyendo este artículo, por favor compártelo con tus amigos y familiares que también pueden estar interesados en este tema. También, por favor deje un comentario a continuación y háganos saber lo que piensa acerca de esta canción y este artículo. Nos encantaría saber de usted!
-Preguntas frecuentes
-Aquí hay algunas preguntas frecuentes sobre Oluwa E Tobi Loba y sus respuestas:
-¿Cuál es el género de Oluwa E Tobi Loba?
-Oluwa E Tobi Loba es una canción de alabanza de hip-hop que combina ritmos tradicionales y modernos. Es un subgénero de música gospel que usa rap, ritmo y rima para expresar fe y adoración.
-¿Quién es el cantante original de Oluwa E Tobi Loba?
-El cantante original de Oluwa E Tobi Loba es Tope Alabi, una cantante de gospel nigeriana, compositora de música de cine y actriz. Lanzó la canción en 2018 como parte de su álbum titulado Yes and Amen.
-¿Cuál es la diferencia entre la versión de Sammie Okposo y la versión de Tope Alabi?
-La versión de Sammie Okposo es un remake de la versión de Tope Alabi, con algunos cambios y adiciones. Sammie Okposo agregó algunas letras en inglés, algunos sonidos de cuerno y algunas voces de fondo a la canción. También hizo la canción más optimista y enérgica, manteniendo el mensaje original y la melodía.
-¿Dónde puedo ver el video de Oluwa E Tobi Loba por Sammie Okposo?
- -¿Cómo puedo contactar con Sammie Okposo o Tope Alabi?
-Puede ponerse en contacto con Sammie Okposo o Tope Alabi a través de sus cuentas de redes sociales o sus sitios web. Aquí están sus datos:
--
-
- Sammie Okposo: Instagram, Facebook, Instagram, Facebook, `_
- for more details.
-
- :return: Service client instance
-
- """
- return self._session.create_client(
- service_name,
- region_name=region_name,
- api_version=api_version,
- use_ssl=use_ssl,
- verify=verify,
- endpoint_url=endpoint_url,
- aws_access_key_id=aws_access_key_id,
- aws_secret_access_key=aws_secret_access_key,
- aws_session_token=aws_session_token,
- config=config,
- )
-
- def resource(
- self,
- service_name,
- region_name=None,
- api_version=None,
- use_ssl=True,
- verify=None,
- endpoint_url=None,
- aws_access_key_id=None,
- aws_secret_access_key=None,
- aws_session_token=None,
- config=None,
- ):
- """
- Create a resource service client by name.
-
- :type service_name: string
- :param service_name: The name of a service, e.g. 's3' or 'ec2'. You
- can get a list of available services via
- :py:meth:`get_available_resources`.
-
- :type region_name: string
- :param region_name: The name of the region associated with the client.
- A client is associated with a single region.
-
- :type api_version: string
- :param api_version: The API version to use. By default, botocore will
- use the latest API version when creating a client. You only need
- to specify this parameter if you want to use a previous API version
- of the client.
-
- :type use_ssl: boolean
- :param use_ssl: Whether or not to use SSL. By default, SSL is used.
- Note that not all services support non-ssl connections.
-
- :type verify: boolean/string
- :param verify: Whether or not to verify SSL certificates. By default
- SSL certificates are verified. You can provide the following
- values:
-
- * False - do not validate SSL certificates. SSL will still be
- used (unless use_ssl is False), but SSL certificates
- will not be verified.
- * path/to/cert/bundle.pem - A filename of the CA cert bundle to
- uses. You can specify this argument if you want to use a
- different CA cert bundle than the one used by botocore.
-
- :type endpoint_url: string
- :param endpoint_url: The complete URL to use for the constructed
- client. Normally, botocore will automatically construct the
- appropriate URL to use when communicating with a service. You
- can specify a complete URL (including the "http/https" scheme)
- to override this behavior. If this value is provided,
- then ``use_ssl`` is ignored.
-
- :type aws_access_key_id: string
- :param aws_access_key_id: The access key to use when creating
- the client. This is entirely optional, and if not provided,
- the credentials configured for the session will automatically
- be used. You only need to provide this argument if you want
- to override the credentials used for this specific client.
-
- :type aws_secret_access_key: string
- :param aws_secret_access_key: The secret key to use when creating
- the client. Same semantics as aws_access_key_id above.
-
- :type aws_session_token: string
- :param aws_session_token: The session token to use when creating
- the client. Same semantics as aws_access_key_id above.
-
- :type config: botocore.client.Config
- :param config: Advanced client configuration options. If region_name
- is specified in the client config, its value will take precedence
- over environment variables and configuration values, but not over
- a region_name value passed explicitly to the method. If
- user_agent_extra is specified in the client config, it overrides
- the default user_agent_extra provided by the resource API. See
- `botocore config documentation
-
`` - see :class:`ParserElement.set_results_name`) - - Example:: - - integer = Word(nums) - date_str = (integer.set_results_name("year") + '/' - + integer.set_results_name("month") + '/' - + integer.set_results_name("day")) - # equivalent form: - # date_str = (integer("year") + '/' - # + integer("month") + '/' - # + integer("day")) - - # parse_string returns a ParseResults object - result = date_str.parse_string("1999/12/31") - - def test(s, fn=repr): - print("{} -> {}".format(s, fn(eval(s)))) - test("list(result)") - test("result[0]") - test("result['month']") - test("result.day") - test("'month' in result") - test("'minutes' in result") - test("result.dump()", str) - - prints:: - - list(result) -> ['1999', '/', '12', '/', '31'] - result[0] -> '1999' - result['month'] -> '12' - result.day -> '31' - 'month' in result -> True - 'minutes' in result -> False - result.dump() -> ['1999', '/', '12', '/', '31'] - - day: '31' - - month: '12' - - year: '1999' - """ - - _null_values: Tuple[Any, ...] = (None, [], "", ()) - - __slots__ = [ - "_name", - "_parent", - "_all_names", - "_modal", - "_toklist", - "_tokdict", - "__weakref__", - ] - - class List(list): - """ - Simple wrapper class to distinguish parsed list results that should be preserved - as actual Python lists, instead of being converted to :class:`ParseResults`: - - LBRACK, RBRACK = map(pp.Suppress, "[]") - element = pp.Forward() - item = ppc.integer - element_list = LBRACK + pp.delimited_list(element) + RBRACK - - # add parse actions to convert from ParseResults to actual Python collection types - def as_python_list(t): - return pp.ParseResults.List(t.as_list()) - element_list.add_parse_action(as_python_list) - - element <<= item | element_list - - element.run_tests(''' - 100 - [2,3,4] - [[2, 1],3,4] - [(2, 1),3,4] - (2,3,4) - ''', post_parse=lambda s, r: (r[0], type(r[0]))) - - prints: - - 100 - (100, ) - - [2,3,4] - ([2, 3, 4], ) - - [[2, 1],3,4] - ([[2, 1], 3, 4], ) - - (Used internally by :class:`Group` when `aslist=True`.) - """ - - def __new__(cls, contained=None): - if contained is None: - contained = [] - - if not isinstance(contained, list): - raise TypeError( - "{} may only be constructed with a list," - " not {}".format(cls.__name__, type(contained).__name__) - ) - - return list.__new__(cls) - - def __new__(cls, toklist=None, name=None, **kwargs): - if isinstance(toklist, ParseResults): - return toklist - self = object.__new__(cls) - self._name = None - self._parent = None - self._all_names = set() - - if toklist is None: - self._toklist = [] - elif isinstance(toklist, (list, _generator_type)): - self._toklist = ( - [toklist[:]] - if isinstance(toklist, ParseResults.List) - else list(toklist) - ) - else: - self._toklist = [toklist] - self._tokdict = dict() - return self - - # Performance tuning: we construct a *lot* of these, so keep this - # constructor as small and fast as possible - def __init__( - self, toklist=None, name=None, asList=True, modal=True, isinstance=isinstance - ): - self._modal = modal - if name is not None and name != "": - if isinstance(name, int): - name = str(name) - if not modal: - self._all_names = {name} - self._name = name - if toklist not in self._null_values: - if isinstance(toklist, (str_type, type)): - toklist = [toklist] - if asList: - if isinstance(toklist, ParseResults): - self[name] = _ParseResultsWithOffset( - ParseResults(toklist._toklist), 0 - ) - else: - self[name] = _ParseResultsWithOffset( - ParseResults(toklist[0]), 0 - ) - self[name]._name = name - else: - try: - self[name] = toklist[0] - except (KeyError, TypeError, IndexError): - if toklist is not self: - self[name] = toklist - else: - self._name = name - - def __getitem__(self, i): - if isinstance(i, (int, slice)): - return self._toklist[i] - else: - if i not in self._all_names: - return self._tokdict[i][-1][0] - else: - return ParseResults([v[0] for v in self._tokdict[i]]) - - def __setitem__(self, k, v, isinstance=isinstance): - if isinstance(v, _ParseResultsWithOffset): - self._tokdict[k] = self._tokdict.get(k, list()) + [v] - sub = v[0] - elif isinstance(k, (int, slice)): - self._toklist[k] = v - sub = v - else: - self._tokdict[k] = self._tokdict.get(k, list()) + [ - _ParseResultsWithOffset(v, 0) - ] - sub = v - if isinstance(sub, ParseResults): - sub._parent = wkref(self) - - def __delitem__(self, i): - if isinstance(i, (int, slice)): - mylen = len(self._toklist) - del self._toklist[i] - - # convert int to slice - if isinstance(i, int): - if i < 0: - i += mylen - i = slice(i, i + 1) - # get removed indices - removed = list(range(*i.indices(mylen))) - removed.reverse() - # fixup indices in token dictionary - for name, occurrences in self._tokdict.items(): - for j in removed: - for k, (value, position) in enumerate(occurrences): - occurrences[k] = _ParseResultsWithOffset( - value, position - (position > j) - ) - else: - del self._tokdict[i] - - def __contains__(self, k) -> bool: - return k in self._tokdict - - def __len__(self) -> int: - return len(self._toklist) - - def __bool__(self) -> bool: - return not not (self._toklist or self._tokdict) - - def __iter__(self) -> Iterator: - return iter(self._toklist) - - def __reversed__(self) -> Iterator: - return iter(self._toklist[::-1]) - - def keys(self): - return iter(self._tokdict) - - def values(self): - return (self[k] for k in self.keys()) - - def items(self): - return ((k, self[k]) for k in self.keys()) - - def haskeys(self) -> bool: - """ - Since ``keys()`` returns an iterator, this method is helpful in bypassing - code that looks for the existence of any defined results names.""" - return bool(self._tokdict) - - def pop(self, *args, **kwargs): - """ - Removes and returns item at specified index (default= ``last``). - Supports both ``list`` and ``dict`` semantics for ``pop()``. If - passed no argument or an integer argument, it will use ``list`` - semantics and pop tokens from the list of parsed tokens. If passed - a non-integer argument (most likely a string), it will use ``dict`` - semantics and pop the corresponding value from any defined results - names. A second default return value argument is supported, just as in - ``dict.pop()``. - - Example:: - - numlist = Word(nums)[...] - print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321'] - - def remove_first(tokens): - tokens.pop(0) - numlist.add_parse_action(remove_first) - print(numlist.parse_string("0 123 321")) # -> ['123', '321'] - - label = Word(alphas) - patt = label("LABEL") + Word(nums)[1, ...] - print(patt.parse_string("AAB 123 321").dump()) - - # Use pop() in a parse action to remove named result (note that corresponding value is not - # removed from list form of results) - def remove_LABEL(tokens): - tokens.pop("LABEL") - return tokens - patt.add_parse_action(remove_LABEL) - print(patt.parse_string("AAB 123 321").dump()) - - prints:: - - ['AAB', '123', '321'] - - LABEL: 'AAB' - - ['AAB', '123', '321'] - """ - if not args: - args = [-1] - for k, v in kwargs.items(): - if k == "default": - args = (args[0], v) - else: - raise TypeError( - "pop() got an unexpected keyword argument {!r}".format(k) - ) - if isinstance(args[0], int) or len(args) == 1 or args[0] in self: - index = args[0] - ret = self[index] - del self[index] - return ret - else: - defaultvalue = args[1] - return defaultvalue - - def get(self, key, default_value=None): - """ - Returns named result matching the given key, or if there is no - such name, then returns the given ``default_value`` or ``None`` if no - ``default_value`` is specified. - - Similar to ``dict.get()``. - - Example:: - - integer = Word(nums) - date_str = integer("year") + '/' + integer("month") + '/' + integer("day") - - result = date_str.parse_string("1999/12/31") - print(result.get("year")) # -> '1999' - print(result.get("hour", "not specified")) # -> 'not specified' - print(result.get("hour")) # -> None - """ - if key in self: - return self[key] - else: - return default_value - - def insert(self, index, ins_string): - """ - Inserts new element at location index in the list of parsed tokens. - - Similar to ``list.insert()``. - - Example:: - - numlist = Word(nums)[...] - print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321'] - - # use a parse action to insert the parse location in the front of the parsed results - def insert_locn(locn, tokens): - tokens.insert(0, locn) - numlist.add_parse_action(insert_locn) - print(numlist.parse_string("0 123 321")) # -> [0, '0', '123', '321'] - """ - self._toklist.insert(index, ins_string) - # fixup indices in token dictionary - for name, occurrences in self._tokdict.items(): - for k, (value, position) in enumerate(occurrences): - occurrences[k] = _ParseResultsWithOffset( - value, position + (position > index) - ) - - def append(self, item): - """ - Add single element to end of ``ParseResults`` list of elements. - - Example:: - - numlist = Word(nums)[...] - print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321'] - - # use a parse action to compute the sum of the parsed integers, and add it to the end - def append_sum(tokens): - tokens.append(sum(map(int, tokens))) - numlist.add_parse_action(append_sum) - print(numlist.parse_string("0 123 321")) # -> ['0', '123', '321', 444] - """ - self._toklist.append(item) - - def extend(self, itemseq): - """ - Add sequence of elements to end of ``ParseResults`` list of elements. - - Example:: - - patt = Word(alphas)[1, ...] - - # use a parse action to append the reverse of the matched strings, to make a palindrome - def make_palindrome(tokens): - tokens.extend(reversed([t[::-1] for t in tokens])) - return ''.join(tokens) - patt.add_parse_action(make_palindrome) - print(patt.parse_string("lskdj sdlkjf lksd")) # -> 'lskdjsdlkjflksddsklfjkldsjdksl' - """ - if isinstance(itemseq, ParseResults): - self.__iadd__(itemseq) - else: - self._toklist.extend(itemseq) - - def clear(self): - """ - Clear all elements and results names. - """ - del self._toklist[:] - self._tokdict.clear() - - def __getattr__(self, name): - try: - return self[name] - except KeyError: - if name.startswith("__"): - raise AttributeError(name) - return "" - - def __add__(self, other) -> "ParseResults": - ret = self.copy() - ret += other - return ret - - def __iadd__(self, other) -> "ParseResults": - if other._tokdict: - offset = len(self._toklist) - addoffset = lambda a: offset if a < 0 else a + offset - otheritems = other._tokdict.items() - otherdictitems = [ - (k, _ParseResultsWithOffset(v[0], addoffset(v[1]))) - for k, vlist in otheritems - for v in vlist - ] - for k, v in otherdictitems: - self[k] = v - if isinstance(v[0], ParseResults): - v[0]._parent = wkref(self) - - self._toklist += other._toklist - self._all_names |= other._all_names - return self - - def __radd__(self, other) -> "ParseResults": - if isinstance(other, int) and other == 0: - # useful for merging many ParseResults using sum() builtin - return self.copy() - else: - # this may raise a TypeError - so be it - return other + self - - def __repr__(self) -> str: - return "{}({!r}, {})".format(type(self).__name__, self._toklist, self.as_dict()) - - def __str__(self) -> str: - return ( - "[" - + ", ".join( - [ - str(i) if isinstance(i, ParseResults) else repr(i) - for i in self._toklist - ] - ) - + "]" - ) - - def _asStringList(self, sep=""): - out = [] - for item in self._toklist: - if out and sep: - out.append(sep) - if isinstance(item, ParseResults): - out += item._asStringList() - else: - out.append(str(item)) - return out - - def as_list(self) -> list: - """ - Returns the parse results as a nested list of matching tokens, all converted to strings. - - Example:: - - patt = Word(alphas)[1, ...] - result = patt.parse_string("sldkj lsdkj sldkj") - # even though the result prints in string-like form, it is actually a pyparsing ParseResults - print(type(result), result) # -> ['sldkj', 'lsdkj', 'sldkj'] - - # Use as_list() to create an actual list - result_list = result.as_list() - print(type(result_list), result_list) # -> ['sldkj', 'lsdkj', 'sldkj'] - """ - return [ - res.as_list() if isinstance(res, ParseResults) else res - for res in self._toklist - ] - - def as_dict(self) -> dict: - """ - Returns the named parse results as a nested dictionary. - - Example:: - - integer = Word(nums) - date_str = integer("year") + '/' + integer("month") + '/' + integer("day") - - result = date_str.parse_string('12/31/1999') - print(type(result), repr(result)) # -> (['12', '/', '31', '/', '1999'], {'day': [('1999', 4)], 'year': [('12', 0)], 'month': [('31', 2)]}) - - result_dict = result.as_dict() - print(type(result_dict), repr(result_dict)) # -> {'day': '1999', 'year': '12', 'month': '31'} - - # even though a ParseResults supports dict-like access, sometime you just need to have a dict - import json - print(json.dumps(result)) # -> Exception: TypeError: ... is not JSON serializable - print(json.dumps(result.as_dict())) # -> {"month": "31", "day": "1999", "year": "12"} - """ - - def to_item(obj): - if isinstance(obj, ParseResults): - return obj.as_dict() if obj.haskeys() else [to_item(v) for v in obj] - else: - return obj - - return dict((k, to_item(v)) for k, v in self.items()) - - def copy(self) -> "ParseResults": - """ - Returns a new copy of a :class:`ParseResults` object. - """ - ret = ParseResults(self._toklist) - ret._tokdict = self._tokdict.copy() - ret._parent = self._parent - ret._all_names |= self._all_names - ret._name = self._name - return ret - - def get_name(self): - r""" - Returns the results name for this token expression. Useful when several - different expressions might match at a particular location. - - Example:: - - integer = Word(nums) - ssn_expr = Regex(r"\d\d\d-\d\d-\d\d\d\d") - house_number_expr = Suppress('#') + Word(nums, alphanums) - user_data = (Group(house_number_expr)("house_number") - | Group(ssn_expr)("ssn") - | Group(integer)("age")) - user_info = user_data[1, ...] - - result = user_info.parse_string("22 111-22-3333 #221B") - for item in result: - print(item.get_name(), ':', item[0]) - - prints:: - - age : 22 - ssn : 111-22-3333 - house_number : 221B - """ - if self._name: - return self._name - elif self._parent: - par = self._parent() - - def find_in_parent(sub): - return next( - ( - k - for k, vlist in par._tokdict.items() - for v, loc in vlist - if sub is v - ), - None, - ) - - return find_in_parent(self) if par else None - elif ( - len(self) == 1 - and len(self._tokdict) == 1 - and next(iter(self._tokdict.values()))[0][1] in (0, -1) - ): - return next(iter(self._tokdict.keys())) - else: - return None - - def dump(self, indent="", full=True, include_list=True, _depth=0) -> str: - """ - Diagnostic method for listing out the contents of - a :class:`ParseResults`. Accepts an optional ``indent`` argument so - that this string can be embedded in a nested display of other data. - - Example:: - - integer = Word(nums) - date_str = integer("year") + '/' + integer("month") + '/' + integer("day") - - result = date_str.parse_string('1999/12/31') - print(result.dump()) - - prints:: - - ['1999', '/', '12', '/', '31'] - - day: '31' - - month: '12' - - year: '1999' - """ - out = [] - NL = "\n" - out.append(indent + str(self.as_list()) if include_list else "") - - if full: - if self.haskeys(): - items = sorted((str(k), v) for k, v in self.items()) - for k, v in items: - if out: - out.append(NL) - out.append("{}{}- {}: ".format(indent, (" " * _depth), k)) - if isinstance(v, ParseResults): - if v: - out.append( - v.dump( - indent=indent, - full=full, - include_list=include_list, - _depth=_depth + 1, - ) - ) - else: - out.append(str(v)) - else: - out.append(repr(v)) - if any(isinstance(vv, ParseResults) for vv in self): - v = self - for i, vv in enumerate(v): - if isinstance(vv, ParseResults): - out.append( - "\n{}{}[{}]:\n{}{}{}".format( - indent, - (" " * (_depth)), - i, - indent, - (" " * (_depth + 1)), - vv.dump( - indent=indent, - full=full, - include_list=include_list, - _depth=_depth + 1, - ), - ) - ) - else: - out.append( - "\n%s%s[%d]:\n%s%s%s" - % ( - indent, - (" " * (_depth)), - i, - indent, - (" " * (_depth + 1)), - str(vv), - ) - ) - - return "".join(out) - - def pprint(self, *args, **kwargs): - """ - Pretty-printer for parsed results as a list, using the - `pprint -#include -#include -#include -#include -#include -#include - -namespace thrust -{ - -namespace detail -{ - -template - class vector_base -{ - private: - typedef thrust::detail::contiguous_storage reverse_iterator; - typedef thrust::reverse_iterator const_reverse_iterator; - - /*! This constructor creates an empty vector_base. - */ - vector_base(void); - - /*! This constructor creates an empty vector_base. - * \param alloc The allocator to use by this vector_base. - */ - explicit vector_base(const Alloc &alloc); - - /*! This constructor creates a vector_base with default-constructed - * elements. - * \param n The number of elements to create. - */ - explicit vector_base(size_type n); - - /*! This constructor creates a vector_base with default-constructed - * elements. - * \param n The number of elements to create. - * \param alloc The allocator to use by this vector_base. - */ - explicit vector_base(size_type n, const Alloc &alloc); - - /*! This constructor creates a vector_base with copies - * of an exemplar element. - * \param n The number of elements to initially create. - * \param value An element to copy. - */ - explicit vector_base(size_type n, const value_type &value); - - /*! This constructor creates a vector_base with copies - * of an exemplar element. - * \param n The number of elements to initially create. - * \param value An element to copy. - * \param alloc The allocator to use by this vector_base. - */ - explicit vector_base(size_type n, const value_type &value, const Alloc &alloc); - - /*! Copy constructor copies from an exemplar vector_base. - * \param v The vector_base to copy. - */ - vector_base(const vector_base &v); - - /*! Copy constructor copies from an exemplar vector_base. - * \param v The vector_base to copy. - * \param alloc The allocator to use by this vector_base. - */ - vector_base(const vector_base &v, const Alloc &alloc); - - #if THRUST_CPP_DIALECT >= 2011 - /*! Move constructor moves from another vector_base. - * \param v The vector_base to move. - */ - vector_base(vector_base &&v); - - // FIXME: the internal Thrust machinery in range_init doesn't work with move - // iterators, which is necessary for the following constructor to be implemented - // correctly - // vector_base(vector_base &&v, const Alloc &alloc); - #endif - - /*! Copy assign operator copies from another vector_base. - * \param v The vector_base to copy. - */ - vector_base &operator=(const vector_base &v); - - #if THRUST_CPP_DIALECT >= 2011 - /*! Move assign operator moves from another vector_base. - * \param v The vector_base to move. - */ - vector_base &operator=(vector_base &&v); - #endif - - /*! Copy constructor copies from an exemplar vector_base with different - * type. - * \param v The vector_base to copy. - */ - template - vector_base(const vector_base - vector_base &operator=(const vector_base - vector_base(const std::vector - vector_base &operator=(const std::vector - vector_base(InputIterator first, InputIterator last); - - /*! This constructor builds a vector_base from a range. - * \param first The beginning of the range. - * \param last The end of the range. - * \param alloc The allocator to use by this vector_base. - */ - template - vector_base(InputIterator first, InputIterator last, const Alloc &alloc); - - /*! The destructor erases the elements. - */ - ~vector_base(void); - - /*! \brief Resizes this vector_base to the specified number of elements. - * \param new_size Number of elements this vector_base should contain. - * \throw std::length_error If n exceeds max_size9). - * - * This method will resize this vector_base to the specified number of - * elements. If the number is smaller than this vector_base's current - * size this vector_base is truncated, otherwise this vector_base is - * extended and new elements are default constructed. - */ - void resize(size_type new_size); - - /*! \brief Resizes this vector_base to the specified number of elements. - * \param new_size Number of elements this vector_base should contain. - * \param x Data with which new elements should be populated. - * \throw std::length_error If n exceeds max_size(). - * - * This method will resize this vector_base to the specified number of - * elements. If the number is smaller than this vector_base's current - * size this vector_base is truncated, otherwise this vector_base is - * extended and new elements are populated with given data. - */ - void resize(size_type new_size, const value_type &x); - - /*! Returns the number of elements in this vector_base. - */ - size_type size(void) const; - - /*! Returns the size() of the largest possible vector_base. - * \return The largest possible return value of size(). - */ - size_type max_size(void) const; - - /*! \brief If n is less than or equal to capacity(), this call has no effect. - * Otherwise, this method is a request for allocation of additional memory. If - * the request is successful, then capacity() is greater than or equal to - * n; otherwise, capacity() is unchanged. In either case, size() is unchanged. - * \throw std::length_error If n exceeds max_size(). - */ - void reserve(size_type n); - - /*! Returns the number of elements which have been reserved in this - * vector_base. - */ - size_type capacity(void) const; - - /*! This method shrinks the capacity of this vector_base to exactly - * fit its elements. - */ - void shrink_to_fit(void); - - /*! \brief Subscript access to the data contained in this vector_dev. - * \param n The index of the element for which data should be accessed. - * \return Read/write reference to data. - * - * This operator allows for easy, array-style, data access. - * Note that data access with this operator is unchecked and - * out_of_range lookups are not defined. - */ - reference operator[](size_type n); - - /*! \brief Subscript read access to the data contained in this vector_dev. - * \param n The index of the element for which data should be accessed. - * \return Read reference to data. - * - * This operator allows for easy, array-style, data access. - * Note that data access with this operator is unchecked and - * out_of_range lookups are not defined. - */ - const_reference operator[](size_type n) const; - - /*! This method returns an iterator pointing to the beginning of - * this vector_base. - * \return mStart - */ - iterator begin(void); - - /*! This method returns a const_iterator pointing to the beginning - * of this vector_base. - * \return mStart - */ - const_iterator begin(void) const; - - /*! This method returns a const_iterator pointing to the beginning - * of this vector_base. - * \return mStart - */ - const_iterator cbegin(void) const; - - /*! This method returns a reverse_iterator pointing to the beginning of - * this vector_base's reversed sequence. - * \return A reverse_iterator pointing to the beginning of this - * vector_base's reversed sequence. - */ - reverse_iterator rbegin(void); - - /*! This method returns a const_reverse_iterator pointing to the beginning of - * this vector_base's reversed sequence. - * \return A const_reverse_iterator pointing to the beginning of this - * vector_base's reversed sequence. - */ - const_reverse_iterator rbegin(void) const; - - /*! This method returns a const_reverse_iterator pointing to the beginning of - * this vector_base's reversed sequence. - * \return A const_reverse_iterator pointing to the beginning of this - * vector_base's reversed sequence. - */ - const_reverse_iterator crbegin(void) const; - - /*! This method returns an iterator pointing to one element past the - * last of this vector_base. - * \return begin() + size(). - */ - iterator end(void); - - /*! This method returns a const_iterator pointing to one element past the - * last of this vector_base. - * \return begin() + size(). - */ - const_iterator end(void) const; - - /*! This method returns a const_iterator pointing to one element past the - * last of this vector_base. - * \return begin() + size(). - */ - const_iterator cend(void) const; - - /*! This method returns a reverse_iterator pointing to one element past the - * last of this vector_base's reversed sequence. - * \return rbegin() + size(). - */ - reverse_iterator rend(void); - - /*! This method returns a const_reverse_iterator pointing to one element past the - * last of this vector_base's reversed sequence. - * \return rbegin() + size(). - */ - const_reverse_iterator rend(void) const; - - /*! This method returns a const_reverse_iterator pointing to one element past the - * last of this vector_base's reversed sequence. - * \return rbegin() + size(). - */ - const_reverse_iterator crend(void) const; - - /*! This method returns a const_reference referring to the first element of this - * vector_base. - * \return The first element of this vector_base. - */ - const_reference front(void) const; - - /*! This method returns a reference pointing to the first element of this - * vector_base. - * \return The first element of this vector_base. - */ - reference front(void); - - /*! This method returns a const reference pointing to the last element of - * this vector_base. - * \return The last element of this vector_base. - */ - const_reference back(void) const; - - /*! This method returns a reference referring to the last element of - * this vector_dev. - * \return The last element of this vector_base. - */ - reference back(void); - - /*! This method returns a pointer to this vector_base's first element. - * \return A pointer to the first element of this vector_base. - */ - pointer data(void); - - /*! This method returns a const_pointer to this vector_base's first element. - * \return a const_pointer to the first element of this vector_base. - */ - const_pointer data(void) const; - - /*! This method resizes this vector_base to 0. - */ - void clear(void); - - /*! This method returns true iff size() == 0. - * \return true if size() == 0; false, otherwise. - */ - bool empty(void) const; - - /*! This method appends the given element to the end of this vector_base. - * \param x The element to append. - */ - void push_back(const value_type &x); - - /*! This method erases the last element of this vector_base, invalidating - * all iterators and references to it. - */ - void pop_back(void); - - /*! This method swaps the contents of this vector_base with another vector_base. - * \param v The vector_base with which to swap. - */ - void swap(vector_base &v); - - /*! This method removes the element at position pos. - * \param pos The position of the element of interest. - * \return An iterator pointing to the new location of the element that followed the element - * at position pos. - */ - iterator erase(iterator pos); - - /*! This method removes the range of elements [first,last) from this vector_base. - * \param first The beginning of the range of elements to remove. - * \param last The end of the range of elements to remove. - * \return An iterator pointing to the new location of the element that followed the last - * element in the sequence [first,last). - */ - iterator erase(iterator first, iterator last); - - /*! This method inserts a single copy of a given exemplar value at the - * specified position in this vector_base. - * \param position The insertion position. - * \param x The exemplar element to copy & insert. - * \return An iterator pointing to the newly inserted element. - */ - iterator insert(iterator position, const T &x); - - /*! This method inserts a copy of an exemplar value to a range at the - * specified position in this vector_base. - * \param position The insertion position - * \param n The number of insertions to perform. - * \param x The value to replicate and insert. - */ - void insert(iterator position, size_type n, const T &x); - - /*! This method inserts a copy of an input range at the specified position - * in this vector_base. - * \param position The insertion position. - * \param first The beginning of the range to copy. - * \param last The end of the range to copy. - * - * \tparam InputIterator is a model of Assignable. - */ - template - void insert(iterator position, InputIterator first, InputIterator last); - - /*! This version of \p assign replicates a given exemplar - * \p n times into this vector_base. - * \param n The number of times to copy \p x. - * \param x The exemplar element to replicate. - */ - void assign(size_type n, const T &x); - - /*! This version of \p assign makes this vector_base a copy of a given input range. - * \param first The beginning of the range to copy. - * \param last The end of the range to copy. - * - * \tparam InputIterator is a model of Input Iterator. - */ - template - void assign(InputIterator first, InputIterator last); - - /*! This method returns a copy of this vector's allocator. - * \return A copy of the alloctor used by this vector. - */ - allocator_type get_allocator(void) const; - - protected: - // Our storage - storage_type m_storage; - - // The size of this vector_base, in number of elements. - size_type m_size; - - private: - // these methods resolve the ambiguity of the constructor template of form (Iterator, Iterator) - template - void init_dispatch(IteratorOrIntegralType begin, IteratorOrIntegralType end, false_type); - - template - void init_dispatch(IteratorOrIntegralType n, IteratorOrIntegralType value, true_type); - - template - void range_init(InputIterator first, InputIterator last); - - template - void range_init(InputIterator first, InputIterator last, thrust::incrementable_traversal_tag); - - template - void range_init(ForwardIterator first, ForwardIterator last, thrust::random_access_traversal_tag); - - void default_init(size_type n); - - void fill_init(size_type n, const T &x); - - // these methods resolve the ambiguity of the insert() template of form (iterator, InputIterator, InputIterator) - template - void insert_dispatch(iterator position, InputIteratorOrIntegralType first, InputIteratorOrIntegralType last, false_type); - - // these methods resolve the ambiguity of the insert() template of form (iterator, InputIterator, InputIterator) - template - void insert_dispatch(iterator position, InputIteratorOrIntegralType n, InputIteratorOrIntegralType x, true_type); - - // this method appends n default-constructed elements at the end - void append(size_type n); - - // this method performs insertion from a fill value - void fill_insert(iterator position, size_type n, const T &x); - - // this method performs insertion from a range - template - void copy_insert(iterator position, InputIterator first, InputIterator last); - - // these methods resolve the ambiguity of the assign() template of form (InputIterator, InputIterator) - template - void assign_dispatch(InputIterator first, InputIterator last, false_type); - - // these methods resolve the ambiguity of the assign() template of form (InputIterator, InputIterator) - template - void assign_dispatch(Integral n, Integral x, true_type); - - // this method performs assignment from a range - template - void range_assign(InputIterator first, InputIterator last); - - // this method performs assignment from a range of RandomAccessIterators - template - void range_assign(RandomAccessIterator first, RandomAccessIterator last, thrust::random_access_traversal_tag); - - // this method performs assignment from a range of InputIterators - template - void range_assign(InputIterator first, InputIterator last, thrust::incrementable_traversal_tag); - - // this method performs assignment from a fill value - void fill_assign(size_type n, const T &x); - - // this method allocates new storage and construct copies the given range - template - void allocate_and_copy(size_type requested_size, - ForwardIterator first, ForwardIterator last, - storage_type &new_storage); -}; // end vector_base - -} // end detail - -/*! This function assigns the contents of vector a to vector b and the - * contents of vector b to vector a. - * - * \param a The first vector of interest. After completion, the contents - * of b will be returned here. - * \param b The second vector of interest. After completion, the contents - * of a will be returned here. - */ -template - void swap(detail::vector_base -bool operator==(const detail::vector_base -bool operator==(const detail::vector_base -bool operator==(const std::vector -bool operator!=(const detail::vector_base -bool operator!=(const detail::vector_base -bool operator!=(const std::vector - diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/cuda/memory.h b/spaces/CVPR/LIVE/thrust/thrust/system/cuda/memory.h deleted file mode 100644 index f20ce352a2340f83871d31769ecffe872c7193d2..0000000000000000000000000000000000000000 --- a/spaces/CVPR/LIVE/thrust/thrust/system/cuda/memory.h +++ /dev/null @@ -1,93 +0,0 @@ -/* - * Copyright 2008-2018 NVIDIA Corporation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in ccudaliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/*! \file thrust/system/cuda/memory.h - * \brief Managing memory associated with Thrust's CUDA system. - */ - -#pragma once - -#include -#include -#include -#include -#include -#include - -namespace thrust -{ -namespace cuda_cub { - -/*! Allocates an area of memory available to Thrust's cuda system. - * \param n Number of bytes to allocate. - * \return A cuda::pointer pointing to the beginning of the newly - * allocated memory. A null cuda::pointer is returned if - * an error occurs. - * \note The cuda::pointer returned by this function must be - * deallocated with \p cuda::free. - * \see cuda::free - * \see std::malloc - */ -inline __host__ __device__ pointer malloc(std::size_t n); - -/*! Allocates a typed area of memory available to Thrust's cuda system. - * \param n Number of elements to allocate. - * \return A cuda::pointer pointing to the beginning of the newly - * allocated elements. A null cuda::pointer is returned if - * an error occurs. - * \note The cuda::pointer returned by this function must be - * deallocated with \p cuda::free. - * \see cuda::free - * \see std::malloc - */ -template -inline __host__ __device__ pointer malloc(std::size_t n); - -/*! Deallocates an area of memory previously allocated by cuda::malloc. - * \param ptr A cuda::pointer pointing to the beginning of an area - * of memory previously allocated with cuda::malloc. - * \see cuda::malloc - * \see std::free - */ -inline __host__ __device__ void free(pointer ptr); - -/*! \p cuda::allocator is the default allocator used by the \p cuda system's containers such as - * cuda::vector if no user-specified allocator is provided. \p cuda::allocator allocates - * (deallocates) storage with \p cuda::malloc (\p cuda::free). - */ -template -using allocator = thrust::mr::stateless_resource_allocator - diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/reduce.h b/spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/reduce.h deleted file mode 100644 index c058e05db4c78c8601c0bd322a7edd8f9ba16d89..0000000000000000000000000000000000000000 --- a/spaces/CVPR/LIVE/thrust/thrust/system/omp/detail/reduce.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright 2008-2013 NVIDIA Corporation - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - -/*! \file reduce.h - * \brief OpenMP implementation of reduce algorithms. - */ - -#pragma once - -#include -#include - -namespace thrust -{ -namespace system -{ -namespace omp -{ -namespace detail -{ - - -template - OutputType reduce(execution_policy &exec, - InputIterator first, - InputIterator last, - OutputType init, - BinaryFunction binary_op); - - -} // end namespace detail -} // end namespace omp -} // end namespace system -} // end namespace thrust - -#include - diff --git a/spaces/CVPR/drawings-to-human/static/_app/immutable/error.svelte-d9523301.js b/spaces/CVPR/drawings-to-human/static/_app/immutable/error.svelte-d9523301.js deleted file mode 100644 index 1c200845989d5bbde3173a928c2ca48d13743a81..0000000000000000000000000000000000000000 --- a/spaces/CVPR/drawings-to-human/static/_app/immutable/error.svelte-d9523301.js +++ /dev/null @@ -1 +0,0 @@ -import{S as w,i as y,s as z,e as E,t as v,c as d,a as b,h as P,d as o,g as u,J as R,j as N,k as S,l as C,m as j,E as H}from"./chunks/index-bcf2726a.js";function J(r){let l,t=r[1].frame+"",a;return{c(){l=E("pre"),a=v(t)},l(f){l=d(f,"PRE",{});var s=b(l);a=P(s,t),s.forEach(o)},m(f,s){u(f,l,s),R(l,a)},p(f,s){s&2&&t!==(t=f[1].frame+"")&&N(a,t)},d(f){f&&o(l)}}}function h(r){let l,t=r[1].stack+"",a;return{c(){l=E("pre"),a=v(t)},l(f){l=d(f,"PRE",{});var s=b(l);a=P(s,t),s.forEach(o)},m(f,s){u(f,l,s),R(l,a)},p(f,s){s&2&&t!==(t=f[1].stack+"")&&N(a,t)},d(f){f&&o(l)}}}function A(r){let l,t,a,f,s=r[1].message+"",c,k,n,p,i=r[1].frame&&J(r),_=r[1].stack&&h(r);return{c(){l=E("h1"),t=v(r[0]),a=S(),f=E("pre"),c=v(s),k=S(),i&&i.c(),n=S(),_&&_.c(),p=C()},l(e){l=d(e,"H1",{});var m=b(l);t=P(m,r[0]),m.forEach(o),a=j(e),f=d(e,"PRE",{});var q=b(f);c=P(q,s),q.forEach(o),k=j(e),i&&i.l(e),n=j(e),_&&_.l(e),p=C()},m(e,m){u(e,l,m),R(l,t),u(e,a,m),u(e,f,m),R(f,c),u(e,k,m),i&&i.m(e,m),u(e,n,m),_&&_.m(e,m),u(e,p,m)},p(e,[m]){m&1&&N(t,e[0]),m&2&&s!==(s=e[1].message+"")&&N(c,s),e[1].frame?i?i.p(e,m):(i=J(e),i.c(),i.m(n.parentNode,n)):i&&(i.d(1),i=null),e[1].stack?_?_.p(e,m):(_=h(e),_.c(),_.m(p.parentNode,p)):_&&(_.d(1),_=null)},i:H,o:H,d(e){e&&o(l),e&&o(a),e&&o(f),e&&o(k),i&&i.d(e),e&&o(n),_&&_.d(e),e&&o(p)}}}function F({error:r,status:l}){return{props:{error:r,status:l}}}function B(r,l,t){let{status:a}=l,{error:f}=l;return r.$$set=s=>{"status"in s&&t(0,a=s.status),"error"in s&&t(1,f=s.error)},[a,f]}class G extends w{constructor(l){super(),y(this,l,B,A,z,{status:0,error:1})}}export{G as default,F as load}; diff --git a/spaces/CVPR/v-doc_abstractive_mac/mi_lstm_cell.py b/spaces/CVPR/v-doc_abstractive_mac/mi_lstm_cell.py deleted file mode 100644 index 6cfa2f66cc532f099cc8f1dc9aede27475d2bdc9..0000000000000000000000000000000000000000 --- a/spaces/CVPR/v-doc_abstractive_mac/mi_lstm_cell.py +++ /dev/null @@ -1,77 +0,0 @@ -import tensorflow as tf -import numpy as np - -class MiLSTMCell(tf.nn.rnn_cell.RNNCell): - def __init__(self, num_units, forget_bias = 1.0, input_size = None, - state_is_tuple = True, activation = tf.tanh, reuse = None): - self.numUnits = num_units - self.forgetBias = forget_bias - self.activation = activation - self.reuse = reuse - - @property - def state_size(self): - return tf.nn.rnn_cell.LSTMStateTuple(self.numUnits, self.numUnits) - - @property - def output_size(self): - return self.numUnits - - def mulWeights(self, inp, inDim, outDim, name = ""): - with tf.variable_scope("weights" + name): - W = tf.get_variable("weights", shape = (inDim, outDim), - initializer = tf.contrib.layers.xavier_initializer()) - output = tf.matmul(inp, W) - return output - - def addBiases(self, inp1, inp2, dim, name = ""): - with tf.variable_scope("additiveBiases" + name): - b = tf.get_variable("biases", shape = (dim,), - initializer = tf.zeros_initializer()) - with tf.variable_scope("multiplicativeBias" + name): - beta = tf.get_variable("biases", shape = (3 * dim,), - initializer = tf.ones_initializer()) - - Wx, Uh, inter = tf.split(beta * tf.concat([inp1, inp2, inp1 * inp2], axis = 1), - num_or_size_splits = 3, axis = 1) - output = Wx + Uh + inter + b - return output - - def __call__(self, inputs, state, scope = None): - scope = scope or type(self).__name__ - with tf.variable_scope(scope, reuse = self.reuse): - c, h = state - inputSize = int(inputs.shape[1]) - - Wx = self.mulWeights(inputs, inputSize, self.numUnits, name = "Wxi") - Uh = self.mulWeights(h, self.numUnits, self.numUnits, name = "Uhi") - - i = self.addBiases(Wx, Uh, self.numUnits, name = "i") - - Wx = self.mulWeights(inputs, inputSize, self.numUnits, name = "Wxj") - Uh = self.mulWeights(h, self.numUnits, self.numUnits, name = "Uhj") - - j = self.addBiases(Wx, Uh, self.numUnits, name = "l") - - Wx = self.mulWeights(inputs, inputSize, self.numUnits, name = "Wxf") - Uh = self.mulWeights(h, self.numUnits, self.numUnits, name = "Uhf") - - f = self.addBiases(Wx, Uh, self.numUnits, name = "f") - - Wx = self.mulWeights(inputs, inputSize, self.numUnits, name = "Wxo") - Uh = self.mulWeights(h, self.numUnits, self.numUnits, name = "Uho") - - o = self.addBiases(Wx, Uh, self.numUnits, name = "o") - # i, j, f, o = tf.split(value = concat, num_or_size_splits = 4, axis = 1) - - newC = (c * tf.nn.sigmoid(f + self.forgetBias) + tf.nn.sigmoid(i) * - self.activation(j)) - newH = self.activation(newC) * tf.nn.sigmoid(o) - - newState = tf.nn.rnn_cell.LSTMStateTuple(newC, newH) - return newH, newState - - def zero_state(self, batchSize, dtype = tf.float32): - return tf.nn.rnn_cell.LSTMStateTuple(tf.zeros((batchSize, self.numUnits), dtype = dtype), - tf.zeros((batchSize, self.numUnits), dtype = dtype)) - \ No newline at end of file diff --git a/spaces/Caoyunkang/Segment-Any-Anomaly/SAA/__init__.py b/spaces/Caoyunkang/Segment-Any-Anomaly/SAA/__init__.py deleted file mode 100644 index 3b1eca16ce7e16330d6e4f415f63005d74206d88..0000000000000000000000000000000000000000 --- a/spaces/Caoyunkang/Segment-Any-Anomaly/SAA/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .model import Model -from .hybrid_prompts import * \ No newline at end of file diff --git a/spaces/Chatop/Lab10/app.py b/spaces/Chatop/Lab10/app.py deleted file mode 100644 index a5bb63c3ca58cb05b98f49e40d35175d12881a13..0000000000000000000000000000000000000000 --- a/spaces/Chatop/Lab10/app.py +++ /dev/null @@ -1,34 +0,0 @@ -import streamlit as st -from transformers.pipelines import pipeline -#from transformers.modeling_auto import AutoModelForQuestionAnswering -#from transformers.tokenization_auto import AutoTokenizer - -# b) Load model & tokenizer -#model = AutoModelForQuestionAnswering.from_pretrained(model_name) -#tokenizer = AutoTokenizer.from_pretrained(model_name) - -#classifier = pipeline("question-answering", model="deepset/roberta-base-squad2") - -model_name = "deepset/xlm-roberta-base-squad2" -nlp = pipeline('question-answering', model=model_name, tokenizer=model_name) -#QA_input = { -# 'question': 'Why is model conversion important?', -# 'context': 'The option to convert models between FARM and transformers gives freedom to the user and let people easily switch between frameworks.' -#} -#res = nlp(QA_input) - -def main(): - st.title("Question & Answering") - - with st.form("text_field"): - sentence_1= st.text_area('Enter question:') - sentence_2= st.text_area('Enter context:') - QA_input = {'question':sentence_1, 'context':sentence_2} - #clicked==True only when the button is clicked - clicked = st.form_submit_button("Submit") - if clicked: - results = nlp(QA_input) - st.json(results) - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/spaces/Chrysoula/voice_to_text_swedish/README.md b/spaces/Chrysoula/voice_to_text_swedish/README.md deleted file mode 100644 index 43ecd1b0761839e909b6eb45c229509da2378a5a..0000000000000000000000000000000000000000 --- a/spaces/Chrysoula/voice_to_text_swedish/README.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: Voice To Text Swedish -emoji: 🌖 -colorFrom: pink -colorTo: blue -sdk: gradio -sdk_version: 3.12.0 -app_file: app.py -pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/CorvaeOboro/gen_ability_icon/torch_utils/ops/bias_act.py b/spaces/CorvaeOboro/gen_ability_icon/torch_utils/ops/bias_act.py deleted file mode 100644 index 4bcb409a89ccf6c6f6ecfca5962683df2d280b1f..0000000000000000000000000000000000000000 --- a/spaces/CorvaeOboro/gen_ability_icon/torch_utils/ops/bias_act.py +++ /dev/null @@ -1,212 +0,0 @@ -# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved. -# -# NVIDIA CORPORATION and its licensors retain all intellectual property -# and proprietary rights in and to this software, related documentation -# and any modifications thereto. Any use, reproduction, disclosure or -# distribution of this software and related documentation without an express -# license agreement from NVIDIA CORPORATION is strictly prohibited. - -"""Custom PyTorch ops for efficient bias and activation.""" - -import os -import warnings -import numpy as np -import torch -import dnnlib -import traceback - -from .. import custom_ops -from .. import misc - -#---------------------------------------------------------------------------- - -activation_funcs = { - 'linear': dnnlib.EasyDict(func=lambda x, **_: x, def_alpha=0, def_gain=1, cuda_idx=1, ref='', has_2nd_grad=False), - 'relu': dnnlib.EasyDict(func=lambda x, **_: torch.nn.functional.relu(x), def_alpha=0, def_gain=np.sqrt(2), cuda_idx=2, ref='y', has_2nd_grad=False), - 'lrelu': dnnlib.EasyDict(func=lambda x, alpha, **_: torch.nn.functional.leaky_relu(x, alpha), def_alpha=0.2, def_gain=np.sqrt(2), cuda_idx=3, ref='y', has_2nd_grad=False), - 'tanh': dnnlib.EasyDict(func=lambda x, **_: torch.tanh(x), def_alpha=0, def_gain=1, cuda_idx=4, ref='y', has_2nd_grad=True), - 'sigmoid': dnnlib.EasyDict(func=lambda x, **_: torch.sigmoid(x), def_alpha=0, def_gain=1, cuda_idx=5, ref='y', has_2nd_grad=True), - 'elu': dnnlib.EasyDict(func=lambda x, **_: torch.nn.functional.elu(x), def_alpha=0, def_gain=1, cuda_idx=6, ref='y', has_2nd_grad=True), - 'selu': dnnlib.EasyDict(func=lambda x, **_: torch.nn.functional.selu(x), def_alpha=0, def_gain=1, cuda_idx=7, ref='y', has_2nd_grad=True), - 'softplus': dnnlib.EasyDict(func=lambda x, **_: torch.nn.functional.softplus(x), def_alpha=0, def_gain=1, cuda_idx=8, ref='y', has_2nd_grad=True), - 'swish': dnnlib.EasyDict(func=lambda x, **_: torch.sigmoid(x) * x, def_alpha=0, def_gain=np.sqrt(2), cuda_idx=9, ref='x', has_2nd_grad=True), -} - -#---------------------------------------------------------------------------- - -_inited = False -_plugin = None -_null_tensor = torch.empty([0]) - -def _init(): - global _inited, _plugin - if not _inited: - _inited = True - sources = ['bias_act.cpp', 'bias_act.cu'] - sources = [os.path.join(os.path.dirname(__file__), s) for s in sources] - try: - _plugin = custom_ops.get_plugin('bias_act_plugin', sources=sources, extra_cuda_cflags=['--use_fast_math']) - except: - warnings.warn('Failed to build CUDA kernels for bias_act. Falling back to slow reference implementation. Details:\n\n' + traceback.format_exc()) - return _plugin is not None - -#---------------------------------------------------------------------------- - -def bias_act(x, b=None, dim=1, act='linear', alpha=None, gain=None, clamp=None, impl='cuda'): - r"""Fused bias and activation function. - - Adds bias `b` to activation tensor `x`, evaluates activation function `act`, - and scales the result by `gain`. Each of the steps is optional. In most cases, - the fused op is considerably more efficient than performing the same calculation - using standard PyTorch ops. It supports first and second order gradients, - but not third order gradients. - - Args: - x: Input activation tensor. Can be of any shape. - b: Bias vector, or `None` to disable. Must be a 1D tensor of the same type - as `x`. The shape must be known, and it must match the dimension of `x` - corresponding to `dim`. - dim: The dimension in `x` corresponding to the elements of `b`. - The value of `dim` is ignored if `b` is not specified. - act: Name of the activation function to evaluate, or `"linear"` to disable. - Can be e.g. `"relu"`, `"lrelu"`, `"tanh"`, `"sigmoid"`, `"swish"`, etc. - See `activation_funcs` for a full list. `None` is not allowed. - alpha: Shape parameter for the activation function, or `None` to use the default. - gain: Scaling factor for the output tensor, or `None` to use default. - See `activation_funcs` for the default scaling of each activation function. - If unsure, consider specifying 1. - clamp: Clamp the output values to `[-clamp, +clamp]`, or `None` to disable - the clamping (default). - impl: Name of the implementation to use. Can be `"ref"` or `"cuda"` (default). - - Returns: - Tensor of the same shape and datatype as `x`. - """ - assert isinstance(x, torch.Tensor) - assert impl in ['ref', 'cuda'] - if impl == 'cuda' and x.device.type == 'cuda' and _init(): - return _bias_act_cuda(dim=dim, act=act, alpha=alpha, gain=gain, clamp=clamp).apply(x, b) - return _bias_act_ref(x=x, b=b, dim=dim, act=act, alpha=alpha, gain=gain, clamp=clamp) - -#---------------------------------------------------------------------------- - -@misc.profiled_function -def _bias_act_ref(x, b=None, dim=1, act='linear', alpha=None, gain=None, clamp=None): - """Slow reference implementation of `bias_act()` using standard TensorFlow ops. - """ - assert isinstance(x, torch.Tensor) - assert clamp is None or clamp >= 0 - spec = activation_funcs[act] - alpha = float(alpha if alpha is not None else spec.def_alpha) - gain = float(gain if gain is not None else spec.def_gain) - clamp = float(clamp if clamp is not None else -1) - - # Add bias. - if b is not None: - assert isinstance(b, torch.Tensor) and b.ndim == 1 - assert 0 <= dim < x.ndim - assert b.shape[0] == x.shape[dim] - x = x + b.reshape([-1 if i == dim else 1 for i in range(x.ndim)]) - - # Evaluate activation function. - alpha = float(alpha) - x = spec.func(x, alpha=alpha) - - # Scale by gain. - gain = float(gain) - if gain != 1: - x = x * gain - - # Clamp. - if clamp >= 0: - x = x.clamp(-clamp, clamp) # pylint: disable=invalid-unary-operand-type - return x - -#---------------------------------------------------------------------------- - -_bias_act_cuda_cache = dict() - -def _bias_act_cuda(dim=1, act='linear', alpha=None, gain=None, clamp=None): - """Fast CUDA implementation of `bias_act()` using custom ops. - """ - # Parse arguments. - assert clamp is None or clamp >= 0 - spec = activation_funcs[act] - alpha = float(alpha if alpha is not None else spec.def_alpha) - gain = float(gain if gain is not None else spec.def_gain) - clamp = float(clamp if clamp is not None else -1) - - # Lookup from cache. - key = (dim, act, alpha, gain, clamp) - if key in _bias_act_cuda_cache: - return _bias_act_cuda_cache[key] - - # Forward op. - class BiasActCuda(torch.autograd.Function): - @staticmethod - def forward(ctx, x, b): # pylint: disable=arguments-differ - ctx.memory_format = torch.channels_last if x.ndim > 2 and x.stride()[1] == 1 else torch.contiguous_format - x = x.contiguous(memory_format=ctx.memory_format) - b = b.contiguous() if b is not None else _null_tensor - y = x - if act != 'linear' or gain != 1 or clamp >= 0 or b is not _null_tensor: - y = _plugin.bias_act(x, b, _null_tensor, _null_tensor, _null_tensor, 0, dim, spec.cuda_idx, alpha, gain, clamp) - ctx.save_for_backward( - x if 'x' in spec.ref or spec.has_2nd_grad else _null_tensor, - b if 'x' in spec.ref or spec.has_2nd_grad else _null_tensor, - y if 'y' in spec.ref else _null_tensor) - return y - - @staticmethod - def backward(ctx, dy): # pylint: disable=arguments-differ - dy = dy.contiguous(memory_format=ctx.memory_format) - x, b, y = ctx.saved_tensors - dx = None - db = None - - if ctx.needs_input_grad[0] or ctx.needs_input_grad[1]: - dx = dy - if act != 'linear' or gain != 1 or clamp >= 0: - dx = BiasActCudaGrad.apply(dy, x, b, y) - - if ctx.needs_input_grad[1]: - db = dx.sum([i for i in range(dx.ndim) if i != dim]) - - return dx, db - - # Backward op. - class BiasActCudaGrad(torch.autograd.Function): - @staticmethod - def forward(ctx, dy, x, b, y): # pylint: disable=arguments-differ - ctx.memory_format = torch.channels_last if dy.ndim > 2 and dy.stride()[1] == 1 else torch.contiguous_format - dx = _plugin.bias_act(dy, b, x, y, _null_tensor, 1, dim, spec.cuda_idx, alpha, gain, clamp) - ctx.save_for_backward( - dy if spec.has_2nd_grad else _null_tensor, - x, b, y) - return dx - - @staticmethod - def backward(ctx, d_dx): # pylint: disable=arguments-differ - d_dx = d_dx.contiguous(memory_format=ctx.memory_format) - dy, x, b, y = ctx.saved_tensors - d_dy = None - d_x = None - d_b = None - d_y = None - - if ctx.needs_input_grad[0]: - d_dy = BiasActCudaGrad.apply(d_dx, x, b, y) - - if spec.has_2nd_grad and (ctx.needs_input_grad[1] or ctx.needs_input_grad[2]): - d_x = _plugin.bias_act(d_dx, b, x, y, dy, 2, dim, spec.cuda_idx, alpha, gain, clamp) - - if spec.has_2nd_grad and ctx.needs_input_grad[2]: - d_b = d_x.sum([i for i in range(d_x.ndim) if i != dim]) - - return d_dy, d_x, d_b, d_y - - # Add to cache. - _bias_act_cuda_cache[key] = BiasActCuda - return BiasActCuda - -#---------------------------------------------------------------------------- diff --git a/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/modeling/rpn/retinanet/inference.py b/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/modeling/rpn/retinanet/inference.py deleted file mode 100644 index 09c17adfc2565871632cffecd51738a2cbd9acb2..0000000000000000000000000000000000000000 --- a/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/modeling/rpn/retinanet/inference.py +++ /dev/null @@ -1,194 +0,0 @@ -import torch - -from ..inference import RPNPostProcessor -from ..utils import permute_and_flatten - -from maskrcnn_benchmark.modeling.box_coder import BoxCoder -from maskrcnn_benchmark.modeling.utils import cat -from maskrcnn_benchmark.structures.bounding_box import BoxList -from maskrcnn_benchmark.structures.boxlist_ops import cat_boxlist -from maskrcnn_benchmark.structures.boxlist_ops import boxlist_nms -from maskrcnn_benchmark.structures.boxlist_ops import remove_small_boxes - - -class RetinaNetPostProcessor(RPNPostProcessor): - """ - Performs post-processing on the outputs of the RetinaNet boxes. - This is only used in the testing. - """ - def __init__( - self, - pre_nms_thresh, - pre_nms_top_n, - nms_thresh, - fpn_post_nms_top_n, - min_size, - num_classes, - box_coder=None, - ): - """ - Arguments: - pre_nms_thresh (float) - pre_nms_top_n (int) - nms_thresh (float) - fpn_post_nms_top_n (int) - min_size (int) - num_classes (int) - box_coder (BoxCoder) - """ - super(RetinaNetPostProcessor, self).__init__( - pre_nms_thresh, 0, nms_thresh, min_size - ) - self.pre_nms_thresh = pre_nms_thresh - self.pre_nms_top_n = pre_nms_top_n - self.nms_thresh = nms_thresh - self.fpn_post_nms_top_n = fpn_post_nms_top_n - self.min_size = min_size - self.num_classes = num_classes - - if box_coder is None: - box_coder = BoxCoder(weights=(10., 10., 5., 5.)) - self.box_coder = box_coder - - def add_gt_proposals(self, proposals, targets): - """ - This function is not used in RetinaNet - """ - pass - - def forward_for_single_feature_map( - self, anchors, box_cls, box_regression): - """ - Arguments: - anchors: list[BoxList] - box_cls: tensor of size N, A * C, H, W - box_regression: tensor of size N, A * 4, H, W - """ - device = box_cls.device - N, _, H, W = box_cls.shape - A = box_regression.size(1) // 4 - C = box_cls.size(1) // A - - # put in the same format as anchors - box_cls = permute_and_flatten(box_cls, N, A, C, H, W) - box_cls = box_cls.sigmoid() - - box_regression = permute_and_flatten(box_regression, N, A, 4, H, W) - box_regression = box_regression.reshape(N, -1, 4) - - num_anchors = A * H * W - - candidate_inds = box_cls > self.pre_nms_thresh - - pre_nms_top_n = candidate_inds.view(N, -1).sum(1) - pre_nms_top_n = pre_nms_top_n.clamp(max=self.pre_nms_top_n) - - results = [] - for per_box_cls, per_box_regression, per_pre_nms_top_n, \ - per_candidate_inds, per_anchors in zip( - box_cls, - box_regression, - pre_nms_top_n, - candidate_inds, - anchors): - - # Sort and select TopN - # TODO most of this can be made out of the loop for - # all images. - # TODO:Yang: Not easy to do. Because the numbers of detections are - # different in each image. Therefore, this part needs to be done - # per image. - per_box_cls = per_box_cls[per_candidate_inds] - - per_box_cls, top_k_indices = \ - per_box_cls.topk(per_pre_nms_top_n, sorted=False) - - per_candidate_nonzeros = \ - per_candidate_inds.nonzero()[top_k_indices, :] - - per_box_loc = per_candidate_nonzeros[:, 0] - per_class = per_candidate_nonzeros[:, 1] - per_class += 1 - - detections = self.box_coder.decode( - per_box_regression[per_box_loc, :].view(-1, 4), - per_anchors.bbox[per_box_loc, :].view(-1, 4) - ) - - boxlist = BoxList(detections, per_anchors.size, mode="xyxy") - boxlist.add_field("labels", per_class) - boxlist.add_field("scores", per_box_cls) - boxlist = boxlist.clip_to_image(remove_empty=False) - boxlist = remove_small_boxes(boxlist, self.min_size) - results.append(boxlist) - - return results - - # TODO very similar to filter_results from PostProcessor - # but filter_results is per image - # TODO Yang: solve this issue in the future. No good solution - # right now. - def select_over_all_levels(self, boxlists): - num_images = len(boxlists) - results = [] - for i in range(num_images): - scores = boxlists[i].get_field("scores") - labels = boxlists[i].get_field("labels") - boxes = boxlists[i].bbox - boxlist = boxlists[i] - result = [] - # skip the background - for j in range(1, self.num_classes): - inds = (labels == j).nonzero().view(-1) - - scores_j = scores[inds] - boxes_j = boxes[inds, :].view(-1, 4) - boxlist_for_class = BoxList(boxes_j, boxlist.size, mode="xyxy") - boxlist_for_class.add_field("scores", scores_j) - boxlist_for_class = boxlist_nms( - boxlist_for_class, self.nms_thresh, - score_field="scores" - ) - num_labels = len(boxlist_for_class) - boxlist_for_class.add_field( - "labels", torch.full((num_labels,), j, - dtype=torch.int64, - device=scores.device) - ) - result.append(boxlist_for_class) - - result = cat_boxlist(result) - number_of_detections = len(result) - - # Limit to max_per_image detections **over all classes** - if number_of_detections > self.fpn_post_nms_top_n > 0: - cls_scores = result.get_field("scores") - image_thresh, _ = torch.kthvalue( - cls_scores.cpu(), - number_of_detections - self.fpn_post_nms_top_n + 1 - ) - keep = cls_scores >= image_thresh.item() - keep = torch.nonzero(keep).squeeze(1) - result = result[keep] - results.append(result) - return results - - -def make_retinanet_postprocessor(config, rpn_box_coder, is_train): - pre_nms_thresh = config.MODEL.RETINANET.INFERENCE_TH - pre_nms_top_n = config.MODEL.RETINANET.PRE_NMS_TOP_N - nms_thresh = config.MODEL.RETINANET.NMS_TH - fpn_post_nms_top_n = config.TEST.DETECTIONS_PER_IMG - min_size = 0 - - box_selector = RetinaNetPostProcessor( - pre_nms_thresh=pre_nms_thresh, - pre_nms_top_n=pre_nms_top_n, - nms_thresh=nms_thresh, - fpn_post_nms_top_n=fpn_post_nms_top_n, - min_size=min_size, - num_classes=config.MODEL.RETINANET.NUM_CLASSES, - box_coder=rpn_box_coder, - ) - - return box_selector diff --git a/spaces/DQChoi/gpt-demo/README.md b/spaces/DQChoi/gpt-demo/README.md deleted file mode 100644 index 242586be259fedf3d3133f4c3c6aff4c388b3018..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/README.md +++ /dev/null @@ -1,56 +0,0 @@ ---- -title: gpt-demo -app_file: app.py -sdk: gradio -sdk_version: 3.34.0 ---- -# Chatbot with OpenAI API and Gradio - -This is a simple chatbot application that uses the OpenAI API and Gradio library to generate responses based on user input. It allows you to have interactive conversations with the chatbot. - -## Prerequisites - -- Python 3.6 or higher -- Pip package manager - -## Installation - -``` -pip install -r requirements.txt -``` - -## Configuration - -1. Create an OpenAI account if you don't have one already: https://openai.com/ -2. Obtain an API key from OpenAI. -3. Create a file named `.env` in the project directory. -4. Open the `.env` file and add the following line, replacing `YOUR_API_KEY` with your actual OpenAI API key: - -``` - OPENAI_API_KEY=YOUR_API_KEY -``` - -## Usage - -1. Run the application: - -``` - python app.py -``` - -2. The application will start and display a URL in the terminal. -3. Open the provided URL in your web browser. -4. Enter a text input in the input area, and the chatbot will generate a response. -5. The response will be displayed in the output area of the interface. - -## Customization - -- To modify the behavior of the chatbot, you can edit the `predict()` function in `app.py`. This function handles the interaction with the OpenAI API and the generation of responses. - -## Contributing - -Contributions are welcome! If you find any issues or have suggestions for improvements, please create an issue or submit a pull request. - -## License - -This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details. diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/ImageTransform.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/ImageTransform.py deleted file mode 100644 index 7881f0d262b0db7ecaed224ee2268f3b69b836c9..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/PIL/ImageTransform.py +++ /dev/null @@ -1,102 +0,0 @@ -# -# The Python Imaging Library. -# $Id$ -# -# transform wrappers -# -# History: -# 2002-04-08 fl Created -# -# Copyright (c) 2002 by Secret Labs AB -# Copyright (c) 2002 by Fredrik Lundh -# -# See the README file for information on usage and redistribution. -# - -from . import Image - - -class Transform(Image.ImageTransformHandler): - def __init__(self, data): - self.data = data - - def getdata(self): - return self.method, self.data - - def transform(self, size, image, **options): - # can be overridden - method, data = self.getdata() - return image.transform(size, method, data, **options) - - -class AffineTransform(Transform): - """ - Define an affine image transform. - - This function takes a 6-tuple (a, b, c, d, e, f) which contain the first - two rows from an affine transform matrix. For each pixel (x, y) in the - output image, the new value is taken from a position (a x + b y + c, - d x + e y + f) in the input image, rounded to nearest pixel. - - This function can be used to scale, translate, rotate, and shear the - original image. - - See :py:meth:`~PIL.Image.Image.transform` - - :param matrix: A 6-tuple (a, b, c, d, e, f) containing the first two rows - from an affine transform matrix. - """ - - method = Image.Transform.AFFINE - - -class ExtentTransform(Transform): - """ - Define a transform to extract a subregion from an image. - - Maps a rectangle (defined by two corners) from the image to a rectangle of - the given size. The resulting image will contain data sampled from between - the corners, such that (x0, y0) in the input image will end up at (0,0) in - the output image, and (x1, y1) at size. - - This method can be used to crop, stretch, shrink, or mirror an arbitrary - rectangle in the current image. It is slightly slower than crop, but about - as fast as a corresponding resize operation. - - See :py:meth:`~PIL.Image.Image.transform` - - :param bbox: A 4-tuple (x0, y0, x1, y1) which specifies two points in the - input image's coordinate system. See :ref:`coordinate-system`. - """ - - method = Image.Transform.EXTENT - - -class QuadTransform(Transform): - """ - Define a quad image transform. - - Maps a quadrilateral (a region defined by four corners) from the image to a - rectangle of the given size. - - See :py:meth:`~PIL.Image.Image.transform` - - :param xy: An 8-tuple (x0, y0, x1, y1, x2, y2, x3, y3) which contain the - upper left, lower left, lower right, and upper right corner of the - source quadrilateral. - """ - - method = Image.Transform.QUAD - - -class MeshTransform(Transform): - """ - Define a mesh image transform. A mesh transform consists of one or more - individual quad transforms. - - See :py:meth:`~PIL.Image.Image.transform` - - :param data: A list of (bbox, quad) tuples. - """ - - method = Image.Transform.MESH diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/aiohttp/cookiejar.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/aiohttp/cookiejar.py deleted file mode 100644 index 6c88b47e3583430e05ea671af5b6da2a557073ec..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/aiohttp/cookiejar.py +++ /dev/null @@ -1,415 +0,0 @@ -import asyncio -import contextlib -import datetime -import os # noqa -import pathlib -import pickle -import re -from collections import defaultdict -from http.cookies import BaseCookie, Morsel, SimpleCookie -from typing import ( # noqa - DefaultDict, - Dict, - Iterable, - Iterator, - List, - Mapping, - Optional, - Set, - Tuple, - Union, - cast, -) - -from yarl import URL - -from .abc import AbstractCookieJar, ClearCookiePredicate -from .helpers import is_ip_address, next_whole_second -from .typedefs import LooseCookies, PathLike, StrOrURL - -__all__ = ("CookieJar", "DummyCookieJar") - - -CookieItem = Union[str, "Morsel[str]"] - - -class CookieJar(AbstractCookieJar): - """Implements cookie storage adhering to RFC 6265.""" - - DATE_TOKENS_RE = re.compile( - r"[\x09\x20-\x2F\x3B-\x40\x5B-\x60\x7B-\x7E]*" - r"(?P [\x00-\x08\x0A-\x1F\d:a-zA-Z\x7F-\xFF]+)" - ) - - DATE_HMS_TIME_RE = re.compile(r"(\d{1,2}):(\d{1,2}):(\d{1,2})") - - DATE_DAY_OF_MONTH_RE = re.compile(r"(\d{1,2})") - - DATE_MONTH_RE = re.compile( - "(jan)|(feb)|(mar)|(apr)|(may)|(jun)|(jul)|" "(aug)|(sep)|(oct)|(nov)|(dec)", - re.I, - ) - - DATE_YEAR_RE = re.compile(r"(\d{2,4})") - - MAX_TIME = datetime.datetime.max.replace(tzinfo=datetime.timezone.utc) - - MAX_32BIT_TIME = datetime.datetime.utcfromtimestamp(2**31 - 1) - - def __init__( - self, - *, - unsafe: bool = False, - quote_cookie: bool = True, - treat_as_secure_origin: Union[StrOrURL, List[StrOrURL], None] = None, - loop: Optional[asyncio.AbstractEventLoop] = None, - ) -> None: - super().__init__(loop=loop) - self._cookies: DefaultDict[Tuple[str, str], SimpleCookie[str]] = defaultdict( - SimpleCookie - ) - self._host_only_cookies: Set[Tuple[str, str]] = set() - self._unsafe = unsafe - self._quote_cookie = quote_cookie - if treat_as_secure_origin is None: - treat_as_secure_origin = [] - elif isinstance(treat_as_secure_origin, URL): - treat_as_secure_origin = [treat_as_secure_origin.origin()] - elif isinstance(treat_as_secure_origin, str): - treat_as_secure_origin = [URL(treat_as_secure_origin).origin()] - else: - treat_as_secure_origin = [ - URL(url).origin() if isinstance(url, str) else url.origin() - for url in treat_as_secure_origin - ] - self._treat_as_secure_origin = treat_as_secure_origin - self._next_expiration = next_whole_second() - self._expirations: Dict[Tuple[str, str, str], datetime.datetime] = {} - # #4515: datetime.max may not be representable on 32-bit platforms - self._max_time = self.MAX_TIME - try: - self._max_time.timestamp() - except OverflowError: - self._max_time = self.MAX_32BIT_TIME - - def save(self, file_path: PathLike) -> None: - file_path = pathlib.Path(file_path) - with file_path.open(mode="wb") as f: - pickle.dump(self._cookies, f, pickle.HIGHEST_PROTOCOL) - - def load(self, file_path: PathLike) -> None: - file_path = pathlib.Path(file_path) - with file_path.open(mode="rb") as f: - self._cookies = pickle.load(f) - - def clear(self, predicate: Optional[ClearCookiePredicate] = None) -> None: - if predicate is None: - self._next_expiration = next_whole_second() - self._cookies.clear() - self._host_only_cookies.clear() - self._expirations.clear() - return - - to_del = [] - now = datetime.datetime.now(datetime.timezone.utc) - for (domain, path), cookie in self._cookies.items(): - for name, morsel in cookie.items(): - key = (domain, path, name) - if ( - key in self._expirations and self._expirations[key] <= now - ) or predicate(morsel): - to_del.append(key) - - for domain, path, name in to_del: - self._host_only_cookies.discard((domain, name)) - key = (domain, path, name) - if key in self._expirations: - del self._expirations[(domain, path, name)] - self._cookies[(domain, path)].pop(name, None) - - next_expiration = min(self._expirations.values(), default=self._max_time) - try: - self._next_expiration = next_expiration.replace( - microsecond=0 - ) + datetime.timedelta(seconds=1) - except OverflowError: - self._next_expiration = self._max_time - - def clear_domain(self, domain: str) -> None: - self.clear(lambda x: self._is_domain_match(domain, x["domain"])) - - def __iter__(self) -> "Iterator[Morsel[str]]": - self._do_expiration() - for val in self._cookies.values(): - yield from val.values() - - def __len__(self) -> int: - return sum(1 for i in self) - - def _do_expiration(self) -> None: - self.clear(lambda x: False) - - def _expire_cookie( - self, when: datetime.datetime, domain: str, path: str, name: str - ) -> None: - self._next_expiration = min(self._next_expiration, when) - self._expirations[(domain, path, name)] = when - - def update_cookies(self, cookies: LooseCookies, response_url: URL = URL()) -> None: - """Update cookies.""" - hostname = response_url.raw_host - - if not self._unsafe and is_ip_address(hostname): - # Don't accept cookies from IPs - return - - if isinstance(cookies, Mapping): - cookies = cookies.items() - - for name, cookie in cookies: - if not isinstance(cookie, Morsel): - tmp: SimpleCookie[str] = SimpleCookie() - tmp[name] = cookie # type: ignore[assignment] - cookie = tmp[name] - - domain = cookie["domain"] - - # ignore domains with trailing dots - if domain.endswith("."): - domain = "" - del cookie["domain"] - - if not domain and hostname is not None: - # Set the cookie's domain to the response hostname - # and set its host-only-flag - self._host_only_cookies.add((hostname, name)) - domain = cookie["domain"] = hostname - - if domain.startswith("."): - # Remove leading dot - domain = domain[1:] - cookie["domain"] = domain - - if hostname and not self._is_domain_match(domain, hostname): - # Setting cookies for different domains is not allowed - continue - - path = cookie["path"] - if not path or not path.startswith("/"): - # Set the cookie's path to the response path - path = response_url.path - if not path.startswith("/"): - path = "/" - else: - # Cut everything from the last slash to the end - path = "/" + path[1 : path.rfind("/")] - cookie["path"] = path - - max_age = cookie["max-age"] - if max_age: - try: - delta_seconds = int(max_age) - try: - max_age_expiration = datetime.datetime.now( - datetime.timezone.utc - ) + datetime.timedelta(seconds=delta_seconds) - except OverflowError: - max_age_expiration = self._max_time - self._expire_cookie(max_age_expiration, domain, path, name) - except ValueError: - cookie["max-age"] = "" - - else: - expires = cookie["expires"] - if expires: - expire_time = self._parse_date(expires) - if expire_time: - self._expire_cookie(expire_time, domain, path, name) - else: - cookie["expires"] = "" - - self._cookies[(domain, path)][name] = cookie - - self._do_expiration() - - def filter_cookies( - self, request_url: URL = URL() - ) -> Union["BaseCookie[str]", "SimpleCookie[str]"]: - """Returns this jar's cookies filtered by their attributes.""" - self._do_expiration() - request_url = URL(request_url) - filtered: Union["SimpleCookie[str]", "BaseCookie[str]"] = ( - SimpleCookie() if self._quote_cookie else BaseCookie() - ) - hostname = request_url.raw_host or "" - request_origin = URL() - with contextlib.suppress(ValueError): - request_origin = request_url.origin() - - is_not_secure = ( - request_url.scheme not in ("https", "wss") - and request_origin not in self._treat_as_secure_origin - ) - - for cookie in self: - name = cookie.key - domain = cookie["domain"] - - # Send shared cookies - if not domain: - filtered[name] = cookie.value - continue - - if not self._unsafe and is_ip_address(hostname): - continue - - if (domain, name) in self._host_only_cookies: - if domain != hostname: - continue - elif not self._is_domain_match(domain, hostname): - continue - - if not self._is_path_match(request_url.path, cookie["path"]): - continue - - if is_not_secure and cookie["secure"]: - continue - - # It's critical we use the Morsel so the coded_value - # (based on cookie version) is preserved - mrsl_val = cast("Morsel[str]", cookie.get(cookie.key, Morsel())) - mrsl_val.set(cookie.key, cookie.value, cookie.coded_value) - filtered[name] = mrsl_val - - return filtered - - @staticmethod - def _is_domain_match(domain: str, hostname: str) -> bool: - """Implements domain matching adhering to RFC 6265.""" - if hostname == domain: - return True - - if not hostname.endswith(domain): - return False - - non_matching = hostname[: -len(domain)] - - if not non_matching.endswith("."): - return False - - return not is_ip_address(hostname) - - @staticmethod - def _is_path_match(req_path: str, cookie_path: str) -> bool: - """Implements path matching adhering to RFC 6265.""" - if not req_path.startswith("/"): - req_path = "/" - - if req_path == cookie_path: - return True - - if not req_path.startswith(cookie_path): - return False - - if cookie_path.endswith("/"): - return True - - non_matching = req_path[len(cookie_path) :] - - return non_matching.startswith("/") - - @classmethod - def _parse_date(cls, date_str: str) -> Optional[datetime.datetime]: - """Implements date string parsing adhering to RFC 6265.""" - if not date_str: - return None - - found_time = False - found_day = False - found_month = False - found_year = False - - hour = minute = second = 0 - day = 0 - month = 0 - year = 0 - - for token_match in cls.DATE_TOKENS_RE.finditer(date_str): - - token = token_match.group("token") - - if not found_time: - time_match = cls.DATE_HMS_TIME_RE.match(token) - if time_match: - found_time = True - hour, minute, second = (int(s) for s in time_match.groups()) - continue - - if not found_day: - day_match = cls.DATE_DAY_OF_MONTH_RE.match(token) - if day_match: - found_day = True - day = int(day_match.group()) - continue - - if not found_month: - month_match = cls.DATE_MONTH_RE.match(token) - if month_match: - found_month = True - assert month_match.lastindex is not None - month = month_match.lastindex - continue - - if not found_year: - year_match = cls.DATE_YEAR_RE.match(token) - if year_match: - found_year = True - year = int(year_match.group()) - - if 70 <= year <= 99: - year += 1900 - elif 0 <= year <= 69: - year += 2000 - - if False in (found_day, found_month, found_year, found_time): - return None - - if not 1 <= day <= 31: - return None - - if year < 1601 or hour > 23 or minute > 59 or second > 59: - return None - - return datetime.datetime( - year, month, day, hour, minute, second, tzinfo=datetime.timezone.utc - ) - - -class DummyCookieJar(AbstractCookieJar): - """Implements a dummy cookie storage. - - It can be used with the ClientSession when no cookie processing is needed. - - """ - - def __init__(self, *, loop: Optional[asyncio.AbstractEventLoop] = None) -> None: - super().__init__(loop=loop) - - def __iter__(self) -> "Iterator[Morsel[str]]": - while False: - yield None - - def __len__(self) -> int: - return 0 - - def clear(self, predicate: Optional[ClearCookiePredicate] = None) -> None: - pass - - def clear_domain(self, domain: str) -> None: - pass - - def update_cookies(self, cookies: LooseCookies, response_url: URL = URL()) -> None: - pass - - def filter_cookies(self, request_url: URL) -> "BaseCookie[str]": - return SimpleCookie() diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/concurrency.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/concurrency.py deleted file mode 100644 index 31b878d5df8a5d1c9687a8fdbf2f377e844d7f48..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/concurrency.py +++ /dev/null @@ -1,40 +0,0 @@ -from contextlib import AsyncExitStack as AsyncExitStack # noqa -from contextlib import asynccontextmanager as asynccontextmanager -from typing import AsyncGenerator, ContextManager, TypeVar - -import anyio -from anyio import CapacityLimiter -from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool # noqa -from starlette.concurrency import run_in_threadpool as run_in_threadpool # noqa -from starlette.concurrency import ( # noqa - run_until_first_complete as run_until_first_complete, -) - -_T = TypeVar("_T") - - -@asynccontextmanager -async def contextmanager_in_threadpool( - cm: ContextManager[_T], -) -> AsyncGenerator[_T, None]: - # blocking __exit__ from running waiting on a free thread - # can create race conditions/deadlocks if the context manager itself - # has it's own internal pool (e.g. a database connection pool) - # to avoid this we let __exit__ run without a capacity limit - # since we're creating a new limiter for each call, any non-zero limit - # works (1 is arbitrary) - exit_limiter = CapacityLimiter(1) - try: - yield await run_in_threadpool(cm.__enter__) - except Exception as e: - ok = bool( - await anyio.to_thread.run_sync( - cm.__exit__, type(e), e, None, limiter=exit_limiter - ) - ) - if not ok: - raise e - else: - await anyio.to_thread.run_sync( - cm.__exit__, None, None, None, limiter=exit_limiter - ) diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/IconButton-d42f3661.js b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/IconButton-d42f3661.js deleted file mode 100644 index 359a1c76aac0418e08c4546316daa6d0df40dbab..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/IconButton-d42f3661.js +++ /dev/null @@ -1,2 +0,0 @@ -import{S as I,e as k,s as w,N as m,O as p,k as q,K as f,U as b,p as g,M as _,o as v,Q as S,z,v as A,A as h,x as B,P as C,R as F,F as K}from"./index-1d65707a.js";import"./Button-f155035a.js";function d(l){let e,i;return{c(){e=m("span"),i=C(l[1]),f(e,"class","svelte-1030q2h")},m(a,s){g(a,e,s),_(e,i)},p(a,s){s&2&&F(i,a[1])},d(a){a&&h(e)}}}function M(l){let e,i,a,s,o,c,r,n=l[2]&&d(l);return s=new l[0]({}),{c(){e=m("button"),n&&n.c(),i=p(),a=m("div"),q(s.$$.fragment),f(a,"class","svelte-1030q2h"),f(e,"aria-label",l[1]),f(e,"title",l[1]),f(e,"class","svelte-1030q2h"),b(e,"pending",l[3])},m(t,u){g(t,e,u),n&&n.m(e,null),_(e,i),_(e,a),v(s,a,null),o=!0,c||(r=S(e,"click",l[4]),c=!0)},p(t,[u]){t[2]?n?n.p(t,u):(n=d(t),n.c(),n.m(e,i)):n&&(n.d(1),n=null),(!o||u&2)&&f(e,"aria-label",t[1]),(!o||u&2)&&f(e,"title",t[1]),(!o||u&8)&&b(e,"pending",t[3])},i(t){o||(z(s.$$.fragment,t),o=!0)},o(t){A(s.$$.fragment,t),o=!1},d(t){t&&h(e),n&&n.d(),B(s),c=!1,r()}}}function N(l,e,i){let{Icon:a}=e,{label:s=""}=e,{show_label:o=!1}=e,{pending:c=!1}=e;function r(n){K.call(this,l,n)}return l.$$set=n=>{"Icon"in n&&i(0,a=n.Icon),"label"in n&&i(1,s=n.label),"show_label"in n&&i(2,o=n.show_label),"pending"in n&&i(3,c=n.pending)},[a,s,o,c,r]}class Q extends I{constructor(e){super(),k(this,e,N,M,w,{Icon:0,label:1,show_label:2,pending:3})}}export{Q as I}; -//# sourceMappingURL=IconButton-d42f3661.js.map diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/h11/tests/test_io.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/h11/tests/test_io.py deleted file mode 100644 index 2b47c0eac92162646c8b60bd3de65bff1951c895..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/h11/tests/test_io.py +++ /dev/null @@ -1,572 +0,0 @@ -from typing import Any, Callable, Generator, List - -import pytest - -from .._events import ( - ConnectionClosed, - Data, - EndOfMessage, - Event, - InformationalResponse, - Request, - Response, -) -from .._headers import Headers, normalize_and_validate -from .._readers import ( - _obsolete_line_fold, - ChunkedReader, - ContentLengthReader, - Http10Reader, - READERS, -) -from .._receivebuffer import ReceiveBuffer -from .._state import ( - CLIENT, - CLOSED, - DONE, - IDLE, - MIGHT_SWITCH_PROTOCOL, - MUST_CLOSE, - SEND_BODY, - SEND_RESPONSE, - SERVER, - SWITCHED_PROTOCOL, -) -from .._util import LocalProtocolError -from .._writers import ( - ChunkedWriter, - ContentLengthWriter, - Http10Writer, - write_any_response, - write_headers, - write_request, - WRITERS, -) -from .helpers import normalize_data_events - -SIMPLE_CASES = [ - ( - (CLIENT, IDLE), - Request( - method="GET", - target="/a", - headers=[("Host", "foo"), ("Connection", "close")], - ), - b"GET /a HTTP/1.1\r\nHost: foo\r\nConnection: close\r\n\r\n", - ), - ( - (SERVER, SEND_RESPONSE), - Response(status_code=200, headers=[("Connection", "close")], reason=b"OK"), - b"HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n", - ), - ( - (SERVER, SEND_RESPONSE), - Response(status_code=200, headers=[], reason=b"OK"), # type: ignore[arg-type] - b"HTTP/1.1 200 OK\r\n\r\n", - ), - ( - (SERVER, SEND_RESPONSE), - InformationalResponse( - status_code=101, headers=[("Upgrade", "websocket")], reason=b"Upgrade" - ), - b"HTTP/1.1 101 Upgrade\r\nUpgrade: websocket\r\n\r\n", - ), - ( - (SERVER, SEND_RESPONSE), - InformationalResponse(status_code=101, headers=[], reason=b"Upgrade"), # type: ignore[arg-type] - b"HTTP/1.1 101 Upgrade\r\n\r\n", - ), -] - - -def dowrite(writer: Callable[..., None], obj: Any) -> bytes: - got_list: List[bytes] = [] - writer(obj, got_list.append) - return b"".join(got_list) - - -def tw(writer: Any, obj: Any, expected: Any) -> None: - got = dowrite(writer, obj) - assert got == expected - - -def makebuf(data: bytes) -> ReceiveBuffer: - buf = ReceiveBuffer() - buf += data - return buf - - -def tr(reader: Any, data: bytes, expected: Any) -> None: - def check(got: Any) -> None: - assert got == expected - # Headers should always be returned as bytes, not e.g. bytearray - # https://github.com/python-hyper/wsproto/pull/54#issuecomment-377709478 - for name, value in getattr(got, "headers", []): - assert type(name) is bytes - assert type(value) is bytes - - # Simple: consume whole thing - buf = makebuf(data) - check(reader(buf)) - assert not buf - - # Incrementally growing buffer - buf = ReceiveBuffer() - for i in range(len(data)): - assert reader(buf) is None - buf += data[i : i + 1] - check(reader(buf)) - - # Trailing data - buf = makebuf(data) - buf += b"trailing" - check(reader(buf)) - assert bytes(buf) == b"trailing" - - -def test_writers_simple() -> None: - for ((role, state), event, binary) in SIMPLE_CASES: - tw(WRITERS[role, state], event, binary) - - -def test_readers_simple() -> None: - for ((role, state), event, binary) in SIMPLE_CASES: - tr(READERS[role, state], binary, event) - - -def test_writers_unusual() -> None: - # Simple test of the write_headers utility routine - tw( - write_headers, - normalize_and_validate([("foo", "bar"), ("baz", "quux")]), - b"foo: bar\r\nbaz: quux\r\n\r\n", - ) - tw(write_headers, Headers([]), b"\r\n") - - # We understand HTTP/1.0, but we don't speak it - with pytest.raises(LocalProtocolError): - tw( - write_request, - Request( - method="GET", - target="/", - headers=[("Host", "foo"), ("Connection", "close")], - http_version="1.0", - ), - None, - ) - with pytest.raises(LocalProtocolError): - tw( - write_any_response, - Response( - status_code=200, headers=[("Connection", "close")], http_version="1.0" - ), - None, - ) - - -def test_readers_unusual() -> None: - # Reading HTTP/1.0 - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.0\r\nSome: header\r\n\r\n", - Request( - method="HEAD", - target="/foo", - headers=[("Some", "header")], - http_version="1.0", - ), - ) - - # check no-headers, since it's only legal with HTTP/1.0 - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.0\r\n\r\n", - Request(method="HEAD", target="/foo", headers=[], http_version="1.0"), # type: ignore[arg-type] - ) - - tr( - READERS[SERVER, SEND_RESPONSE], - b"HTTP/1.0 200 OK\r\nSome: header\r\n\r\n", - Response( - status_code=200, - headers=[("Some", "header")], - http_version="1.0", - reason=b"OK", - ), - ) - - # single-character header values (actually disallowed by the ABNF in RFC - # 7230 -- this is a bug in the standard that we originally copied...) - tr( - READERS[SERVER, SEND_RESPONSE], - b"HTTP/1.0 200 OK\r\n" b"Foo: a a a a a \r\n\r\n", - Response( - status_code=200, - headers=[("Foo", "a a a a a")], - http_version="1.0", - reason=b"OK", - ), - ) - - # Empty headers -- also legal - tr( - READERS[SERVER, SEND_RESPONSE], - b"HTTP/1.0 200 OK\r\n" b"Foo:\r\n\r\n", - Response( - status_code=200, headers=[("Foo", "")], http_version="1.0", reason=b"OK" - ), - ) - - tr( - READERS[SERVER, SEND_RESPONSE], - b"HTTP/1.0 200 OK\r\n" b"Foo: \t \t \r\n\r\n", - Response( - status_code=200, headers=[("Foo", "")], http_version="1.0", reason=b"OK" - ), - ) - - # Tolerate broken servers that leave off the response code - tr( - READERS[SERVER, SEND_RESPONSE], - b"HTTP/1.0 200\r\n" b"Foo: bar\r\n\r\n", - Response( - status_code=200, headers=[("Foo", "bar")], http_version="1.0", reason=b"" - ), - ) - - # Tolerate headers line endings (\r\n and \n) - # \n\r\b between headers and body - tr( - READERS[SERVER, SEND_RESPONSE], - b"HTTP/1.1 200 OK\r\nSomeHeader: val\n\r\n", - Response( - status_code=200, - headers=[("SomeHeader", "val")], - http_version="1.1", - reason="OK", - ), - ) - - # delimited only with \n - tr( - READERS[SERVER, SEND_RESPONSE], - b"HTTP/1.1 200 OK\nSomeHeader1: val1\nSomeHeader2: val2\n\n", - Response( - status_code=200, - headers=[("SomeHeader1", "val1"), ("SomeHeader2", "val2")], - http_version="1.1", - reason="OK", - ), - ) - - # mixed \r\n and \n - tr( - READERS[SERVER, SEND_RESPONSE], - b"HTTP/1.1 200 OK\r\nSomeHeader1: val1\nSomeHeader2: val2\n\r\n", - Response( - status_code=200, - headers=[("SomeHeader1", "val1"), ("SomeHeader2", "val2")], - http_version="1.1", - reason="OK", - ), - ) - - # obsolete line folding - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.1\r\n" - b"Host: example.com\r\n" - b"Some: multi-line\r\n" - b" header\r\n" - b"\tnonsense\r\n" - b" \t \t\tI guess\r\n" - b"Connection: close\r\n" - b"More-nonsense: in the\r\n" - b" last header \r\n\r\n", - Request( - method="HEAD", - target="/foo", - headers=[ - ("Host", "example.com"), - ("Some", "multi-line header nonsense I guess"), - ("Connection", "close"), - ("More-nonsense", "in the last header"), - ], - ), - ) - - with pytest.raises(LocalProtocolError): - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.1\r\n" b" folded: line\r\n\r\n", - None, - ) - - with pytest.raises(LocalProtocolError): - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.1\r\n" b"foo : line\r\n\r\n", - None, - ) - with pytest.raises(LocalProtocolError): - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.1\r\n" b"foo\t: line\r\n\r\n", - None, - ) - with pytest.raises(LocalProtocolError): - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.1\r\n" b"foo\t: line\r\n\r\n", - None, - ) - with pytest.raises(LocalProtocolError): - tr(READERS[CLIENT, IDLE], b"HEAD /foo HTTP/1.1\r\n" b": line\r\n\r\n", None) - - -def test__obsolete_line_fold_bytes() -> None: - # _obsolete_line_fold has a defensive cast to bytearray, which is - # necessary to protect against O(n^2) behavior in case anyone ever passes - # in regular bytestrings... but right now we never pass in regular - # bytestrings. so this test just exists to get some coverage on that - # defensive cast. - assert list(_obsolete_line_fold([b"aaa", b"bbb", b" ccc", b"ddd"])) == [ - b"aaa", - bytearray(b"bbb ccc"), - b"ddd", - ] - - -def _run_reader_iter( - reader: Any, buf: bytes, do_eof: bool -) -> Generator[Any, None, None]: - while True: - event = reader(buf) - if event is None: - break - yield event - # body readers have undefined behavior after returning EndOfMessage, - # because this changes the state so they don't get called again - if type(event) is EndOfMessage: - break - if do_eof: - assert not buf - yield reader.read_eof() - - -def _run_reader(*args: Any) -> List[Event]: - events = list(_run_reader_iter(*args)) - return normalize_data_events(events) - - -def t_body_reader(thunk: Any, data: bytes, expected: Any, do_eof: bool = False) -> None: - # Simple: consume whole thing - print("Test 1") - buf = makebuf(data) - assert _run_reader(thunk(), buf, do_eof) == expected - - # Incrementally growing buffer - print("Test 2") - reader = thunk() - buf = ReceiveBuffer() - events = [] - for i in range(len(data)): - events += _run_reader(reader, buf, False) - buf += data[i : i + 1] - events += _run_reader(reader, buf, do_eof) - assert normalize_data_events(events) == expected - - is_complete = any(type(event) is EndOfMessage for event in expected) - if is_complete and not do_eof: - buf = makebuf(data + b"trailing") - assert _run_reader(thunk(), buf, False) == expected - - -def test_ContentLengthReader() -> None: - t_body_reader(lambda: ContentLengthReader(0), b"", [EndOfMessage()]) - - t_body_reader( - lambda: ContentLengthReader(10), - b"0123456789", - [Data(data=b"0123456789"), EndOfMessage()], - ) - - -def test_Http10Reader() -> None: - t_body_reader(Http10Reader, b"", [EndOfMessage()], do_eof=True) - t_body_reader(Http10Reader, b"asdf", [Data(data=b"asdf")], do_eof=False) - t_body_reader( - Http10Reader, b"asdf", [Data(data=b"asdf"), EndOfMessage()], do_eof=True - ) - - -def test_ChunkedReader() -> None: - t_body_reader(ChunkedReader, b"0\r\n\r\n", [EndOfMessage()]) - - t_body_reader( - ChunkedReader, - b"0\r\nSome: header\r\n\r\n", - [EndOfMessage(headers=[("Some", "header")])], - ) - - t_body_reader( - ChunkedReader, - b"5\r\n01234\r\n" - + b"10\r\n0123456789abcdef\r\n" - + b"0\r\n" - + b"Some: header\r\n\r\n", - [ - Data(data=b"012340123456789abcdef"), - EndOfMessage(headers=[("Some", "header")]), - ], - ) - - t_body_reader( - ChunkedReader, - b"5\r\n01234\r\n" + b"10\r\n0123456789abcdef\r\n" + b"0\r\n\r\n", - [Data(data=b"012340123456789abcdef"), EndOfMessage()], - ) - - # handles upper and lowercase hex - t_body_reader( - ChunkedReader, - b"aA\r\n" + b"x" * 0xAA + b"\r\n" + b"0\r\n\r\n", - [Data(data=b"x" * 0xAA), EndOfMessage()], - ) - - # refuses arbitrarily long chunk integers - with pytest.raises(LocalProtocolError): - # Technically this is legal HTTP/1.1, but we refuse to process chunk - # sizes that don't fit into 20 characters of hex - t_body_reader(ChunkedReader, b"9" * 100 + b"\r\nxxx", [Data(data=b"xxx")]) - - # refuses garbage in the chunk count - with pytest.raises(LocalProtocolError): - t_body_reader(ChunkedReader, b"10\x00\r\nxxx", None) - - # handles (and discards) "chunk extensions" omg wtf - t_body_reader( - ChunkedReader, - b"5; hello=there\r\n" - + b"xxxxx" - + b"\r\n" - + b'0; random="junk"; some=more; canbe=lonnnnngg\r\n\r\n', - [Data(data=b"xxxxx"), EndOfMessage()], - ) - - t_body_reader( - ChunkedReader, - b"5 \r\n01234\r\n" + b"0\r\n\r\n", - [Data(data=b"01234"), EndOfMessage()], - ) - - -def test_ContentLengthWriter() -> None: - w = ContentLengthWriter(5) - assert dowrite(w, Data(data=b"123")) == b"123" - assert dowrite(w, Data(data=b"45")) == b"45" - assert dowrite(w, EndOfMessage()) == b"" - - w = ContentLengthWriter(5) - with pytest.raises(LocalProtocolError): - dowrite(w, Data(data=b"123456")) - - w = ContentLengthWriter(5) - dowrite(w, Data(data=b"123")) - with pytest.raises(LocalProtocolError): - dowrite(w, Data(data=b"456")) - - w = ContentLengthWriter(5) - dowrite(w, Data(data=b"123")) - with pytest.raises(LocalProtocolError): - dowrite(w, EndOfMessage()) - - w = ContentLengthWriter(5) - dowrite(w, Data(data=b"123")) == b"123" - dowrite(w, Data(data=b"45")) == b"45" - with pytest.raises(LocalProtocolError): - dowrite(w, EndOfMessage(headers=[("Etag", "asdf")])) - - -def test_ChunkedWriter() -> None: - w = ChunkedWriter() - assert dowrite(w, Data(data=b"aaa")) == b"3\r\naaa\r\n" - assert dowrite(w, Data(data=b"a" * 20)) == b"14\r\n" + b"a" * 20 + b"\r\n" - - assert dowrite(w, Data(data=b"")) == b"" - - assert dowrite(w, EndOfMessage()) == b"0\r\n\r\n" - - assert ( - dowrite(w, EndOfMessage(headers=[("Etag", "asdf"), ("a", "b")])) - == b"0\r\nEtag: asdf\r\na: b\r\n\r\n" - ) - - -def test_Http10Writer() -> None: - w = Http10Writer() - assert dowrite(w, Data(data=b"1234")) == b"1234" - assert dowrite(w, EndOfMessage()) == b"" - - with pytest.raises(LocalProtocolError): - dowrite(w, EndOfMessage(headers=[("Etag", "asdf")])) - - -def test_reject_garbage_after_request_line() -> None: - with pytest.raises(LocalProtocolError): - tr(READERS[SERVER, SEND_RESPONSE], b"HTTP/1.0 200 OK\x00xxxx\r\n\r\n", None) - - -def test_reject_garbage_after_response_line() -> None: - with pytest.raises(LocalProtocolError): - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.1 xxxxxx\r\n" b"Host: a\r\n\r\n", - None, - ) - - -def test_reject_garbage_in_header_line() -> None: - with pytest.raises(LocalProtocolError): - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.1\r\n" b"Host: foo\x00bar\r\n\r\n", - None, - ) - - -def test_reject_non_vchar_in_path() -> None: - for bad_char in b"\x00\x20\x7f\xee": - message = bytearray(b"HEAD /") - message.append(bad_char) - message.extend(b" HTTP/1.1\r\nHost: foobar\r\n\r\n") - with pytest.raises(LocalProtocolError): - tr(READERS[CLIENT, IDLE], message, None) - - -# https://github.com/python-hyper/h11/issues/57 -def test_allow_some_garbage_in_cookies() -> None: - tr( - READERS[CLIENT, IDLE], - b"HEAD /foo HTTP/1.1\r\n" - b"Host: foo\r\n" - b"Set-Cookie: ___utmvafIumyLc=kUd\x01UpAt; path=/; Max-Age=900\r\n" - b"\r\n", - Request( - method="HEAD", - target="/foo", - headers=[ - ("Host", "foo"), - ("Set-Cookie", "___utmvafIumyLc=kUd\x01UpAt; path=/; Max-Age=900"), - ], - ), - ) - - -def test_host_comes_first() -> None: - tw( - write_headers, - normalize_and_validate([("foo", "bar"), ("Host", "example.com")]), - b"Host: example.com\r\nfoo: bar\r\n\r\n", - ) diff --git a/spaces/DaleChen/AutoGPT/autogpt/config/__init__.py b/spaces/DaleChen/AutoGPT/autogpt/config/__init__.py deleted file mode 100644 index 726b6dcf3da95968b948c4d897e97a9cdd0928ff..0000000000000000000000000000000000000000 --- a/spaces/DaleChen/AutoGPT/autogpt/config/__init__.py +++ /dev/null @@ -1,14 +0,0 @@ -""" -This module contains the configuration classes for AutoGPT. -""" -from autogpt.config.ai_config import AIConfig -from autogpt.config.config import Config, check_openai_api_key -from autogpt.config.singleton import AbstractSingleton, Singleton - -__all__ = [ - "check_openai_api_key", - "AbstractSingleton", - "AIConfig", - "Config", - "Singleton", -] diff --git a/spaces/Datasculptor/StyleGAN-NADA/e4e/utils/model_utils.py b/spaces/Datasculptor/StyleGAN-NADA/e4e/utils/model_utils.py deleted file mode 100644 index e51e95578f72b3218d6d832e3b604193cb68c1d7..0000000000000000000000000000000000000000 --- a/spaces/Datasculptor/StyleGAN-NADA/e4e/utils/model_utils.py +++ /dev/null @@ -1,35 +0,0 @@ -import torch -import argparse -from models.psp import pSp -from models.encoders.psp_encoders import Encoder4Editing - - -def setup_model(checkpoint_path, device='cuda'): - ckpt = torch.load(checkpoint_path, map_location='cpu') - opts = ckpt['opts'] - - opts['checkpoint_path'] = checkpoint_path - opts['device'] = device - opts = argparse.Namespace(**opts) - - net = pSp(opts) - net.eval() - net = net.to(device) - return net, opts - - -def load_e4e_standalone(checkpoint_path, device='cuda'): - ckpt = torch.load(checkpoint_path, map_location='cpu') - opts = argparse.Namespace(**ckpt['opts']) - e4e = Encoder4Editing(50, 'ir_se', opts) - e4e_dict = {k.replace('encoder.', ''): v for k, v in ckpt['state_dict'].items() if k.startswith('encoder.')} - e4e.load_state_dict(e4e_dict) - e4e.eval() - e4e = e4e.to(device) - latent_avg = ckpt['latent_avg'].to(device) - - def add_latent_avg(model, inputs, outputs): - return outputs + latent_avg.repeat(outputs.shape[0], 1, 1) - - e4e.register_forward_hook(add_latent_avg) - return e4e diff --git a/spaces/Dorado607/ChuanhuChatGPT/modules/models/modeling_moss.py b/spaces/Dorado607/ChuanhuChatGPT/modules/models/modeling_moss.py deleted file mode 100644 index b7adea5bca857f7fdd6399dde7ce359f8f8cecfe..0000000000000000000000000000000000000000 --- a/spaces/Dorado607/ChuanhuChatGPT/modules/models/modeling_moss.py +++ /dev/null @@ -1,711 +0,0 @@ -""" PyTorch Moss model.""" - -from typing import Optional, Tuple, Union - -import torch -import torch.utils.checkpoint -from torch import nn -from torch.nn import CrossEntropyLoss - -from transformers.activations import ACT2FN -from transformers.modeling_utils import PreTrainedModel -from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast -from transformers.utils import ( - add_code_sample_docstrings, - add_start_docstrings, - add_start_docstrings_to_model_forward, - logging -) - -from .configuration_moss import MossConfig - - -logger = logging.get_logger(__name__) - -_CHECKPOINT_FOR_DOC = "fnlp/moss-moon-003-base" -_CONFIG_FOR_DOC = "MossConfig" - - -MOSS_PRETRAINED_MODEL_ARCHIVE_LIST = [ - "fnlp/moss-moon-003-base", - "fnlp/moss-moon-003-sft", - "fnlp/moss-moon-003-sft-plugin", -] - - -# Copied from transformers.models.gptj.modeling_gptj.create_sinusoidal_positions -def create_sinusoidal_positions(num_pos: int, dim: int) -> torch.Tensor: - inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2) / dim)) - sinusoid_inp = torch.einsum("i , j -> i j", torch.arange(num_pos, dtype=torch.float), inv_freq).float() - return torch.cat((torch.sin(sinusoid_inp), torch.cos(sinusoid_inp)), dim=1) - - -# Copied from transformers.models.gptj.modeling_gptj.rotate_every_two -def rotate_every_two(x: torch.Tensor) -> torch.Tensor: - x1 = x[:, :, :, ::2] - x2 = x[:, :, :, 1::2] - x = torch.stack((-x2, x1), dim=-1) - return x.flatten(-2) # in einsum notation: rearrange(x, '... d j -> ... (d j)') - - -# Copied from transformers.models.gptj.modeling_gptj.apply_rotary_pos_emb -def apply_rotary_pos_emb(tensor: torch.Tensor, sin: torch.Tensor, cos: torch.Tensor) -> torch.Tensor: - sin = torch.repeat_interleave(sin[:, :, None, :], 2, 3) - cos = torch.repeat_interleave(cos[:, :, None, :], 2, 3) - return (tensor * cos) + (rotate_every_two(tensor) * sin) - - -class MossAttention(nn.Module): - def __init__(self, config): - super().__init__() - - max_positions = config.max_position_embeddings - self.register_buffer( - "causal_mask", - torch.tril(torch.ones((max_positions, max_positions), dtype=torch.bool)).view( - 1, 1, max_positions, max_positions - ), - ) - - self.attn_dropout = nn.Dropout(config.attn_pdrop) - self.resid_dropout = nn.Dropout(config.resid_pdrop) - - self.embed_dim = config.hidden_size - self.num_attention_heads = config.num_attention_heads - self.head_dim = self.embed_dim // self.num_attention_heads - if self.head_dim * self.num_attention_heads != self.embed_dim: - raise ValueError( - f"embed_dim must be divisible by num_attention_heads (got `embed_dim`: {self.embed_dim} and" - f" `num_attention_heads`: {self.num_attention_heads})." - ) - self.scale_attn = torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32)).to(torch.get_default_dtype()) - self.qkv_proj = nn.Linear(self.embed_dim, self.embed_dim * 3, bias=False) - - self.out_proj = nn.Linear(self.embed_dim, self.embed_dim, bias=False) - self.rotary_dim = config.rotary_dim - pos_embd_dim = self.rotary_dim or self.embed_dim - self.embed_positions = create_sinusoidal_positions(max_positions, pos_embd_dim) - - def _split_heads(self, x, n_head, dim_head, mp_num): - reshaped = x.reshape(x.shape[:-1] + (n_head // mp_num, dim_head)) - reshaped = reshaped.reshape(x.shape[:-2] + (-1,) + reshaped.shape[-1:]) - return reshaped - - def _merge_heads(self, tensor, num_attention_heads, attn_head_size): - """ - Merges attn_head_size dim and num_attn_heads dim into n_ctx - """ - if len(tensor.shape) == 5: - tensor = tensor.permute(0, 1, 3, 2, 4).contiguous() - elif len(tensor.shape) == 4: - tensor = tensor.permute(0, 2, 1, 3).contiguous() - else: - raise ValueError(f"Input tensor rank should be one of [4, 5], but is: {len(tensor.shape)}") - new_shape = tensor.size()[:-2] + (num_attention_heads * attn_head_size,) - return tensor.view(new_shape) - - def _attn( - self, - query, - key, - value, - attention_mask=None, - head_mask=None, - ): - # compute causal mask from causal mask buffer - query_length, key_length = query.size(-2), key.size(-2) - causal_mask = self.causal_mask[:, :, key_length - query_length : key_length, :key_length] - - # Keep the attention weights computation in fp32 to avoid overflow issues - query = query.to(torch.float32) - key = key.to(torch.float32) - - attn_weights = torch.matmul(query, key.transpose(-1, -2)) - - attn_weights = attn_weights / self.scale_attn - mask_value = torch.finfo(attn_weights.dtype).min - # Need to be a tensor, otherwise we get error: `RuntimeError: expected scalar type float but found double`. - # Need to be on the same device, otherwise `RuntimeError: ..., x and y to be on the same device` - mask_value = torch.tensor(mask_value, dtype=attn_weights.dtype).to(attn_weights.device) - attn_weights = torch.where(causal_mask, attn_weights, mask_value) - - if attention_mask is not None: - # Apply the attention mask - attn_weights = attn_weights + attention_mask - - attn_weights = nn.Softmax(dim=-1)(attn_weights) - attn_weights = attn_weights.to(value.dtype) - attn_weights = self.attn_dropout(attn_weights) - - # Mask heads if we want to - if head_mask is not None: - attn_weights = attn_weights * head_mask - - attn_output = torch.matmul(attn_weights, value) - - return attn_output, attn_weights - - def forward( - self, - hidden_states: Optional[torch.FloatTensor], - layer_past: Optional[Tuple[torch.Tensor]] = None, - attention_mask: Optional[torch.FloatTensor] = None, - position_ids: Optional[torch.LongTensor] = None, - head_mask: Optional[torch.FloatTensor] = None, - use_cache: Optional[bool] = False, - output_attentions: Optional[bool] = False, - ) -> Union[ - Tuple[torch.Tensor, Tuple[torch.Tensor]], - Optional[Tuple[torch.Tensor, Tuple[torch.Tensor], Tuple[torch.Tensor, ...]]], - ]: - qkv = self.qkv_proj(hidden_states) - # TODO(enijkamp): factor out number of logical TPU-v4 cores or make forward pass agnostic - mp_num = 4 - qkv_split = qkv.reshape(qkv.shape[:-1] + (mp_num, -1)) - - local_dim = self.head_dim * self.num_attention_heads // mp_num - query, value, key = torch.split(qkv_split, local_dim, dim=-1) - query = self._split_heads(query, self.num_attention_heads, self.head_dim, mp_num=mp_num) - key = self._split_heads(key, self.num_attention_heads, self.head_dim, mp_num=mp_num) - - value = self._split_heads(value, self.num_attention_heads, self.head_dim, mp_num=mp_num) - value = value.permute(0, 2, 1, 3) - - embed_positions = self.embed_positions - if embed_positions.device != position_ids.device: - embed_positions = embed_positions.to(position_ids.device) - self.embed_positions = embed_positions - - sincos = embed_positions[position_ids] - sin, cos = torch.split(sincos, sincos.shape[-1] // 2, dim=-1) - - if self.rotary_dim is not None: - k_rot = key[:, :, :, : self.rotary_dim] - k_pass = key[:, :, :, self.rotary_dim :] - - q_rot = query[:, :, :, : self.rotary_dim] - q_pass = query[:, :, :, self.rotary_dim :] - - k_rot = apply_rotary_pos_emb(k_rot, sin, cos) - q_rot = apply_rotary_pos_emb(q_rot, sin, cos) - - key = torch.cat([k_rot, k_pass], dim=-1) - query = torch.cat([q_rot, q_pass], dim=-1) - else: - key = apply_rotary_pos_emb(key, sin, cos) - query = apply_rotary_pos_emb(query, sin, cos) - - key = key.permute(0, 2, 1, 3) - query = query.permute(0, 2, 1, 3) - - if layer_past is not None: - past_key = layer_past[0] - past_value = layer_past[1] - key = torch.cat((past_key, key), dim=-2) - value = torch.cat((past_value, value), dim=-2) - - if use_cache is True: - present = (key, value) - else: - present = None - - # compute self-attention: V x Softmax(QK^T) - attn_output, attn_weights = self._attn(query, key, value, attention_mask, head_mask) - - attn_output = self._merge_heads(attn_output, self.num_attention_heads, self.head_dim) - attn_output = self.out_proj(attn_output) - attn_output = self.resid_dropout(attn_output) - - outputs = (attn_output, present) - if output_attentions: - outputs += (attn_weights,) - - return outputs # a, present, (attentions) - - -# Copied from transformers.models.gptj.modeling_gptj.GPTJMLP with GPTJ->Moss -class MossMLP(nn.Module): - def __init__(self, intermediate_size, config): # in MLP: intermediate_size= 4 * embed_dim - super().__init__() - embed_dim = config.n_embd - - self.fc_in = nn.Linear(embed_dim, intermediate_size) - self.fc_out = nn.Linear(intermediate_size, embed_dim) - - self.act = ACT2FN[config.activation_function] - self.dropout = nn.Dropout(config.resid_pdrop) - - def forward(self, hidden_states: Optional[torch.FloatTensor]) -> torch.FloatTensor: - hidden_states = self.fc_in(hidden_states) - hidden_states = self.act(hidden_states) - hidden_states = self.fc_out(hidden_states) - hidden_states = self.dropout(hidden_states) - return hidden_states - - -# Copied from transformers.models.gptj.modeling_gptj.GPTJBlock with GPTJ->Moss -class MossBlock(nn.Module): - def __init__(self, config): - super().__init__() - inner_dim = config.n_inner if config.n_inner is not None else 4 * config.n_embd - self.ln_1 = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon) - self.attn = MossAttention(config) - self.mlp = MossMLP(inner_dim, config) - - def forward( - self, - hidden_states: Optional[torch.FloatTensor], - layer_past: Optional[Tuple[torch.Tensor]] = None, - attention_mask: Optional[torch.FloatTensor] = None, - position_ids: Optional[torch.LongTensor] = None, - head_mask: Optional[torch.FloatTensor] = None, - use_cache: Optional[bool] = False, - output_attentions: Optional[bool] = False, - ) -> Union[Tuple[torch.Tensor], Optional[Tuple[torch.Tensor, Tuple[torch.FloatTensor, ...]]]]: - residual = hidden_states - hidden_states = self.ln_1(hidden_states) - attn_outputs = self.attn( - hidden_states=hidden_states, - layer_past=layer_past, - attention_mask=attention_mask, - position_ids=position_ids, - head_mask=head_mask, - use_cache=use_cache, - output_attentions=output_attentions, - ) - attn_output = attn_outputs[0] # output_attn: a, present, (attentions) - outputs = attn_outputs[1:] - - feed_forward_hidden_states = self.mlp(hidden_states) - hidden_states = attn_output + feed_forward_hidden_states + residual - - if use_cache: - outputs = (hidden_states,) + outputs - else: - outputs = (hidden_states,) + outputs[1:] - - return outputs # hidden_states, present, (attentions) - - -class MossPreTrainedModel(PreTrainedModel): - """ - An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained - models. - """ - - config_class = MossConfig - base_model_prefix = "transformer" - supports_gradient_checkpointing = True - _no_split_modules = ["MossBlock"] - - def __init__(self, *inputs, **kwargs): - super().__init__(*inputs, **kwargs) - - def _init_weights(self, module): - """Initialize the weights.""" - if isinstance(module, (nn.Linear,)): - # Slightly different from Mesh Transformer JAX which uses truncated_normal for initialization - # cf https://github.com/pytorch/pytorch/pull/5617 - module.weight.data.normal_(mean=0.0, std=self.config.initializer_range) - if module.bias is not None: - module.bias.data.zero_() - elif isinstance(module, nn.Embedding): - module.weight.data.normal_(mean=0.0, std=self.config.initializer_range) - if module.padding_idx is not None: - module.weight.data[module.padding_idx].zero_() - elif isinstance(module, nn.LayerNorm): - module.bias.data.zero_() - module.weight.data.fill_(1.0) - - def _set_gradient_checkpointing(self, module, value=False): - if isinstance(module, MossModel): - module.gradient_checkpointing = value - - -MOSS_START_DOCSTRING = r""" - This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use - it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and - behavior. - - Parameters: - config ([`MossConfig`]): Model configuration class with all the parameters of the model. - Initializing with a config file does not load the weights associated with the model, only the - configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. -""" - -MOSS_INPUTS_DOCSTRING = r""" - Args: - input_ids (`torch.LongTensor` of shape `({0})`): - Indices of input sequence tokens in the vocabulary. - - Indices can be obtained using [`AutoProcenizer`]. See [`PreTrainedTokenizer.encode`] and - [`PreTrainedTokenizer.__call__`] for details. - - [What are input IDs?](../glossary#input-ids) - attention_mask (`torch.FloatTensor` of shape `({0})`, *optional*): - Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: - - - 1 for tokens that are **not masked**, - - 0 for tokens that are **masked**. - - [What are attention masks?](../glossary#attention-mask) - token_type_ids (`torch.LongTensor` of shape `({0})`, *optional*): - Segment token indices to indicate first and second portions of the inputs. Indices are selected in `[0, - 1]`: - - - 0 corresponds to a *sentence A* token, - - 1 corresponds to a *sentence B* token. - - [What are token type IDs?](../glossary#token-type-ids) - position_ids (`torch.LongTensor` of shape `({0})`, *optional*): - Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, - config.n_positions - 1]`. - - [What are position IDs?](../glossary#position-ids) - head_mask (`torch.FloatTensor` of shape `(num_attention_heads,)` or `(n_layer, num_attention_heads)`, *optional*): - Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`: - - - 1 indicates the head is **not masked**, - - 0 indicates the head is **masked**. - - inputs_embeds (`torch.FloatTensor` of shape `({0}, hidden_dim)`, *optional*): - Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This - is useful if you want more control over how to convert *input_ids* indices into associated vectors than the - model's internal embedding lookup matrix. - output_attentions (`bool`, *optional*): - Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned - tensors for more detail. - output_hidden_states (`bool`, *optional*): - Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for - more detail. - return_dict (`bool`, *optional*): - Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. -""" - - -@add_start_docstrings( - "The bare Moss Model transformer outputting raw hidden-states without any specific head on top.", - MOSS_START_DOCSTRING, -) -class MossModel(MossPreTrainedModel): - def __init__(self, config): - super().__init__(config) - - self.embed_dim = config.n_embd - self.vocab_size = config.vocab_size - self.wte = nn.Embedding(config.vocab_size, self.embed_dim) - self.drop = nn.Dropout(config.embd_pdrop) - self.h = nn.ModuleList([MossBlock(config) for _ in range(config.n_layer)]) - self.ln_f = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_epsilon) - self.rotary_dim = min(config.rotary_dim, config.n_ctx // config.num_attention_heads) - - self.gradient_checkpointing = False - - # Initialize weights and apply final processing - self.post_init() - - def get_input_embeddings(self): - return self.wte - - def set_input_embeddings(self, new_embeddings): - self.wte = new_embeddings - - @add_start_docstrings_to_model_forward(MOSS_INPUTS_DOCSTRING.format("batch_size, sequence_length")) - @add_code_sample_docstrings( - checkpoint=_CHECKPOINT_FOR_DOC, - output_type=BaseModelOutputWithPast, - config_class=_CONFIG_FOR_DOC, - ) - def forward( - self, - input_ids: Optional[torch.LongTensor] = None, - past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None, - attention_mask: Optional[torch.FloatTensor] = None, - token_type_ids: Optional[torch.LongTensor] = None, - position_ids: Optional[torch.LongTensor] = None, - head_mask: Optional[torch.FloatTensor] = None, - inputs_embeds: Optional[torch.FloatTensor] = None, - use_cache: Optional[bool] = None, - output_attentions: Optional[bool] = None, - output_hidden_states: Optional[bool] = None, - return_dict: Optional[bool] = None, - ) -> Union[Tuple, BaseModelOutputWithPast]: - output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions - output_hidden_states = ( - output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states - ) - use_cache = use_cache if use_cache is not None else self.config.use_cache - return_dict = return_dict if return_dict is not None else self.config.use_return_dict - - if input_ids is not None and inputs_embeds is not None: - raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time") - elif input_ids is not None: - input_shape = input_ids.size() - input_ids = input_ids.view(-1, input_shape[-1]) - batch_size = input_ids.shape[0] - elif inputs_embeds is not None: - input_shape = inputs_embeds.size()[:-1] - batch_size = inputs_embeds.shape[0] - else: - raise ValueError("You have to specify either input_ids or inputs_embeds") - - device = input_ids.device if input_ids is not None else inputs_embeds.device - - if token_type_ids is not None: - token_type_ids = token_type_ids.view(-1, input_shape[-1]) - - if position_ids is not None: - position_ids = position_ids.view(-1, input_shape[-1]).long() - - if past_key_values is None: - past_length = 0 - past_key_values = tuple([None] * len(self.h)) - else: - past_length = past_key_values[0][0].size(-2) - - if position_ids is None: - position_ids = torch.arange(past_length, input_shape[-1] + past_length, dtype=torch.long, device=device) - position_ids = position_ids.unsqueeze(0).view(-1, input_shape[-1]) - - # Attention mask. - if attention_mask is not None: - if batch_size <= 0: - raise ValueError("batch_size has to be defined and > 0") - attention_mask = attention_mask.view(batch_size, -1) - # We create a 3D attention mask from a 2D tensor mask. - # Sizes are [batch_size, 1, 1, to_seq_length] - # So we can broadcast to [batch_size, num_heads, from_seq_length, to_seq_length] - # this attention mask is more simple than the triangular masking of causal attention - # used in OpenAI GPT, we just need to prepare the broadcast dimension here. - attention_mask = attention_mask[:, None, None, :] - - # Since attention_mask is 1.0 for positions we want to attend and 0.0 for - # masked positions, this operation will create a tensor which is 0.0 for - # positions we want to attend and the dtype's smallest value for masked positions. - # Since we are adding it to the raw scores before the softmax, this is - # effectively the same as removing these entirely. - attention_mask = attention_mask.to(dtype=self.dtype) # fp16 compatibility - attention_mask = (1.0 - attention_mask) * torch.finfo(self.dtype).min - - # Prepare head mask if needed - # 1.0 in head_mask indicate we keep the head - # attention_probs has shape bsz x num_attention_heads x N x N - # head_mask has shape n_layer x batch x num_attention_heads x N x N - head_mask = self.get_head_mask(head_mask, self.config.n_layer) - - if inputs_embeds is None: - inputs_embeds = self.wte(input_ids) - - hidden_states = inputs_embeds - - if token_type_ids is not None: - token_type_embeds = self.wte(token_type_ids) - hidden_states = hidden_states + token_type_embeds - - hidden_states = self.drop(hidden_states) - - output_shape = input_shape + (hidden_states.size(-1),) - - if self.gradient_checkpointing and self.training: - if use_cache: - logger.warning_once( - "`use_cache=True` is incompatible with `config.gradient_checkpointing=True`. Setting " - "`use_cache=False`..." - ) - use_cache = False - - presents = () if use_cache else None - all_self_attentions = () if output_attentions else None - all_hidden_states = () if output_hidden_states else None - for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)): - if output_hidden_states: - all_hidden_states = all_hidden_states + (hidden_states,) - - if self.gradient_checkpointing and self.training: - - def create_custom_forward(module): - def custom_forward(*inputs): - # None for past_key_value - return module(*inputs, use_cache, output_attentions) - - return custom_forward - - outputs = torch.utils.checkpoint.checkpoint( - create_custom_forward(block), - hidden_states, - None, - attention_mask, - position_ids, - head_mask[i], - ) - else: - outputs = block( - hidden_states=hidden_states, - layer_past=layer_past, - attention_mask=attention_mask, - position_ids=position_ids, - head_mask=head_mask[i], - use_cache=use_cache, - output_attentions=output_attentions, - ) - - hidden_states = outputs[0] - if use_cache is True: - presents = presents + (outputs[1],) - - if output_attentions: - all_self_attentions = all_self_attentions + (outputs[2 if use_cache else 1],) - - hidden_states = self.ln_f(hidden_states) - - hidden_states = hidden_states.view(output_shape) - # Add last hidden state - if output_hidden_states: - all_hidden_states = all_hidden_states + (hidden_states,) - - if not return_dict: - return tuple(v for v in [hidden_states, presents, all_hidden_states, all_self_attentions] if v is not None) - - return BaseModelOutputWithPast( - last_hidden_state=hidden_states, - past_key_values=presents, - hidden_states=all_hidden_states, - attentions=all_self_attentions, - ) - - -@add_start_docstrings( - """ - The Moss Model transformer with a language modeling head on top. - """, - MOSS_START_DOCSTRING, -) -class MossForCausalLM(MossPreTrainedModel): - _keys_to_ignore_on_load_missing = [r"h\.\d+\.attn\.causal_mask"] - - def __init__(self, config): - super().__init__(config) - self.transformer = MossModel(config) - self.lm_head = nn.Linear(config.n_embd, config.vocab_size) - - # Initialize weights and apply final processing - self.post_init() - - def get_output_embeddings(self): - return self.lm_head - - def set_output_embeddings(self, new_embeddings): - self.lm_head = new_embeddings - - def prepare_inputs_for_generation(self, input_ids, past_key_values=None, **kwargs): - token_type_ids = kwargs.get("token_type_ids", None) - # only last token for inputs_ids if past is defined in kwargs - if past_key_values: - input_ids = input_ids[:, -1].unsqueeze(-1) - if token_type_ids is not None: - token_type_ids = token_type_ids[:, -1].unsqueeze(-1) - - attention_mask = kwargs.get("attention_mask", None) - position_ids = kwargs.get("position_ids", None) - - if attention_mask is not None and position_ids is None: - # create position_ids on the fly for batch generation - position_ids = attention_mask.long().cumsum(-1) - 1 - position_ids.masked_fill_(attention_mask == 0, 1) - if past_key_values: - position_ids = position_ids[:, -1].unsqueeze(-1) - - return { - "input_ids": input_ids, - "past_key_values": past_key_values, - "use_cache": kwargs.get("use_cache"), - "position_ids": position_ids, - "attention_mask": attention_mask, - "token_type_ids": token_type_ids, - } - - @add_start_docstrings_to_model_forward(MOSS_INPUTS_DOCSTRING.format("batch_size, sequence_length")) - @add_code_sample_docstrings( - checkpoint=_CHECKPOINT_FOR_DOC, - output_type=CausalLMOutputWithPast, - config_class=_CONFIG_FOR_DOC, - ) - def forward( - self, - input_ids: Optional[torch.LongTensor] = None, - past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None, - attention_mask: Optional[torch.FloatTensor] = None, - token_type_ids: Optional[torch.LongTensor] = None, - position_ids: Optional[torch.LongTensor] = None, - head_mask: Optional[torch.FloatTensor] = None, - inputs_embeds: Optional[torch.FloatTensor] = None, - labels: Optional[torch.LongTensor] = None, - use_cache: Optional[bool] = None, - output_attentions: Optional[bool] = None, - output_hidden_states: Optional[bool] = None, - return_dict: Optional[bool] = None, - ) -> Union[Tuple, CausalLMOutputWithPast]: - r""" - labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): - Labels for language modeling. Note that the labels **are shifted** inside the model, i.e. you can set - `labels = input_ids` Indices are selected in `[-100, 0, ..., config.vocab_size]` All labels set to `-100` - are ignored (masked), the loss is only computed for labels in `[0, ..., config.vocab_size]` - """ - return_dict = return_dict if return_dict is not None else self.config.use_return_dict - - transformer_outputs = self.transformer( - input_ids, - past_key_values=past_key_values, - attention_mask=attention_mask, - token_type_ids=token_type_ids, - position_ids=position_ids, - head_mask=head_mask, - inputs_embeds=inputs_embeds, - use_cache=use_cache, - output_attentions=output_attentions, - output_hidden_states=output_hidden_states, - return_dict=return_dict, - ) - hidden_states = transformer_outputs[0] - - # make sure sampling in fp16 works correctly and - # compute loss in fp32 to match with mesh-tf version - # https://github.com/EleutherAI/gpt-neo/blob/89ce74164da2fb16179106f54e2269b5da8db333/models/gpt2/gpt2.py#L179 - lm_logits = self.lm_head(hidden_states).to(torch.float32) - - loss = None - if labels is not None: - # Shift so that tokens < n predict n - shift_logits = lm_logits[..., :-1, :].contiguous() - shift_labels = labels[..., 1:].contiguous() - # Flatten the tokens - loss_fct = CrossEntropyLoss() - loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)) - - loss = loss.to(hidden_states.dtype) - - if not return_dict: - output = (lm_logits,) + transformer_outputs[1:] - return ((loss,) + output) if loss is not None else output - - return CausalLMOutputWithPast( - loss=loss, - logits=lm_logits, - past_key_values=transformer_outputs.past_key_values, - hidden_states=transformer_outputs.hidden_states, - attentions=transformer_outputs.attentions, - ) - - @staticmethod - def _reorder_cache( - past_key_values: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor - ) -> Tuple[Tuple[torch.Tensor]]: - """ - This function is used to re-order the `past_key_values` cache if [`~PretrainedModel.beam_search`] or - [`~PretrainedModel.beam_sample`] is called. This is required to match `past_key_values` with the correct - beam_idx at every generation step. - """ - return tuple( - tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past) - for layer_past in past_key_values - ) diff --git a/spaces/DragGan/DragGan/torch_utils/misc.py b/spaces/DragGan/DragGan/torch_utils/misc.py deleted file mode 100644 index 335397dd1662d8f5bfd44e17899a00549867f4bc..0000000000000000000000000000000000000000 --- a/spaces/DragGan/DragGan/torch_utils/misc.py +++ /dev/null @@ -1,266 +0,0 @@ -# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# NVIDIA CORPORATION and its licensors retain all intellectual property -# and proprietary rights in and to this software, related documentation -# and any modifications thereto. Any use, reproduction, disclosure or -# distribution of this software and related documentation without an express -# license agreement from NVIDIA CORPORATION is strictly prohibited. - -import re -import contextlib -import numpy as np -import torch -import warnings -import dnnlib - -#---------------------------------------------------------------------------- -# Cached construction of constant tensors. Avoids CPU=>GPU copy when the -# same constant is used multiple times. - -_constant_cache = dict() - -def constant(value, shape=None, dtype=None, device=None, memory_format=None): - value = np.asarray(value) - if shape is not None: - shape = tuple(shape) - if dtype is None: - dtype = torch.get_default_dtype() - if device is None: - device = torch.device('cpu') - if memory_format is None: - memory_format = torch.contiguous_format - - key = (value.shape, value.dtype, value.tobytes(), shape, dtype, device, memory_format) - tensor = _constant_cache.get(key, None) - if tensor is None: - tensor = torch.as_tensor(value.copy(), dtype=dtype, device=device) - if shape is not None: - tensor, _ = torch.broadcast_tensors(tensor, torch.empty(shape)) - tensor = tensor.contiguous(memory_format=memory_format) - _constant_cache[key] = tensor - return tensor - -#---------------------------------------------------------------------------- -# Replace NaN/Inf with specified numerical values. - -try: - nan_to_num = torch.nan_to_num # 1.8.0a0 -except AttributeError: - def nan_to_num(input, nan=0.0, posinf=None, neginf=None, *, out=None): # pylint: disable=redefined-builtin - assert isinstance(input, torch.Tensor) - if posinf is None: - posinf = torch.finfo(input.dtype).max - if neginf is None: - neginf = torch.finfo(input.dtype).min - assert nan == 0 - return torch.clamp(input.unsqueeze(0).nansum(0), min=neginf, max=posinf, out=out) - -#---------------------------------------------------------------------------- -# Symbolic assert. - -try: - symbolic_assert = torch._assert # 1.8.0a0 # pylint: disable=protected-access -except AttributeError: - symbolic_assert = torch.Assert # 1.7.0 - -#---------------------------------------------------------------------------- -# Context manager to temporarily suppress known warnings in torch.jit.trace(). -# Note: Cannot use catch_warnings because of https://bugs.python.org/issue29672 - -@contextlib.contextmanager -def suppress_tracer_warnings(): - flt = ('ignore', None, torch.jit.TracerWarning, None, 0) - warnings.filters.insert(0, flt) - yield - warnings.filters.remove(flt) - -#---------------------------------------------------------------------------- -# Assert that the shape of a tensor matches the given list of integers. -# None indicates that the size of a dimension is allowed to vary. -# Performs symbolic assertion when used in torch.jit.trace(). - -def assert_shape(tensor, ref_shape): - if tensor.ndim != len(ref_shape): - raise AssertionError(f'Wrong number of dimensions: got {tensor.ndim}, expected {len(ref_shape)}') - for idx, (size, ref_size) in enumerate(zip(tensor.shape, ref_shape)): - if ref_size is None: - pass - elif isinstance(ref_size, torch.Tensor): - with suppress_tracer_warnings(): # as_tensor results are registered as constants - symbolic_assert(torch.equal(torch.as_tensor(size), ref_size), f'Wrong size for dimension {idx}') - elif isinstance(size, torch.Tensor): - with suppress_tracer_warnings(): # as_tensor results are registered as constants - symbolic_assert(torch.equal(size, torch.as_tensor(ref_size)), f'Wrong size for dimension {idx}: expected {ref_size}') - elif size != ref_size: - raise AssertionError(f'Wrong size for dimension {idx}: got {size}, expected {ref_size}') - -#---------------------------------------------------------------------------- -# Function decorator that calls torch.autograd.profiler.record_function(). - -def profiled_function(fn): - def decorator(*args, **kwargs): - with torch.autograd.profiler.record_function(fn.__name__): - return fn(*args, **kwargs) - decorator.__name__ = fn.__name__ - return decorator - -#---------------------------------------------------------------------------- -# Sampler for torch.utils.data.DataLoader that loops over the dataset -# indefinitely, shuffling items as it goes. - -class InfiniteSampler(torch.utils.data.Sampler): - def __init__(self, dataset, rank=0, num_replicas=1, shuffle=True, seed=0, window_size=0.5): - assert len(dataset) > 0 - assert num_replicas > 0 - assert 0 <= rank < num_replicas - assert 0 <= window_size <= 1 - super().__init__(dataset) - self.dataset = dataset - self.rank = rank - self.num_replicas = num_replicas - self.shuffle = shuffle - self.seed = seed - self.window_size = window_size - - def __iter__(self): - order = np.arange(len(self.dataset)) - rnd = None - window = 0 - if self.shuffle: - rnd = np.random.RandomState(self.seed) - rnd.shuffle(order) - window = int(np.rint(order.size * self.window_size)) - - idx = 0 - while True: - i = idx % order.size - if idx % self.num_replicas == self.rank: - yield order[i] - if window >= 2: - j = (i - rnd.randint(window)) % order.size - order[i], order[j] = order[j], order[i] - idx += 1 - -#---------------------------------------------------------------------------- -# Utilities for operating with torch.nn.Module parameters and buffers. - -def params_and_buffers(module): - assert isinstance(module, torch.nn.Module) - return list(module.parameters()) + list(module.buffers()) - -def named_params_and_buffers(module): - assert isinstance(module, torch.nn.Module) - return list(module.named_parameters()) + list(module.named_buffers()) - -def copy_params_and_buffers(src_module, dst_module, require_all=False): - assert isinstance(src_module, torch.nn.Module) - assert isinstance(dst_module, torch.nn.Module) - src_tensors = dict(named_params_and_buffers(src_module)) - for name, tensor in named_params_and_buffers(dst_module): - assert (name in src_tensors) or (not require_all) - if name in src_tensors: - tensor.copy_(src_tensors[name].detach()).requires_grad_(tensor.requires_grad) - -#---------------------------------------------------------------------------- -# Context manager for easily enabling/disabling DistributedDataParallel -# synchronization. - -@contextlib.contextmanager -def ddp_sync(module, sync): - assert isinstance(module, torch.nn.Module) - if sync or not isinstance(module, torch.nn.parallel.DistributedDataParallel): - yield - else: - with module.no_sync(): - yield - -#---------------------------------------------------------------------------- -# Check DistributedDataParallel consistency across processes. - -def check_ddp_consistency(module, ignore_regex=None): - assert isinstance(module, torch.nn.Module) - for name, tensor in named_params_and_buffers(module): - fullname = type(module).__name__ + '.' + name - if ignore_regex is not None and re.fullmatch(ignore_regex, fullname): - continue - tensor = tensor.detach() - if tensor.is_floating_point(): - tensor = nan_to_num(tensor) - other = tensor.clone() - torch.distributed.broadcast(tensor=other, src=0) - assert (tensor == other).all(), fullname - -#---------------------------------------------------------------------------- -# Print summary table of module hierarchy. - -def print_module_summary(module, inputs, max_nesting=3, skip_redundant=True): - assert isinstance(module, torch.nn.Module) - assert not isinstance(module, torch.jit.ScriptModule) - assert isinstance(inputs, (tuple, list)) - - # Register hooks. - entries = [] - nesting = [0] - def pre_hook(_mod, _inputs): - nesting[0] += 1 - def post_hook(mod, _inputs, outputs): - nesting[0] -= 1 - if nesting[0] <= max_nesting: - outputs = list(outputs) if isinstance(outputs, (tuple, list)) else [outputs] - outputs = [t for t in outputs if isinstance(t, torch.Tensor)] - entries.append(dnnlib.EasyDict(mod=mod, outputs=outputs)) - hooks = [mod.register_forward_pre_hook(pre_hook) for mod in module.modules()] - hooks += [mod.register_forward_hook(post_hook) for mod in module.modules()] - - # Run module. - outputs = module(*inputs) - for hook in hooks: - hook.remove() - - # Identify unique outputs, parameters, and buffers. - tensors_seen = set() - for e in entries: - e.unique_params = [t for t in e.mod.parameters() if id(t) not in tensors_seen] - e.unique_buffers = [t for t in e.mod.buffers() if id(t) not in tensors_seen] - e.unique_outputs = [t for t in e.outputs if id(t) not in tensors_seen] - tensors_seen |= {id(t) for t in e.unique_params + e.unique_buffers + e.unique_outputs} - - # Filter out redundant entries. - if skip_redundant: - entries = [e for e in entries if len(e.unique_params) or len(e.unique_buffers) or len(e.unique_outputs)] - - # Construct table. - rows = [[type(module).__name__, 'Parameters', 'Buffers', 'Output shape', 'Datatype']] - rows += [['---'] * len(rows[0])] - param_total = 0 - buffer_total = 0 - submodule_names = {mod: name for name, mod in module.named_modules()} - for e in entries: - name = ' ' if e.mod is module else submodule_names[e.mod] - param_size = sum(t.numel() for t in e.unique_params) - buffer_size = sum(t.numel() for t in e.unique_buffers) - output_shapes = [str(list(t.shape)) for t in e.outputs] - output_dtypes = [str(t.dtype).split('.')[-1] for t in e.outputs] - rows += [[ - name + (':0' if len(e.outputs) >= 2 else ''), - str(param_size) if param_size else '-', - str(buffer_size) if buffer_size else '-', - (output_shapes + ['-'])[0], - (output_dtypes + ['-'])[0], - ]] - for idx in range(1, len(e.outputs)): - rows += [[name + f':{idx}', '-', '-', output_shapes[idx], output_dtypes[idx]]] - param_total += param_size - buffer_total += buffer_size - rows += [['---'] * len(rows[0])] - rows += [['Total', str(param_total), str(buffer_total), '-', '-']] - - # Print table. - widths = [max(len(cell) for cell in column) for column in zip(*rows)] - print() - for row in rows: - print(' '.join(cell + ' ' * (width - len(cell)) for cell, width in zip(row, widths))) - print() - return outputs - -#---------------------------------------------------------------------------- diff --git a/spaces/DragGan/DragGan/torch_utils/ops/__init__.py b/spaces/DragGan/DragGan/torch_utils/ops/__init__.py deleted file mode 100644 index 939e7c6c8f94c4ea1141885c3c3295fe083b06aa..0000000000000000000000000000000000000000 --- a/spaces/DragGan/DragGan/torch_utils/ops/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# NVIDIA CORPORATION and its licensors retain all intellectual property -# and proprietary rights in and to this software, related documentation -# and any modifications thereto. Any use, reproduction, disclosure or -# distribution of this software and related documentation without an express -# license agreement from NVIDIA CORPORATION is strictly prohibited. - -# empty diff --git a/spaces/DragGan/DragGan/torch_utils/ops/conv2d_resample.py b/spaces/DragGan/DragGan/torch_utils/ops/conv2d_resample.py deleted file mode 100644 index 5eb5877d7ffe4af74a2165f1d8d8c39dfac2476b..0000000000000000000000000000000000000000 --- a/spaces/DragGan/DragGan/torch_utils/ops/conv2d_resample.py +++ /dev/null @@ -1,143 +0,0 @@ -# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# NVIDIA CORPORATION and its licensors retain all intellectual property -# and proprietary rights in and to this software, related documentation -# and any modifications thereto. Any use, reproduction, disclosure or -# distribution of this software and related documentation without an express -# license agreement from NVIDIA CORPORATION is strictly prohibited. - -"""2D convolution with optional up/downsampling.""" - -import torch - -from .. import misc -from . import conv2d_gradfix -from . import upfirdn2d -from .upfirdn2d import _parse_padding -from .upfirdn2d import _get_filter_size - -#---------------------------------------------------------------------------- - -def _get_weight_shape(w): - with misc.suppress_tracer_warnings(): # this value will be treated as a constant - shape = [int(sz) for sz in w.shape] - misc.assert_shape(w, shape) - return shape - -#---------------------------------------------------------------------------- - -def _conv2d_wrapper(x, w, stride=1, padding=0, groups=1, transpose=False, flip_weight=True): - """Wrapper for the underlying `conv2d()` and `conv_transpose2d()` implementations. - """ - _out_channels, _in_channels_per_group, kh, kw = _get_weight_shape(w) - - # Flip weight if requested. - # Note: conv2d() actually performs correlation (flip_weight=True) not convolution (flip_weight=False). - if not flip_weight and (kw > 1 or kh > 1): - w = w.flip([2, 3]) - - # Execute using conv2d_gradfix. - op = conv2d_gradfix.conv_transpose2d if transpose else conv2d_gradfix.conv2d - return op(x, w, stride=stride, padding=padding, groups=groups) - -#---------------------------------------------------------------------------- - -@misc.profiled_function -def conv2d_resample(x, w, f=None, up=1, down=1, padding=0, groups=1, flip_weight=True, flip_filter=False): - r"""2D convolution with optional up/downsampling. - - Padding is performed only once at the beginning, not between the operations. - - Args: - x: Input tensor of shape - `[batch_size, in_channels, in_height, in_width]`. - w: Weight tensor of shape - `[out_channels, in_channels//groups, kernel_height, kernel_width]`. - f: Low-pass filter for up/downsampling. Must be prepared beforehand by - calling upfirdn2d.setup_filter(). None = identity (default). - up: Integer upsampling factor (default: 1). - down: Integer downsampling factor (default: 1). - padding: Padding with respect to the upsampled image. Can be a single number - or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]` - (default: 0). - groups: Split input channels into N groups (default: 1). - flip_weight: False = convolution, True = correlation (default: True). - flip_filter: False = convolution, True = correlation (default: False). - - Returns: - Tensor of the shape `[batch_size, num_channels, out_height, out_width]`. - """ - # Validate arguments. - assert isinstance(x, torch.Tensor) and (x.ndim == 4) - assert isinstance(w, torch.Tensor) and (w.ndim == 4) and (w.dtype == x.dtype) - assert f is None or (isinstance(f, torch.Tensor) and f.ndim in [1, 2] and f.dtype == torch.float32) - assert isinstance(up, int) and (up >= 1) - assert isinstance(down, int) and (down >= 1) - assert isinstance(groups, int) and (groups >= 1) - out_channels, in_channels_per_group, kh, kw = _get_weight_shape(w) - fw, fh = _get_filter_size(f) - px0, px1, py0, py1 = _parse_padding(padding) - - # Adjust padding to account for up/downsampling. - if up > 1: - px0 += (fw + up - 1) // 2 - px1 += (fw - up) // 2 - py0 += (fh + up - 1) // 2 - py1 += (fh - up) // 2 - if down > 1: - px0 += (fw - down + 1) // 2 - px1 += (fw - down) // 2 - py0 += (fh - down + 1) // 2 - py1 += (fh - down) // 2 - - # Fast path: 1x1 convolution with downsampling only => downsample first, then convolve. - if kw == 1 and kh == 1 and (down > 1 and up == 1): - x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, padding=[px0,px1,py0,py1], flip_filter=flip_filter) - x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight) - return x - - # Fast path: 1x1 convolution with upsampling only => convolve first, then upsample. - if kw == 1 and kh == 1 and (up > 1 and down == 1): - x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight) - x = upfirdn2d.upfirdn2d(x=x, f=f, up=up, padding=[px0,px1,py0,py1], gain=up**2, flip_filter=flip_filter) - return x - - # Fast path: downsampling only => use strided convolution. - if down > 1 and up == 1: - x = upfirdn2d.upfirdn2d(x=x, f=f, padding=[px0,px1,py0,py1], flip_filter=flip_filter) - x = _conv2d_wrapper(x=x, w=w, stride=down, groups=groups, flip_weight=flip_weight) - return x - - # Fast path: upsampling with optional downsampling => use transpose strided convolution. - if up > 1: - if groups == 1: - w = w.transpose(0, 1) - else: - w = w.reshape(groups, out_channels // groups, in_channels_per_group, kh, kw) - w = w.transpose(1, 2) - w = w.reshape(groups * in_channels_per_group, out_channels // groups, kh, kw) - px0 -= kw - 1 - px1 -= kw - up - py0 -= kh - 1 - py1 -= kh - up - pxt = max(min(-px0, -px1), 0) - pyt = max(min(-py0, -py1), 0) - x = _conv2d_wrapper(x=x, w=w, stride=up, padding=[pyt,pxt], groups=groups, transpose=True, flip_weight=(not flip_weight)) - x = upfirdn2d.upfirdn2d(x=x, f=f, padding=[px0+pxt,px1+pxt,py0+pyt,py1+pyt], gain=up**2, flip_filter=flip_filter) - if down > 1: - x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, flip_filter=flip_filter) - return x - - # Fast path: no up/downsampling, padding supported by the underlying implementation => use plain conv2d. - if up == 1 and down == 1: - if px0 == px1 and py0 == py1 and px0 >= 0 and py0 >= 0: - return _conv2d_wrapper(x=x, w=w, padding=[py0,px0], groups=groups, flip_weight=flip_weight) - - # Fallback: Generic reference implementation. - x = upfirdn2d.upfirdn2d(x=x, f=(f if up > 1 else None), up=up, padding=[px0,px1,py0,py1], gain=up**2, flip_filter=flip_filter) - x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight) - if down > 1: - x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, flip_filter=flip_filter) - return x - -#---------------------------------------------------------------------------- diff --git a/spaces/DrishtiSharma/ASR_using_Wav2Vec2/app.py b/spaces/DrishtiSharma/ASR_using_Wav2Vec2/app.py deleted file mode 100644 index b2d73e214bd1c96e550241194b85fcf069ac151a..0000000000000000000000000000000000000000 --- a/spaces/DrishtiSharma/ASR_using_Wav2Vec2/app.py +++ /dev/null @@ -1,67 +0,0 @@ -#References: 1. https://www.kdnuggets.com/2021/03/speech-text-wav2vec.html - #2. https://www.youtube.com/watch?v=4CoVcsxZphE - #3. https://www.analyticsvidhya.com/blog/2021/02/hugging-face-introduces-the-first-automatic-speech-recognition-model-wav2vec2/ - -#Importing all the necessary packages -import nltk -import librosa -import torch -import gradio as gr -from transformers import Wav2Vec2Tokenizer, Wav2Vec2ForCTC -nltk.download("punkt") - -#Loading the model and the tokenizer -model_name = "facebook/wav2vec2-base-960h" -tokenizer = Wav2Vec2Tokenizer.from_pretrained(model_name) -model = Wav2Vec2ForCTC.from_pretrained(model_name) - - -def load_data(input_file): - - """ Function for resampling to ensure that the speech input is sampled at 16KHz. - """ - #read the file - speech, sample_rate = librosa.load(input_file) - #make it 1-D - if len(speech.shape) > 1: - speech = speech[:,0] + speech[:,1] - #Resampling at 16KHz since wav2vec2-base-960h is pretrained and fine-tuned on speech audio sampled at 16 KHz. - if sample_rate !=16000: - speech = librosa.resample(speech, sample_rate,16000) - return speech - - - -def correct_casing(input_sentence): - """ This function is for correcting the casing of the generated transcribed text - """ - sentences = nltk.sent_tokenize(input_sentence) - return (' '.join([s.replace(s[0],s[0].capitalize(),1) for s in sentences])) - - - -def asr_transcript(input_file): - """This function generates transcripts for the provided audio input - """ - speech = load_data(input_file) - - #Tokenize - input_values = tokenizer(speech, return_tensors="pt").input_values - #Take logits - logits = model(input_values).logits - #Take argmax - predicted_ids = torch.argmax(logits, dim=-1) - #Get the words from predicted word ids - transcription = tokenizer.decode(predicted_ids[0]) - #Output is all upper case - transcription = correct_casing(transcription.lower()) - return transcription - - -gr.Interface(asr_transcript, - inputs = gr.inputs.Audio(source="microphone", type="filepath", optional=True, label="Please record your voice"), - outputs = gr.outputs.Textbox(label="Output Text"), - title="ASR using Wav2Vec 2.0", - description = "This application displays transcribed text for given audio input", - examples = [["Test_File1.wav"], ["Test_File2.wav"], ["Test_File3.wav"]], theme="grass").launch() - diff --git a/spaces/EPFL-VILAB/MultiMAE/utils/metrics.py b/spaces/EPFL-VILAB/MultiMAE/utils/metrics.py deleted file mode 100644 index e31c750eebaba053ef45ff8ef17827a1a0843bdf..0000000000000000000000000000000000000000 --- a/spaces/EPFL-VILAB/MultiMAE/utils/metrics.py +++ /dev/null @@ -1,45 +0,0 @@ -# -------------------------------------------------------- -# Based on timm and MAE-priv code bases -# https://github.com/rwightman/pytorch-image-models/tree/master/timm -# https://github.com/BUPT-PRIV/MAE-priv -# -------------------------------------------------------- -""" Eval metrics and related - -Hacked together by / Copyright 2020 Ross Wightman -""" - - -class AverageMeter: - """Computes and stores the average and current value""" - - def __init__(self): - self.reset() - - def reset(self): - self.val = 0 - self.avg = 0 - self.sum = 0 - self.count = 0 - - def update(self, val, n=1): - self.val = val - self.sum += val * n - self.count += n - self.avg = self.sum / self.count - - -def accuracy(output, target, topk=(1,)): - """Computes the accuracy over the k top predictions for the specified values of k""" - maxk = min(max(topk), output.size()[1]) - batch_size = target.size(0) - _, pred = output.topk(maxk, 1, True, True) - pred = pred.t() - correct = pred.eq(target.reshape(1, -1).expand_as(pred)) - return [correct[:min(k, maxk)].reshape(-1).float().sum(0) * 100. / batch_size for k in topk] - - -def cls_map(output, target): - # batch_size = target.size(0) - # idx_axes = torch.arange(batch_size) - scores, preds = output.softmax(dim=-1).topk(1, 1, True, True) - return scores, preds diff --git a/spaces/ElAnon/nsumr/app.py b/spaces/ElAnon/nsumr/app.py deleted file mode 100644 index 0014a79b3178fca1ecb892d56bfeea8ed54f51dc..0000000000000000000000000000000000000000 --- a/spaces/ElAnon/nsumr/app.py +++ /dev/null @@ -1,11 +0,0 @@ -import gradio as gr - - -def image_classifier(inp): - return {'cat': 0.3, 'dog': 0.7} - - -iface = gr.Interface(fn=image_classifier, inputs="image", outputs="label").load("huggingface/facebook/bart-large-cnn") - - -iface.launch() \ No newline at end of file diff --git a/spaces/EsoCode/text-generation-webui/extensions/multimodal/script.py b/spaces/EsoCode/text-generation-webui/extensions/multimodal/script.py deleted file mode 100644 index b3f654e43269ef53bfbecc628a0d94ecb3d2f83b..0000000000000000000000000000000000000000 --- a/spaces/EsoCode/text-generation-webui/extensions/multimodal/script.py +++ /dev/null @@ -1,103 +0,0 @@ -import base64 -import re -import time -from functools import partial -from io import BytesIO - -import gradio as gr -import torch - -from extensions.multimodal.multimodal_embedder import MultimodalEmbedder -from modules import shared -from modules.logging_colors import logger - -params = { - "add_all_images_to_prompt": False, - # device to run vision encoder on - "vision_device": None, - # bits to load vision encoder in, either 16 or 32 - "vision_bits": 32, - # device to run multimodal projector on - "projector_device": None, - # multimodal projector bits, either 32 or 16 - "projector_bits": 32 -} - - -# If 'state' is True, will hijack the next chat generation -input_hijack = { - 'state': False, - 'value': ["", ""] -} - - -# initialized in ui, so that params are loaded from settings -multimodal_embedder: MultimodalEmbedder = None - - -def add_chat_picture(picture, text, visible_text): - # resize the image, so that shortest edge is at least 224 (size for CLIP), and at most 300 (to keep history manageable) - max_hw, min_hw = max(picture.size), min(picture.size) - aspect_ratio = max_hw / min_hw - shortest_edge = int(max(300 / aspect_ratio, 224)) - longest_edge = int(shortest_edge * aspect_ratio) - w = shortest_edge if picture.width < picture.height else longest_edge - h = shortest_edge if picture.width >= picture.height else longest_edge - picture = picture.resize((w, h)) - - buffer = BytesIO() - picture.save(buffer, format="JPEG") - img_str = base64.b64encode(buffer.getvalue()).decode('utf-8') - image = f' 
'
-
- if '' in text: - text = text.replace(' ', image) - else: - text = text + '\n' + image - - if visible_text == '' or visible_text is None: - visible_text = text - elif ' ' in visible_text: - visible_text = visible_text.replace(' ', image) - else: - visible_text = visible_text + '\n' + image - - return text, visible_text - - -def custom_tokenized_length(prompt): - return multimodal_embedder.len_in_tokens(prompt) - - -def tokenizer_modifier(state, prompt, input_ids, input_embeds): - global params - start_ts = time.time() - image_match = re.search(r' 
', prompt)
-
- if image_match is None:
- return prompt, input_ids, input_embeds
-
- prompt, input_ids, input_embeds, total_embedded = multimodal_embedder.forward(prompt, state, params)
- logger.info(f'Embedded {total_embedded} image(s) in {time.time()-start_ts:.2f}s')
- return (prompt,
- input_ids.unsqueeze(0).to(shared.model.device, dtype=torch.int64),
- input_embeds.unsqueeze(0).to(shared.model.device, dtype=shared.model.dtype))
-
-
-def ui():
- global multimodal_embedder
- multimodal_embedder = MultimodalEmbedder(params)
- with gr.Column():
- picture_select = gr.Image(label='Send a picture', type='pil')
- # The models don't seem to deal well with multiple images
- single_image_checkbox = gr.Checkbox(False, label='Embed all images, not only the last one')
- # Prepare the input hijack
- picture_select.upload(
- lambda picture: input_hijack.update({"state": True, "value": partial(add_chat_picture, picture)}),
- [picture_select],
- None
- )
- picture_select.clear(lambda: input_hijack.update({"state": False, "value": ["", ""]}), None, None)
- single_image_checkbox.change(lambda x: params.update({"add_all_images_to_prompt": x}), single_image_checkbox, None)
- shared.gradio['Generate'].click(lambda: None, None, picture_select)
- shared.gradio['textbox'].submit(lambda: None, None, picture_select)
diff --git a/spaces/EuroPython2022/pulsar-clip/utils.py b/spaces/EuroPython2022/pulsar-clip/utils.py
deleted file mode 100644
index be53a32665baba000a7ac0a4a1c1c1e34127cf88..0000000000000000000000000000000000000000
--- a/spaces/EuroPython2022/pulsar-clip/utils.py
+++ /dev/null
@@ -1,139 +0,0 @@
-import numpy as np
-import random
-import torch
-import math
-
-
-def rotate_axis(x, add_angle=0, axis=1): # TODO Replace with a rotation matrix # But this is more fun
- axes = list(range(3))
- axes.remove(axis)
- ax1, ax2 = axes
- angle = torch.atan2(x[..., ax1], x[..., ax2])
- if isinstance(add_angle, torch.Tensor):
- while add_angle.ndim < angle.ndim:
- add_angle = add_angle.unsqueeze(-1)
- angle = angle + add_angle
- dist = x.norm(dim=-1)
- t = []
- _, t = zip(*sorted([
- (axis, x[..., axis]),
- (ax1, torch.sin(angle) * dist),
- (ax2, torch.cos(angle) * dist),
- ]))
- return torch.stack(t, dim=-1)
-
-
-noise_level = 0.5
-
-
-# stolen from https://gist.github.com/ac1b097753f217c5c11bc2ff396e0a57
-# ported from https://github.com/pvigier/perlin-numpy/blob/master/perlin2d.py
-def rand_perlin_2d(shape, res, fade=lambda t: 6 * t ** 5 - 15 * t ** 4 + 10 * t ** 3):
- delta = (res[0] / shape[0], res[1] / shape[1])
- d = (shape[0] // res[0], shape[1] // res[1])
-
- grid = torch.stack(torch.meshgrid(torch.arange(0, res[0], delta[0]), torch.arange(0, res[1], delta[1])), dim=-1) % 1
- angles = 2 * math.pi * torch.rand(res[0] + 1, res[1] + 1)
- gradients = torch.stack((torch.cos(angles), torch.sin(angles)), dim=-1)
-
- tile_grads = lambda slice1, slice2: gradients[slice1[0]:slice1[1], slice2[0]:slice2[1]].repeat_interleave(d[0],
- 0).repeat_interleave(
- d[1], 1)
- dot = lambda grad, shift: (
- torch.stack((grid[:shape[0], :shape[1], 0] + shift[0], grid[:shape[0], :shape[1], 1] + shift[1]),
- dim=-1) * grad[:shape[0], :shape[1]]).sum(dim=-1)
-
- n00 = dot(tile_grads([0, -1], [0, -1]), [0, 0])
- n10 = dot(tile_grads([1, None], [0, -1]), [-1, 0])
- n01 = dot(tile_grads([0, -1], [1, None]), [0, -1])
- n11 = dot(tile_grads([1, None], [1, None]), [-1, -1])
- t = fade(grid[:shape[0], :shape[1]])
- return math.sqrt(2) * torch.lerp(torch.lerp(n00, n10, t[..., 0]), torch.lerp(n01, n11, t[..., 0]), t[..., 1])
-
-
-def rand_perlin_2d_octaves(shape, res, octaves=1, persistence=0.5):
- noise = torch.zeros(shape)
- frequency = 1
- amplitude = 1
- for _ in range(octaves):
- noise += amplitude * rand_perlin_2d(shape, (frequency * res[0], frequency * res[1]))
- frequency *= 2
- amplitude *= persistence
- noise *= random.random() - noise_level # haha
- noise += random.random() - noise_level # haha x2
- return noise
-
-
-def load_clip(model_name="ViT-B/16", device="cuda:0" if torch.cuda.is_available() else "cpu"):
- import clip
- model, preprocess = clip.load(model_name, device=device, jit=False)
- if len(preprocess.transforms) > 4:
- preprocess.transforms = preprocess.transforms[-1:]
- return model, preprocess
-
-
-# http://blog.andreaskahler.com/2009/06/creating-icosphere-mesh-in-code.html
-def ico():
- phi = (1 + 5 ** 0.5) / 2
- return (
- np.array([
- [-1, phi, 0],
- [1, phi, 0],
- [-1, -phi, 0],
- [1, -phi, 0],
- [0, -1, phi],
- [0, 1, phi],
- [0, -1, -phi],
- [0, 1, -phi],
- [phi, 0, -1],
- [phi, 0, 1],
- [-phi, 0, -1],
- [-phi, 0, 1]
- ]) / phi,
- [
- [0, 11, 5],
- [0, 5, 1],
- [0, 1, 7],
- [0, 7, 10],
- [0, 10, 11],
- [1, 5, 9],
- [5, 11, 4],
- [11, 10, 2],
- [10, 7, 6],
- [7, 1, 8],
- [3, 9, 4],
- [3, 4, 2],
- [3, 2, 6],
- [3, 6, 8],
- [3, 8, 9],
- [4, 9, 5],
- [2, 4, 11],
- [6, 2, 10],
- [8, 6, 7],
- [9, 8, 1]
- ]
- )
-
-
-def ico_at(xyz=np.array([0, 0, 0]), radius=1.0, i=0):
- vert, idx = ico()
- return vert * radius + xyz, [[y + i for y in x] for x in idx]
-
-
-def save_obj(points, out_path):
- with torch.inference_mode():
- vert_pos, vert_col, vert_rad, vert_opa = (x.detach().cpu().numpy() for x in points)
-
- verts = []
- faces = []
- for xyz, radius, (r, g, b), a in zip(vert_pos, vert_rad, vert_col, vert_opa):
- v, i = ico_at(xyz, radius, len(verts))
- for x, y, z in v:
- verts.append((x, y, z, r, g, b)) # int(r * 255), int(g * 255), int(b * 255), int(a * 255)))
- faces += i
-
- with open(out_path, "w") as out_file:
- for v in verts:
- out_file.write("v " + " ".join(map(str, v)) + "\n")
- for f in faces:
- out_file.write("f " + " ".join([str(x + 1) for x in f]) + "\n")
diff --git a/spaces/EuroSciPy2022/clustering/README.md b/spaces/EuroSciPy2022/clustering/README.md
deleted file mode 100644
index 836c379bfea0bec4cb3e9432f5732749fbd55909..0000000000000000000000000000000000000000
--- a/spaces/EuroSciPy2022/clustering/README.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: Clustering With Sklearn
-emoji: 📚
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 3.0.24
-app_file: app.py
-pinned: false
-license: bsd-3-clause
-tags:
-- sklearn
----
-
-# Clustering with scikit learn
-
-Gradio demo based on this [sklearn demo](https://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html).
diff --git a/spaces/FSDL-Fashion/fashion_img_search/fis/feature_extraction/detection/base.py b/spaces/FSDL-Fashion/fashion_img_search/fis/feature_extraction/detection/base.py
deleted file mode 100644
index 8ff21a7f1734932db0fb6826543dc23b39fe0428..0000000000000000000000000000000000000000
--- a/spaces/FSDL-Fashion/fashion_img_search/fis/feature_extraction/detection/base.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from abc import ABC, abstractmethod
-
-from PIL import Image
-
-
-class BaseDetector(ABC):
- """Base class for detection models."""
-
- @abstractmethod
- def __call__(self, image: Image) -> None:
- """Get embeddings from an image.
-
- Args:
- image: Image to encode
-
- Returns:
- Embedding
- """
diff --git a/spaces/FelixLuoX/codeformer/CodeFormer/facelib/detection/yolov5face/utils/__init__.py b/spaces/FelixLuoX/codeformer/CodeFormer/facelib/detection/yolov5face/utils/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Felladrin/Web-LLM-Mistral-7B-OpenOrca/dist/index.html b/spaces/Felladrin/Web-LLM-Mistral-7B-OpenOrca/dist/index.html
deleted file mode 100644
index 8855d95fb86c6230e1eaff3f6e740cbc8ebb0f78..0000000000000000000000000000000000000000
--- a/spaces/Felladrin/Web-LLM-Mistral-7B-OpenOrca/dist/index.html
+++ /dev/null
@@ -1 +0,0 @@
-\ No newline at end of file diff --git a/spaces/FridaZuley/RVC_HFKawaii/infer/lib/uvr5_pack/lib_v5/layers_537227KB.py b/spaces/FridaZuley/RVC_HFKawaii/infer/lib/uvr5_pack/lib_v5/layers_537227KB.py deleted file mode 100644 index 9b127bc6427f5c60c8cf85603a3d8a093c3501c4..0000000000000000000000000000000000000000 --- a/spaces/FridaZuley/RVC_HFKawaii/infer/lib/uvr5_pack/lib_v5/layers_537227KB.py +++ /dev/null @@ -1,126 +0,0 @@ -import torch -import torch.nn.functional as F -from torch import nn - -from . import spec_utils - - -class Conv2DBNActiv(nn.Module): - def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU): - super(Conv2DBNActiv, self).__init__() - self.conv = nn.Sequential( - nn.Conv2d( - nin, - nout, - kernel_size=ksize, - stride=stride, - padding=pad, - dilation=dilation, - bias=False, - ), - nn.BatchNorm2d(nout), - activ(), - ) - - def __call__(self, x): - return self.conv(x) - - -class SeperableConv2DBNActiv(nn.Module): - def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU): - super(SeperableConv2DBNActiv, self).__init__() - self.conv = nn.Sequential( - nn.Conv2d( - nin, - nin, - kernel_size=ksize, - stride=stride, - padding=pad, - dilation=dilation, - groups=nin, - bias=False, - ), - nn.Conv2d(nin, nout, kernel_size=1, bias=False), - nn.BatchNorm2d(nout), - activ(), - ) - - def __call__(self, x): - return self.conv(x) - - -class Encoder(nn.Module): - def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU): - super(Encoder, self).__init__() - self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ) - self.conv2 = Conv2DBNActiv(nout, nout, ksize, stride, pad, activ=activ) - - def __call__(self, x): - skip = self.conv1(x) - h = self.conv2(skip) - - return h, skip - - -class Decoder(nn.Module): - def __init__( - self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False - ): - super(Decoder, self).__init__() - self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ) - self.dropout = nn.Dropout2d(0.1) if dropout else None - - def __call__(self, x, skip=None): - x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True) - if skip is not None: - skip = spec_utils.crop_center(skip, x) - x = torch.cat([x, skip], dim=1) - h = self.conv(x) - - if self.dropout is not None: - h = self.dropout(h) - - return h - - -class ASPPModule(nn.Module): - def __init__(self, nin, nout, dilations=(4, 8, 16, 32, 64), activ=nn.ReLU): - super(ASPPModule, self).__init__() - self.conv1 = nn.Sequential( - nn.AdaptiveAvgPool2d((1, None)), - Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ), - ) - self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ) - self.conv3 = SeperableConv2DBNActiv( - nin, nin, 3, 1, dilations[0], dilations[0], activ=activ - ) - self.conv4 = SeperableConv2DBNActiv( - nin, nin, 3, 1, dilations[1], dilations[1], activ=activ - ) - self.conv5 = SeperableConv2DBNActiv( - nin, nin, 3, 1, dilations[2], dilations[2], activ=activ - ) - self.conv6 = SeperableConv2DBNActiv( - nin, nin, 3, 1, dilations[2], dilations[2], activ=activ - ) - self.conv7 = SeperableConv2DBNActiv( - nin, nin, 3, 1, dilations[2], dilations[2], activ=activ - ) - self.bottleneck = nn.Sequential( - Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1) - ) - - def forward(self, x): - _, _, h, w = x.size() - feat1 = F.interpolate( - self.conv1(x), size=(h, w), mode="bilinear", align_corners=True - ) - feat2 = self.conv2(x) - feat3 = self.conv3(x) - feat4 = self.conv4(x) - feat5 = self.conv5(x) - feat6 = self.conv6(x) - feat7 = self.conv7(x) - out = torch.cat((feat1, feat2, feat3, feat4, feat5, feat6, feat7), dim=1) - bottle = self.bottleneck(out) - return bottle diff --git a/spaces/FridaZuley/RVC_HFKawaii/tools/calc_rvc_model_similarity.py b/spaces/FridaZuley/RVC_HFKawaii/tools/calc_rvc_model_similarity.py deleted file mode 100644 index 42496e088e51dc5162d0714470c2226f696e260c..0000000000000000000000000000000000000000 --- a/spaces/FridaZuley/RVC_HFKawaii/tools/calc_rvc_model_similarity.py +++ /dev/null @@ -1,96 +0,0 @@ -# This code references https://huggingface.co/JosephusCheung/ASimilarityCalculatior/blob/main/qwerty.py -# Fill in the path of the model to be queried and the root directory of the reference models, and this script will return the similarity between the model to be queried and all reference models. -import os -import logging - -logger = logging.getLogger(__name__) - -import torch -import torch.nn as nn -import torch.nn.functional as F - - -def cal_cross_attn(to_q, to_k, to_v, rand_input): - hidden_dim, embed_dim = to_q.shape - attn_to_q = nn.Linear(hidden_dim, embed_dim, bias=False) - attn_to_k = nn.Linear(hidden_dim, embed_dim, bias=False) - attn_to_v = nn.Linear(hidden_dim, embed_dim, bias=False) - attn_to_q.load_state_dict({"weight": to_q}) - attn_to_k.load_state_dict({"weight": to_k}) - attn_to_v.load_state_dict({"weight": to_v}) - - return torch.einsum( - "ik, jk -> ik", - F.softmax( - torch.einsum("ij, kj -> ik", attn_to_q(rand_input), attn_to_k(rand_input)), - dim=-1, - ), - attn_to_v(rand_input), - ) - - -def model_hash(filename): - try: - with open(filename, "rb") as file: - import hashlib - - m = hashlib.sha256() - - file.seek(0x100000) - m.update(file.read(0x10000)) - return m.hexdigest()[0:8] - except FileNotFoundError: - return "NOFILE" - - -def eval(model, n, input): - qk = f"enc_p.encoder.attn_layers.{n}.conv_q.weight" - uk = f"enc_p.encoder.attn_layers.{n}.conv_k.weight" - vk = f"enc_p.encoder.attn_layers.{n}.conv_v.weight" - atoq, atok, atov = model[qk][:, :, 0], model[uk][:, :, 0], model[vk][:, :, 0] - - attn = cal_cross_attn(atoq, atok, atov, input) - return attn - - -def main(path, root): - torch.manual_seed(114514) - model_a = torch.load(path, map_location="cpu")["weight"] - - logger.info("Query:\t\t%s\t%s" % (path, model_hash(path))) - - map_attn_a = {} - map_rand_input = {} - for n in range(6): - hidden_dim, embed_dim, _ = model_a[ - f"enc_p.encoder.attn_layers.{n}.conv_v.weight" - ].shape - rand_input = torch.randn([embed_dim, hidden_dim]) - - map_attn_a[n] = eval(model_a, n, rand_input) - map_rand_input[n] = rand_input - - del model_a - - for name in sorted(list(os.listdir(root))): - path = "%s/%s" % (root, name) - model_b = torch.load(path, map_location="cpu")["weight"] - - sims = [] - for n in range(6): - attn_a = map_attn_a[n] - attn_b = eval(model_b, n, map_rand_input[n]) - - sim = torch.mean(torch.cosine_similarity(attn_a, attn_b)) - sims.append(sim) - - logger.info( - "Reference:\t%s\t%s\t%s" - % (path, model_hash(path), f"{torch.mean(torch.stack(sims)) * 1e2:.2f}%") - ) - - -if __name__ == "__main__": - query_path = r"assets\weights\mi v3.pth" - reference_root = r"assets\weights" - main(query_path, reference_root) diff --git a/spaces/GXSA/bingo/src/lib/hooks/use-copy-to-clipboard.tsx b/spaces/GXSA/bingo/src/lib/hooks/use-copy-to-clipboard.tsx deleted file mode 100644 index 62f7156dca246c46b213151af003a3a177977ccf..0000000000000000000000000000000000000000 --- a/spaces/GXSA/bingo/src/lib/hooks/use-copy-to-clipboard.tsx +++ /dev/null @@ -1,33 +0,0 @@ -'use client' - -import * as React from 'react' - -export interface useCopyToClipboardProps { - timeout?: number -} - -export function useCopyToClipboard({ - timeout = 2000 -}: useCopyToClipboardProps) { - const [isCopied, setIsCopied] = React.useState(false) - - const copyToClipboard = (value: string) => { - if (typeof window === 'undefined' || !navigator.clipboard?.writeText) { - return - } - - if (!value) { - return - } - - navigator.clipboard.writeText(value).then(() => { - setIsCopied(true) - - setTimeout(() => { - setIsCopied(false) - }, timeout) - }) - } - - return { isCopied, copyToClipboard } -} diff --git a/spaces/GaenKoki/voicevox/speaker_info/b1a81618-b27b-40d2-b0ea-27a9ad408c4b/policy.md b/spaces/GaenKoki/voicevox/speaker_info/b1a81618-b27b-40d2-b0ea-27a9ad408c4b/policy.md deleted file mode 100644 index 68114802c449a6799db4cf7aae3cecbb71db0e70..0000000000000000000000000000000000000000 --- a/spaces/GaenKoki/voicevox/speaker_info/b1a81618-b27b-40d2-b0ea-27a9ad408c4b/policy.md +++ /dev/null @@ -1,3 +0,0 @@ -dummy4 policy - -https://voicevox.hiroshiba.jp/ diff --git a/spaces/Gen-Sim/Gen-Sim/cliport/tasks/put_block_in_bowl.py b/spaces/Gen-Sim/Gen-Sim/cliport/tasks/put_block_in_bowl.py deleted file mode 100644 index 8d0649b3d07fca52aa361f48afc998d9e5607241..0000000000000000000000000000000000000000 --- a/spaces/Gen-Sim/Gen-Sim/cliport/tasks/put_block_in_bowl.py +++ /dev/null @@ -1,69 +0,0 @@ -import numpy as np -from cliport.tasks.task import Task -from cliport.utils import utils -import random -import pybullet as p - - -class PutBlockInBowl(Task): - """Place all blocks of a specified color in a bowl of specified color.""" - - def __init__(self): - super().__init__() - self.max_steps = 10 - self.lang_template = "put the {pick} blocks in a {place} bowl" - self.task_completed_desc = "done placing blocks in bowls." - self.additional_reset() - - - def reset(self, env): - super().reset(env) - n_bowls = np.random.randint(1, 4) - n_blocks = np.random.randint(1, n_bowls + 1) - colors, selected_color_names = utils.get_colors(mode=self.mode, n_colors=2) - - # Add bowls. - # x, y, z dimensions for the asset size - bowl_size = (0.12, 0.12, 0) - bowl_urdf = 'bowl/bowl.urdf' - bowl_poses = [] - for _ in range(n_bowls): - bowl_pose = self.get_random_pose(env, bowl_size) - bowl_id = env.add_object(bowl_urdf, bowl_pose, category='fixed', color=colors[1]) - bowl_poses.append(bowl_pose) - - # Add blocks. - blocks = [] - block_size = (0.04, 0.04, 0.04) - block_urdf = 'stacking/block.urdf' - for _ in range(n_blocks): - block_pose = self.get_random_pose(env, block_size) - block_id = env.add_object(block_urdf, block_pose, color=colors[0]) - blocks.append(block_id) - - # Goal: put each block in a different bowl. - language_goal = (self.lang_template.format(pick=selected_color_names[0], place=selected_color_names[1])) - self.add_goal(objs=blocks, matches=np.ones((len(blocks), len(bowl_poses))), targ_poses=bowl_poses, replace=False, - rotations=True, metric='pose', params=None, step_max_reward=1, language_goal=language_goal) - - - # Only one mistake allowed. - self.max_steps = len(blocks) + 1 - - # Colors of distractor objects. - distractor_bowl_colors = [utils.COLORS[c] for c in utils.COLORS if c not in selected_color_names] - distractor_block_colors = [utils.COLORS[c] for c in utils.COLORS if c not in selected_color_names] - - # Add distractors. - n_distractors = 0 - max_distractors = 6 - while n_distractors < max_distractors: - is_block = np.random.rand() > 0.5 - urdf = block_urdf if is_block else bowl_urdf - size = block_size if is_block else bowl_size - colors = distractor_block_colors if is_block else distractor_bowl_colors - pose = self.get_random_pose(env, size) - color = colors[n_distractors % len(colors)] - - obj_id = env.add_object(urdf, pose, color=color) - n_distractors += 1 \ No newline at end of file diff --git a/spaces/Gradio-Blocks/anime-colorization/scripts/pixel_guide_super_res_train.py b/spaces/Gradio-Blocks/anime-colorization/scripts/pixel_guide_super_res_train.py deleted file mode 100644 index 89f25bec1f62e0392aadb23e5b2665a115edffc1..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/anime-colorization/scripts/pixel_guide_super_res_train.py +++ /dev/null @@ -1,108 +0,0 @@ -""" -Train a super-resolution model. -""" - -import argparse - -import torch.nn.functional as F - -from pixel_guide_diffusion import dist_util, logger -from pixel_guide_diffusion.image_datasets import load_data -from pixel_guide_diffusion.resample import create_named_schedule_sampler -from pixel_guide_diffusion.script_util import ( - pgsr_model_and_diffusion_defaults, - pgsr_create_model_and_diffusion, - args_to_dict, - add_dict_to_argparser, -) -from pixel_guide_diffusion.train_util import TrainLoop - - -def main(): - args = create_argparser().parse_args() - - dist_util.setup_dist() - logger.configure() - - logger.log("creating model...") - model, diffusion = pgsr_create_model_and_diffusion( - **args_to_dict(args, pgsr_model_and_diffusion_defaults().keys()) - ) - model.to(dist_util.dev()) - schedule_sampler = create_named_schedule_sampler(args.schedule_sampler, diffusion) - - logger.log("creating data loader...") - data = load_superres_data( - args.data_dir, - args.batch_size, - large_size=args.large_size, - small_size=args.small_size, - class_cond=args.class_cond, - guide_dir=args.guide_dir, - guide_size=args.guide_size, - crop_size=args.crop_size, - deterministic=True, - ) - - logger.log("training...") - TrainLoop( - model=model, - diffusion=diffusion, - data=data, - batch_size=args.batch_size, - microbatch=args.microbatch, - lr=args.lr, - ema_rate=args.ema_rate, - log_interval=args.log_interval, - save_interval=args.save_interval, - resume_checkpoint=args.resume_checkpoint, - use_fp16=args.use_fp16, - fp16_scale_growth=args.fp16_scale_growth, - schedule_sampler=schedule_sampler, - weight_decay=args.weight_decay, - lr_anneal_steps=args.lr_anneal_steps, - ).run_loop() - - -def load_superres_data(data_dir, batch_size, large_size, small_size, class_cond=False, guide_dir='', guide_size=0, crop_size=0, deterministic=False): - data = load_data( - data_dir=data_dir, - batch_size=batch_size, - image_size=large_size, - class_cond=class_cond, - guide_dir=guide_dir, - guide_size=guide_size, - crop_size=crop_size, - deterministic=deterministic, - ) - for large_batch, model_kwargs in data: - model_kwargs["low_res"] = F.interpolate(large_batch, scale_factor=small_size/large_size, mode="area") - yield large_batch, model_kwargs - - -def create_argparser(): - defaults = dict( - data_dir="", - guide_dir="", - crop_size=32, - schedule_sampler="uniform", - lr=1e-4, - weight_decay=0.0, - lr_anneal_steps=0, - batch_size=1, - microbatch=-1, - ema_rate="0.9999", - log_interval=10, - save_interval=10000, - resume_checkpoint="", - use_fp16=False, - fp16_scale_growth=1e-3, - ) - defaults.update(pgsr_model_and_diffusion_defaults()) - parser = argparse.ArgumentParser() - add_dict_to_argparser(parser, defaults) - return parser - - -if __name__ == "__main__": - main() diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/exp/mask_rcnn_1x_hybrid_base/config.py b/spaces/Gradio-Blocks/uniformer_image_detection/exp/mask_rcnn_1x_hybrid_base/config.py deleted file mode 100644 index 64e1fabdc75de43ad473cb3eea02cc51104ad84a..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_detection/exp/mask_rcnn_1x_hybrid_base/config.py +++ /dev/null @@ -1,37 +0,0 @@ -_base_ = [ - '../../configs/_base_/models/mask_rcnn_uniformer_fpn.py', - '../../configs/_base_/datasets/coco_instance.py', - '../../configs/_base_/schedules/schedule_1x.py', - '../../configs/_base_/default_runtime.py' -] - -model = dict( - backbone=dict( - embed_dim=[64, 128, 320, 512], - layers=[5, 8, 20, 7], - head_dim=64, - drop_path_rate=0.3, - use_checkpoint=False, - windows=False, - hybrid=True, - window_size=14 - ), - neck=dict(in_channels=[64, 128, 320, 512])) - -optimizer = dict(_delete_=True, type='AdamW', lr=0.0001, betas=(0.9, 0.999), weight_decay=0.05, - paramwise_cfg=dict(custom_keys={'absolute_pos_embed': dict(decay_mult=0.), - 'relative_position_bias_table': dict(decay_mult=0.), - 'norm': dict(decay_mult=0.)})) -lr_config = dict(step=[8, 11]) -runner = dict(type='EpochBasedRunnerAmp', max_epochs=12) - -# do not use mmdet version fp16 -fp16 = None -optimizer_config = dict( - type="DistOptimizerHook", - update_interval=1, - grad_clip=None, - coalesce=True, - bucket_size_mb=-1, - use_fp16=True, -) diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes.py deleted file mode 100644 index c53ec41baf9043029549b4893b2380372ea5ecd9..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r101-d16-mg124_512x1024_80k_cityscapes.py +++ /dev/null @@ -1,11 +0,0 @@ -_base_ = './deeplabv3plus_r50-d8_512x1024_80k_cityscapes.py' -model = dict( - pretrained='open-mmlab://resnet101_v1c', - backbone=dict( - depth=101, - dilations=(1, 1, 1, 2), - strides=(1, 2, 2, 1), - multi_grid=(1, 2, 4)), - decode_head=dict( - dilations=(1, 6, 12, 18), - sampler=dict(type='OHEMPixelSampler', min_kept=100000))) diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r101-d8_512x512_160k_ade20k.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r101-d8_512x512_160k_ade20k.py deleted file mode 100644 index 7f6795e5ef0e4bf1d10ee7ed4f608bf93ac24216..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r101-d8_512x512_160k_ade20k.py +++ /dev/null @@ -1,2 +0,0 @@ -_base_ = './psanet_r50-d8_512x512_160k_ade20k.py' -model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101)) diff --git a/spaces/GuXiaoBei/wechat-chatbot/channel/channel_factory.py b/spaces/GuXiaoBei/wechat-chatbot/channel/channel_factory.py deleted file mode 100644 index bfeaacfd835dec6b69109e025e43c8b6eacb121b..0000000000000000000000000000000000000000 --- a/spaces/GuXiaoBei/wechat-chatbot/channel/channel_factory.py +++ /dev/null @@ -1,17 +0,0 @@ -""" -channel factory -""" - -def create_channel(channel_type): - """ - create a channel instance - :param channel_type: channel type code - :return: channel instance - """ - if channel_type == 'wx': - from channel.wechat.wechat_channel import WechatChannel - return WechatChannel() - elif channel_type == 'wxy': - from channel.wechat.wechaty_channel import WechatyChannel - return WechatyChannel() - raise RuntimeError diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/distributed/utils.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/distributed/utils.py deleted file mode 100644 index dbf318e7035603c1294eb45af7e98097df36289d..0000000000000000000000000000000000000000 --- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/distributed/utils.py +++ /dev/null @@ -1,826 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. -# -# This source code is licensed under the MIT license found in the -# LICENSE file in the root directory of this source tree. - -import io -import logging -import os -import pickle -import random -import socket -import struct -import subprocess -import warnings -from argparse import Namespace -from collections import OrderedDict -from dataclasses import dataclass -from typing import Any, Dict, List, Mapping, Optional -import sys -import time - -import torch -import torch.distributed as dist -from fairseq.dataclass.configs import DistributedTrainingConfig, FairseqConfig -from omegaconf import open_dict - -try: - import torch_xla.core.xla_model as xm -except ImportError: - xm = None - - -# Flag to indicate if we're using Megatron -# NOTE: this is a temporary hack until we move away from Megatron's model parallel init -_USE_MEGATRON = False - -# Whether to use XLA ops (e.g., on TPUs) instead of CUDA ops. -_USE_XLA = False - - -logger = logging.getLogger(__name__) - - -def is_master(cfg: DistributedTrainingConfig): - return cfg.distributed_rank == 0 - - -def infer_init_method(cfg: DistributedTrainingConfig, force_distributed=False): - if cfg.distributed_init_method is not None or cfg.tpu: - return - - num_pipelines_per_node = None - if cfg.pipeline_model_parallel: - num_pipeline_devices, num_pipelines_per_node = _pipeline_parallel_pre_init(cfg) - - if all( - key in os.environ - for key in ["MASTER_ADDR", "MASTER_PORT", "WORLD_SIZE", "RANK"] - ): - # support torch.distributed.launch - _infer_torch_distributed_launch_init(cfg) - elif cfg.distributed_port > 0: - # we can determine the init method automatically for Slurm - _infer_slurm_init(cfg, num_pipelines_per_node) - elif cfg.distributed_world_size > 1 or force_distributed: - # fallback for single node with multiple GPUs - _infer_single_node_init(cfg) - - if cfg.pipeline_model_parallel: - _pipeline_parallel_post_init(cfg, num_pipeline_devices, num_pipelines_per_node) - elif not cfg.distributed_no_spawn: - with open_dict(cfg): - cfg.distributed_num_procs = min( - torch.cuda.device_count(), cfg.distributed_world_size - ) - - -def _infer_torch_distributed_launch_init(cfg: DistributedTrainingConfig): - cfg.distributed_init_method = "env://" - cfg.distributed_world_size = int(os.environ["WORLD_SIZE"]) - cfg.distributed_rank = int(os.environ["RANK"]) - # processes are created by torch.distributed.launch - cfg.distributed_no_spawn = True - - -def _infer_slurm_init(cfg: DistributedTrainingConfig, num_pipelines_per_node): - node_list = os.environ.get("SLURM_STEP_NODELIST") - if node_list is None: - node_list = os.environ.get("SLURM_JOB_NODELIST") - if node_list is not None: - try: - hostnames = subprocess.check_output( - ["scontrol", "show", "hostnames", node_list] - ) - cfg.distributed_init_method = "tcp://{host}:{port}".format( - host=hostnames.split()[0].decode("utf-8"), - port=cfg.distributed_port, - ) - nnodes = int(os.environ.get("SLURM_NNODES")) - ntasks_per_node = os.environ.get("SLURM_NTASKS_PER_NODE") - if ntasks_per_node is not None: - ntasks_per_node = int(ntasks_per_node) - else: - ntasks = int(os.environ.get("SLURM_NTASKS")) - nnodes = int(os.environ.get("SLURM_NNODES")) - assert ntasks % nnodes == 0 - ntasks_per_node = int(ntasks / nnodes) - if ntasks_per_node == 1: - gpus_per_node = torch.cuda.device_count() - node_id = int(os.environ.get("SLURM_NODEID")) - cfg.distributed_rank = node_id * gpus_per_node - cfg.distributed_world_size = nnodes * gpus_per_node - elif cfg.pipeline_model_parallel: - assert ntasks_per_node == num_pipelines_per_node, ( - "SLURM --ntasks-per-node must match number of pipelines per " - "node (={})".format(num_pipelines_per_node) - ) - cfg.distributed_no_spawn = True - # For 4-way MP on nodes with 8 GPUs, ranks will be [0, 1] on - # the first node, [1, 2] on the second node, etc. This - # matches torch.distributed.launch. - node_id = int(os.environ.get("SLURM_NODEID")) - local_id = int(os.environ.get("SLURM_LOCALID")) - cfg.distributed_rank = node_id * num_pipelines_per_node + local_id - # In the above example, device_id will always be in [0, 1], - # which also matches torch.distributed.launch. - cfg.device_id = local_id - # We also want to set distributed_world_size to be the total - # number of pipelines across all nodes. - cfg.distributed_world_size = nnodes * num_pipelines_per_node - else: - assert ntasks_per_node == cfg.distributed_world_size // nnodes - cfg.distributed_no_spawn = True - cfg.distributed_rank = int(os.environ.get("SLURM_PROCID")) - cfg.device_id = int(os.environ.get("SLURM_LOCALID")) - except subprocess.CalledProcessError as e: # scontrol failed - raise e - except FileNotFoundError: # Slurm is not installed - pass - - -def _infer_single_node_init(cfg: DistributedTrainingConfig): - assert ( - cfg.distributed_world_size <= torch.cuda.device_count() - ), f"world size is {cfg.distributed_world_size} but have {torch.cuda.device_count()} available devices" - port = random.randint(10000, 20000) - cfg.distributed_init_method = "tcp://localhost:{port}".format(port=port) - - -def _pipeline_parallel_pre_init(cfg: DistributedTrainingConfig): - from fairseq import utils - - balance_exists = ( - cfg.pipeline_balance is not None - or cfg.pipeline_encoder_balance is not None - or cfg.pipeline_decoder_balance is not None - ) - devices_exist = ( - cfg.pipeline_devices is not None - or cfg.pipeline_encoder_devices is not None - or cfg.pipeline_decoder_devices is not None - ) - if not balance_exists: - raise ValueError( - "--pipeline-balance is currently required for pipeline model parallelism" - ) - if not devices_exist: - raise ValueError( - "--pipeline-devices is currently required for pipeline model parallelism" - ) - - cfg.pipeline_balance = utils.eval_str_list(cfg.pipeline_balance, type=int) - if cfg.pipeline_devices is not None: - cfg.pipeline_devices = utils.eval_str_list(cfg.pipeline_devices, type=int) - num_pipeline_devices = len(set(cfg.pipeline_devices)) - else: - cfg.pipeline_encoder_devices = utils.eval_str_list( - cfg.pipeline_encoder_devices, type=int - ) - cfg.pipeline_decoder_devices = utils.eval_str_list( - cfg.pipeline_decoder_devices, type=int - ) - num_pipeline_devices = len( - set(cfg.pipeline_encoder_devices + cfg.pipeline_decoder_devices) - ) - gpus_per_node = torch.cuda.device_count() - assert ( - gpus_per_node >= num_pipeline_devices - and gpus_per_node % num_pipeline_devices == 0 - ), ( - "the number of unique device IDs in --pipeline-devices must evenly divide " - "the number of GPUs per node (multi-node pipelining is not yet supported)" - ) - num_pipelines_per_node = gpus_per_node // num_pipeline_devices - return num_pipeline_devices, num_pipelines_per_node - - -def _pipeline_parallel_post_init( - cfg: DistributedTrainingConfig, num_pipeline_devices, num_pipelines_per_node -): - if not cfg.distributed_no_spawn: - # When distributed_no_spawn is False, we expect distributed_rank and - # distributed_world_size to be based on the total number of GPUs, so - # we need to correct them to be based on the number of pipelines. - assert cfg.distributed_world_size % num_pipeline_devices == 0 - cfg.distributed_world_size = ( - cfg.distributed_world_size // num_pipeline_devices - ) - # In the case of 4-way MP on nodes with 8 GPUs, we want - # distributed_rank to be the starting GPU index for each pipeline - # i.e., 0, 2, ... - gpus_per_node = torch.cuda.device_count() - assert cfg.distributed_rank % gpus_per_node == 0 - assert cfg.distributed_rank % num_pipeline_devices == 0 - - with open_dict(cfg): - cfg.distributed_rank = cfg.distributed_rank // num_pipeline_devices - # launch one process per pipeline - cfg.distributed_num_procs = num_pipelines_per_node - - # if we have 4-way MP on a node with 8 GPUs, we want device_ids to be 0 - # and 4, indicating the starting device IDs for each pipeline - cfg.device_id *= num_pipeline_devices - - if cfg.device_id > 0: - # if there's multiple pipelines on a node (e.g., 4-way MP on an 8 - # GPU node), we need to adjust pipeline_devices accordingly - logger.debug( - "setting CUDA device={} on rank {}".format( - cfg.device_id, cfg.distributed_rank - ) - ) - torch.cuda.set_device(cfg.device_id) - with open_dict(cfg): - cfg.pipeline_devices = [cfg.device_id + d for d in cfg.pipeline_devices] - logger.info( - "setting pipeline_devices={} on rank {}".format( - cfg.pipeline_devices, cfg.distributed_rank - ) - ) - - -def distributed_init(cfg: FairseqConfig): - if isinstance(cfg, Namespace): - from fairseq.dataclass.utils import convert_namespace_to_omegaconf - - cfg = convert_namespace_to_omegaconf(cfg) - - if not cfg.common.tpu: - if torch.distributed.is_available() and torch.distributed.is_initialized(): - warnings.warn( - "Distributed is already initialized, cannot initialize twice!" - ) - else: - logger.info( - "distributed init (rank {}): {}".format( - cfg.distributed_training.distributed_rank, - cfg.distributed_training.distributed_init_method, - ) - ) - logger.info('Start init') - max_time_wait = 600 - for i in range(max_time_wait): - try: - dist.init_process_group( - backend=cfg.distributed_training.distributed_backend, - init_method=cfg.distributed_training.distributed_init_method, - world_size=cfg.distributed_training.distributed_world_size, - rank=cfg.distributed_training.distributed_rank, - ) - logger.info( - "initialized host {} as rank {}".format( - socket.gethostname(), - cfg.distributed_training.distributed_rank, - ) - ) - if torch.distributed.is_initialized(): - print("single-machine distributed training is initialized.") - break - except ValueError: - # This is caused by TCPStore failure. - print('Retry: {}, with value error {}'.format( - i + 1, sys.exc_info()[0])) - time.sleep(5) - if i == max_time_wait - 1: - print('k8s resource wait too long time') - exit(-1) - except Exception: - print('Retry: {}, with value error {}'.format( - i + 1, sys.exc_info()[0])) - exit(-1) - # perform a dummy all-reduce to initialize the NCCL communicator - if torch.cuda.is_available(): - dist.all_reduce(torch.zeros(1).cuda()) - - cfg.distributed_training.distributed_rank = torch.distributed.get_rank() - else: - assert xm.xrt_world_size() == cfg.distributed_training.distributed_world_size - global _USE_XLA - _USE_XLA = True - cfg.distributed_training.device_id = xm.get_local_ordinal() - cfg.distributed_training.distributed_rank = xm.get_ordinal() - xm.rendezvous("distributed_init") # wait for all workers - - if is_master(cfg.distributed_training): - logging.getLogger().setLevel(logging.INFO) - else: - logging.getLogger().setLevel(logging.WARNING) - - if cfg.common.model_parallel_size > 1: - try: - from fairseq.model_parallel.megatron.mpu import ( - initialize_model_parallel, - model_parallel_cuda_manual_seed, - ) - except ImportError: - raise ImportError( - "\n\nPlease install the megatron submodule:" - "\n\n git submodule update --init " - "fairseq/model_parallel/megatron" - ) - global _USE_MEGATRON - _USE_MEGATRON = True - initialize_model_parallel(cfg.common.model_parallel_size) - model_parallel_cuda_manual_seed(cfg.common.seed) - model_part_number = get_model_parallel_rank() - cfg.checkpoint.checkpoint_suffix += "-model_part-{0}".format(model_part_number) - - if hasattr(cfg, "model") and getattr(cfg.model, "base_layers", 0) > 0: - cfg.checkpoint.checkpoint_suffix = f"-rank-{cfg.distributed_training.distributed_rank}" - - return cfg.distributed_training.distributed_rank - - -def distributed_main(i, main, cfg: FairseqConfig, kwargs): - cfg.distributed_training.device_id = i - if torch.cuda.is_available() and not cfg.common.cpu and not cfg.common.tpu: - torch.cuda.set_device(cfg.distributed_training.device_id) - if cfg.distributed_training.distributed_rank is None: # torch.multiprocessing.spawn - cfg.distributed_training.distributed_rank = kwargs.pop("start_rank", 0) + i - - cfg.distributed_training.distributed_rank = distributed_init(cfg) - - after_distributed_init_fn = kwargs.pop("after_distributed_init_fn", None) - if after_distributed_init_fn: - cfg = after_distributed_init_fn(cfg) - - main(cfg, **kwargs) - - if torch.distributed.is_initialized(): - torch.distributed.barrier(get_global_group()) - - -def call_main(cfg: FairseqConfig, main, **kwargs): - if cfg.distributed_training.distributed_init_method is None: - infer_init_method(cfg.distributed_training) - - if cfg.distributed_training.distributed_init_method is not None: - # distributed training - if not cfg.distributed_training.distributed_no_spawn: - start_rank = cfg.distributed_training.distributed_rank - cfg.distributed_training.distributed_rank = None # assign automatically - kwargs["start_rank"] = start_rank - torch.multiprocessing.spawn( - fn=distributed_main, - args=(main, cfg, kwargs), - nprocs=min( - torch.cuda.device_count(), - cfg.distributed_training.distributed_world_size, - ), - join=True, - ) - else: - distributed_main(cfg.distributed_training.device_id, main, cfg, kwargs) - elif cfg.common.tpu and cfg.distributed_training.distributed_world_size > 1: - import torch_xla.distributed.xla_multiprocessing as xmp - - torch.multiprocessing.set_sharing_strategy("file_system") - xmp.spawn( - fn=distributed_main, - args=(main, cfg, kwargs), - # tpu-comment: - # 8 devices in one TPU VM, is the max processes to be spawned. - # The rest is driven by xm.distributed.xla_dist - nprocs=min(cfg.distributed_training.distributed_world_size, 8), - ) - else: - # single GPU main - main(cfg, **kwargs) - - -def use_xla(): - global _USE_XLA - return _USE_XLA - - -def new_groups(grouped_ranks: List[List[int]]): - if use_xla(): - return ("tpu", grouped_ranks) - else: - groups = [dist.new_group(g) for g in grouped_ranks] - my_group_idx = _find_my_group_index(grouped_ranks) - return groups[my_group_idx] - - -def _find_my_group_index(grouped_ranks): - my_rank = get_global_rank() - for i, group in enumerate(grouped_ranks): - if my_rank in group: - return i - raise RuntimeError - - -def _find_my_group(grouped_ranks): - index = _find_my_group_index(grouped_ranks) - return grouped_ranks[index] - - -def get_rank(group): - if use_xla(): - assert group[0] == "tpu" - my_group = _find_my_group(group[1]) - return my_group.index(get_global_rank()) - else: - return dist.get_rank(group=group) - - -def get_world_size(group): - if use_xla(): - assert group[0] == "tpu" - my_group = _find_my_group(group[1]) - return len(my_group) - elif torch.distributed.is_initialized(): - return dist.get_world_size(group=group) - else: - return 1 - - -def get_global_group(): - if use_xla(): - return new_groups([list(range(get_global_world_size()))]) - elif torch.distributed.is_initialized(): - if not hasattr(get_global_group, "_global_group"): - # ideally we could use torch.distributed.group.WORLD, but it seems - # to cause random NCCL hangs in some cases - get_global_group._global_group = dist.new_group() - return get_global_group._global_group - else: - return None - - -def get_global_rank(): - if use_xla(): - return xm.get_ordinal() - elif torch.distributed.is_initialized(): - return torch.distributed.get_rank() - else: - return 0 - - -def get_global_world_size(): - if use_xla(): - return xm.xrt_world_size() - elif torch.distributed.is_initialized(): - return torch.distributed.get_world_size() - else: - return 1 - - -def get_data_parallel_group(): - """Get the data parallel group the caller rank belongs to.""" - global _USE_MEGATRON - if _USE_MEGATRON: - from fairseq.model_parallel.megatron import mpu - - return mpu.get_data_parallel_group() - else: - return get_global_group() - - -def get_data_parallel_rank(): - """Return my rank for the data parallel group.""" - return get_rank(get_data_parallel_group()) - - -def get_data_parallel_world_size(): - """Return world size for the data parallel group.""" - return get_world_size(get_data_parallel_group()) - - -def get_model_parallel_group(): - global _USE_MEGATRON - if _USE_MEGATRON: - from fairseq.model_parallel.megatron import mpu - - return mpu.get_model_parallel_group() - else: - return None - - -def get_model_parallel_rank(): - """Return my rank for the model parallel group.""" - return get_rank(get_model_parallel_group()) - - -def get_model_parallel_world_size(): - """Return world size for the model parallel group.""" - return get_world_size(get_model_parallel_group()) - - -def all_reduce(tensor, group, op="sum"): - if use_xla(): - assert isinstance(group, tuple) and group[0] == "tpu" - tensor = [tensor] # wrap in a list to make xm.all_reduce in-place - return xm.all_reduce(op, tensor, groups=group[1])[0] - else: - if op == "sum": - op = dist.ReduceOp.SUM - elif op == "max": - op = dist.ReduceOp.MAX - else: - raise NotImplementedError - dist.all_reduce(tensor, op=op, group=group) - return tensor - - -def broadcast(tensor, src, group): - if use_xla(): - # XLA doesn't support broadcast, hack it with all_reduce - if get_rank(group) != src: - tensor.zero_() - all_reduce(tensor, group) - else: - dist.broadcast(tensor, src=src, group=group) - - -def all_to_all(tensor, group): - """Perform an all-to-all operation on a 1D Tensor.""" - assert tensor.dim() == 1 - split_count = get_world_size(group=group) - assert tensor.numel() % split_count == 0 - if use_xla(): - assert isinstance(group, tuple) and group[0] == "tpu" - return xm.all_to_all( - tensor, - split_dimension=0, - concat_dimension=0, - split_count=split_count, - groups=group[1], - ) - else: - output = torch.zeros_like(tensor) - dist.all_to_all_single(output, tensor, group=group) - return output - - -def all_gather(tensor, group, return_tensor=False): - """Perform an all-gather operation.""" - if use_xla(): - result = xm.all_gather(tensor, groups=group[1]) - world_size = get_world_size(group=group) - result = result.view(world_size, *tensor.size()) - if return_tensor: - return result - else: - return [result[i] for i in range(world_size)] - else: - world_size = get_world_size(group=group) - rank = get_rank(group=group) - tensor_list = [ - tensor if i == rank else torch.empty_like(tensor) for i in range(world_size) - ] - dist.all_gather(tensor_list, tensor, group=group) - if return_tensor: - return torch.stack(tensor_list, dim=0) - else: - return tensor_list - - -def all_gather_list(data, group=None, max_size=16384): - """Gathers arbitrary data from all nodes into a list. - - Similar to :func:`~torch.distributed.all_gather` but for arbitrary Python - data. Note that *data* must be picklable and any CUDA tensors will be moved - to CPU and returned on CPU as well. - - Args: - data (Any): data from the local worker to be gathered on other workers - group: group of the collective - max_size (int, optional): maximum size of the data to be gathered - across workers - """ - from fairseq import utils - - if group is None: - group = get_global_group() - torch.distributed.barrier(group=group) - rank = get_rank(group=group) - world_size = get_world_size(group=group) - - buffer_size = max_size * world_size - if ( - not hasattr(all_gather_list, "_buffer") - or all_gather_list._buffer.numel() < buffer_size - ): - all_gather_list._buffer = torch.cuda.ByteTensor(buffer_size) - all_gather_list._cpu_buffer = torch.ByteTensor(max_size).pin_memory() - buffer = all_gather_list._buffer - buffer.zero_() - cpu_buffer = all_gather_list._cpu_buffer - - data = utils.move_to_cpu(data) - enc = pickle.dumps(data) - enc_size = len(enc) - header_size = 4 # size of header that contains the length of the encoded data - size = header_size + enc_size - if size > max_size: - raise ValueError( - "encoded data size ({}) exceeds max_size ({})".format(size, max_size) - ) - - header = struct.pack(">I", enc_size) - cpu_buffer[:size] = torch.ByteTensor(list(header + enc)) - start = rank * max_size - buffer[start : start + size].copy_(cpu_buffer[:size]) - - all_reduce(buffer, group=group) - - buffer = buffer.cpu() - try: - result = [] - for i in range(world_size): - out_buffer = buffer[i * max_size : (i + 1) * max_size] - (enc_size,) = struct.unpack(">I", bytes(out_buffer[:header_size].tolist())) - if enc_size > 0: - result.append( - pickle.loads( - bytes(out_buffer[header_size : header_size + enc_size].tolist()) - ) - ) - return result - except pickle.UnpicklingError: - raise Exception( - "Unable to unpickle data from other workers. all_gather_list requires all " - "workers to enter the function together, so this error usually indicates " - "that the workers have fallen out of sync somehow. Workers can fall out of " - "sync if one of them runs out of memory, or if there are other conditions " - "in your training script that can cause one worker to finish an epoch " - "while other workers are still iterating over their portions of the data. " - "Try rerunning with --ddp-backend=legacy_ddp and see if that helps." - ) - - -def all_reduce_dict(data: Mapping[str, Any], device, group) -> Dict[str, Any]: - """ - AllReduce a dictionary of values across workers. We separately - reduce items that are already on the device and items on CPU for - better performance. - - Args: - data (Mapping[str, Any]): dictionary of data to all-reduce, but - cannot be a nested dictionary - device (torch.device): device for the reduction - group: group of the collective - """ - data_keys = list(data.keys()) - - # We want to separately reduce items that are already on the - # device and items on CPU for performance reasons. - cpu_data = OrderedDict() - device_data = OrderedDict() - for k in data_keys: - t = data[k] - if not torch.is_tensor(t): - cpu_data[k] = torch.tensor(t, dtype=torch.double) - elif t.device.type != device.type: - cpu_data[k] = t.to(dtype=torch.double) - else: - device_data[k] = t.to(dtype=torch.double) - - def _all_reduce_dict(data: OrderedDict): - if len(data) == 0: - return data - buf = torch.cat([t.view(-1) for t in data.values()]).to(device=device) - all_reduce(buf, group=group) - split_buf = torch.split(buf, [t.numel() for t in data.values()]) - reduced_data = [t.view_as(orig) for t, orig in zip(split_buf, data.values())] - return OrderedDict(zip(data.keys(), reduced_data)) - - cpu_data = _all_reduce_dict(cpu_data) - device_data = _all_reduce_dict(device_data) - - def get_from_stack(key): - if key in cpu_data: - return cpu_data[key] - elif key in device_data: - return device_data[key] - raise KeyError - - return OrderedDict([(key, get_from_stack(key)) for key in data_keys]) - - -def broadcast_tensors( - tensors: Optional[List[torch.Tensor]], - src_rank: int, - group: object, - dist_device: Optional[torch.device] = None, -) -> List[torch.Tensor]: - """ - Broadcasts a list of tensors without other (non-src) ranks needing to know - the dtypes/shapes of the tensors. - """ - if dist_device is None: - if torch.distributed.get_backend(group) == "nccl": - dist_device = torch.device("cuda") - else: - dist_device = torch.device("cpu") - - # share metadata first to simplify transfer - is_src_rank = (get_rank(group) == src_rank) - if is_src_rank: - metadata = [ - {"size": t.size(), "dtype": t.dtype, "device": t.device} for t in tensors - ] - metadata = _broadcast_object_slow(metadata, src_rank, group, dist_device) - else: - metadata = _broadcast_object_slow(None, src_rank, group, dist_device) - - out_tensors = [] - for i, meta in enumerate(metadata): - if is_src_rank: - tensor = tensors[i] - broadcast(tensors[i].to(dist_device), src=src_rank, group=group) - else: - tensor = torch.zeros( - [meta["size"].numel()], dtype=meta["dtype"], device=dist_device - ) - broadcast(tensor, src=src_rank, group=group) - tensor = tensor.view(meta["size"]).to(meta["device"]) - out_tensors.append(tensor) - return out_tensors - - -def broadcast_object( - obj: Any, - src_rank: int, - group: object, - dist_device: Optional[torch.device] = None, -) -> Any: - """Broadcast an arbitrary Python object to other workers.""" - if dist_device is None: - if torch.distributed.get_backend(group) == "nccl": - dist_device = torch.device("cuda") - else: - dist_device = torch.device("cpu") - - if get_rank(group) == src_rank: - # split the tensors from the non-tensors so we can broadcast them - # directly, avoiding unnecessary serialization/deserialization - tensors = [] - obj = _split_tensors_from_obj(obj, tensors) - obj = _broadcast_object_slow(obj, src_rank, group, dist_device) - tensors = broadcast_tensors(tensors, src_rank, group, dist_device) - else: - obj = _broadcast_object_slow(None, src_rank, group, dist_device) - tensors = broadcast_tensors(None, src_rank, group, dist_device) - return _put_tensors_in_obj(obj, tensors) - - -def _broadcast_object_slow( - obj: Any, src_rank: int, group: object, dist_device: torch.device, -) -> Any: - if get_rank(group) == src_rank: - # Emit data - buffer = io.BytesIO() - torch.save(obj, buffer) - buffer = torch.ByteTensor(buffer.getbuffer()).to(dist_device) - length = torch.LongTensor([len(buffer)]).to(dist_device) - broadcast(length, src=src_rank, group=group) - broadcast(buffer, src=src_rank, group=group) - else: - # Fetch from the source - length = torch.LongTensor([0]).to(dist_device) - broadcast(length, src=src_rank, group=group) - buffer = torch.ByteTensor(int(length.item())).to(dist_device) - broadcast(buffer, src=src_rank, group=group) - buffer = io.BytesIO(buffer.cpu().numpy()) - obj = torch.load(buffer, map_location="cpu") - return obj - - -@dataclass(frozen=True) -class _TensorPlaceholder: - index: int - - -def _split_tensors_from_obj(obj: Any, tensors: List[torch.Tensor]) -> Any: - if torch.is_tensor(obj): - placeholder = _TensorPlaceholder(index=len(tensors)) - tensors.append(obj) - return placeholder - elif isinstance(obj, dict): - return {k: _split_tensors_from_obj(v, tensors) for k, v in obj.items()} - elif isinstance(obj, list): - return [_split_tensors_from_obj(v, tensors) for v in obj] - elif isinstance(obj, tuple): - return tuple(_split_tensors_from_obj(v, tensors) for v in obj) - elif isinstance(obj, set): - return {_split_tensors_from_obj(v, tensors) for v in obj} - else: - return obj - - -def _put_tensors_in_obj(obj: Any, tensors: List[torch.Tensor]) -> Any: - if isinstance(obj, _TensorPlaceholder): - return tensors[obj.index] - elif isinstance(obj, dict): - return {k: _put_tensors_in_obj(v, tensors) for k, v in obj.items()} - elif isinstance(obj, list): - return [_put_tensors_in_obj(v, tensors) for v in obj] - elif isinstance(obj, tuple): - return tuple(_put_tensors_in_obj(v, tensors) for v in obj) - elif isinstance(obj, set): - return {_put_tensors_in_obj(v, tensors) for v in obj} - else: - return obj diff --git a/spaces/Harveenchadha/oiTrans/indic_nlp_library/indicnlp/tokenize/__init__.py b/spaces/Harveenchadha/oiTrans/indic_nlp_library/indicnlp/tokenize/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/index.03f37f65.js b/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/index.03f37f65.js deleted file mode 100644 index 6688a54451dd7cc40d8682c8dc83d8e8a8a2bdf8..0000000000000000000000000000000000000000 --- a/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/index.03f37f65.js +++ /dev/null @@ -1,3744 +0,0 @@ -import{S as by,i as _y,s as wy,w as Fp,b as Aa,f as uf,g as zf,x as cu,n as cf,e as Gh,F as TG,J as FD,I as gA,O as AG,c as u0,m as c0,L as MG,j as Bh,k as jh,o as f0,K as Z4,ap as Cf,B as SG,D as EG,E as CG,a5 as OG,a6 as M5,M as bC,t as LG,h as PG,a as J4,P as DG,R as IG,T as zG,U as RG,V as FG}from"./index.396f4a72.js";import{c as Ro,a as Jx,g as NG}from"./_commonjsHelpers.88e99c8f.js";import{g as BG}from"./color.509e5f03.js";import{a as Vv,n as jG,b as UG,c as V2,t as b0,f as K4,p as VG,d as qG,e as HG,g as ND,h as $G,i as GG,j as Yo,k as Bm,l as WG,_ as BD,m as jD,x as YG,y as XG,o as Zh,R as q2,r as UD,q as mA,s as vA,C as yA,u as _C,v as wC,w as H2,z as Xp,A as Q4,B as zl,D as ky,E as ZG,F as JG,G as KG,H as QG,I as eW,J as tW,K as $2,L as nW,M as rW,N as iW,O as aW,P as kC,Q as jm,S as xA,T as G2,U as TC,V as Ed,W as W2,X as oW,Y as cp,Z as sW,$ as ek,a0 as lW,a1 as c_,a2 as uW}from"./linear.955f0731.js";import{d as cW}from"./dsv.7fe76a93.js";import{B as fW}from"./BlockLabel.37da86a3.js";function hW(t){let n,e,o,f,r,a,u;return{c(){n=Fp("svg"),e=Fp("circle"),o=Fp("circle"),f=Fp("circle"),r=Fp("circle"),a=Fp("circle"),u=Fp("path"),Aa(e,"cx","20"),Aa(e,"cy","4"),Aa(e,"r","2"),Aa(e,"fill","currentColor"),Aa(o,"cx","8"),Aa(o,"cy","16"),Aa(o,"r","2"),Aa(o,"fill","currentColor"),Aa(f,"cx","28"),Aa(f,"cy","12"),Aa(f,"r","2"),Aa(f,"fill","currentColor"),Aa(r,"cx","11"),Aa(r,"cy","7"),Aa(r,"r","2"),Aa(r,"fill","currentColor"),Aa(a,"cx","16"),Aa(a,"cy","24"),Aa(a,"r","2"),Aa(a,"fill","currentColor"),Aa(u,"fill","currentColor"),Aa(u,"d","M30 3.413L28.586 2L4 26.585V2H2v26a2 2 0 0 0 2 2h26v-2H5.413Z"),Aa(n,"xmlns","http://www.w3.org/2000/svg"),Aa(n,"xmlns:xlink","http://www.w3.org/1999/xlink"),Aa(n,"aria-hidden","true"),Aa(n,"role","img"),Aa(n,"class","iconify iconify--carbon"),Aa(n,"width","100%"),Aa(n,"height","100%"),Aa(n,"preserveAspectRatio","xMidYMid meet"),Aa(n,"viewBox","0 0 32 32")},m(c,i){uf(c,n,i),zf(n,e),zf(n,o),zf(n,f),zf(n,r),zf(n,a),zf(n,u)},p:cu,i:cu,o:cu,d(c){c&&cf(n)}}}class VD extends by{constructor(n){super(),_y(this,n,null,hW,wy,{})}}var qD={exports:{}};(function(t,n){(function(e){t.exports=e()})(function(){return function e(o,f,r){function a(i,s){if(!f[i]){if(!o[i]){var l=typeof Jx=="function"&&Jx;if(!s&&l)return l(i,!0);if(u)return u(i,!0);var d=new Error("Cannot find module '"+i+"'");throw d.code="MODULE_NOT_FOUND",d}var h=f[i]={exports:{}};o[i][0].call(h.exports,function(m){return a(o[i][1][m]||m)},h,h.exports,e,o,f,r)}return f[i].exports}for(var u=typeof Jx=="function"&&Jx,c=0;c "},i.prototype.compare=function(U,q,$,ne,H){if(Z(U,Uint8Array)&&(U=i.from(U,U.offset,U.byteLength)),!i.isBuffer(U))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof U);if(q===void 0&&(q=0),$===void 0&&($=U?U.length:0),ne===void 0&&(ne=0),H===void 0&&(H=this.length),q<0||$>U.length||ne<0||H>this.length)throw new RangeError("out of range index");if(ne>=H&&q>=$)return 0;if(ne>=H)return-1;if(q>=$)return 1;if(this===U)return 0;for(var Q=(H>>>=0)-(ne>>>=0),ee=($>>>=0)-(q>>>=0),ie=Math.min(Q,ee),ae=this.slice(ne,H),ue=U.slice(q,$),le=0;le