Update parquet files (step 20 of 249)

spaces/1phancelerku/anime-remove-background/Crossword Puzzle APK The Best App for Relaxing and Unwinding with Crosswords.md

@@ -1,80 +0,0 @@
-
-<h1>Crossword Puzzle APK: A Fun and Challenging Game for Your Brain</h1>
-<p>Do you love word games? Do you enjoy solving puzzles and learning new things? If you answered yes, then you should try playing crossword puzzle apk. This is an app that lets you play crossword puzzles on your Android device. Whether you are a beginner or an expert, you will find crossword puzzles that suit your level and interest. In this article, we will tell you what a crossword puzzle apk is, why you should play it, how to play it, and what are some of its features.</p>
-<h2>cross word puzzle apk</h2><br /><p><b><b>Download File</b> &#9989; <a href="https://jinyurl.com/2uNLFK">https://jinyurl.com/2uNLFK</a></b></p><br /><br />
-<h2>What is a crossword puzzle apk?</h2>
-<h3>An apk file is a format for installing applications on Android devices</h3>
-<p>An apk file is short for Android Package Kit. It is a file format that contains all the elements needed to install an application on an Android device. You can download apk files from various sources, such as websites, app stores, or file-sharing platforms. However, you should be careful about the source of the apk file, as some may contain malware or viruses that can harm your device. You should only download apk files from trusted and reputable sources.</p>
-<h3>A crossword puzzle is a word game that involves filling in a grid with words that match the clues</h3>
-<p>A crossword puzzle is one of the most popular word games in the world. It consists of a grid of white and black squares, where some of the white squares form horizontal or vertical words. The words are determined by the clues given at the side or bottom of the grid. The clues are usually in the form of definitions, synonyms, antonyms, or wordplay. The goal of the game is to fill in all the white squares with letters that form valid words.</p>
-<h3>A crossword puzzle apk is an app that lets you play crossword puzzles on your phone or tablet</h3>
-<p>A crossword puzzle apk is an application that you can install on your Android device using an apk file. It allows you to play crossword puzzles on your phone or tablet anytime and anywhere. You can choose from hundreds of crossword puzzles in different categories and difficulties, or you can create your own puzzles using the app's editor. You can also customize the app's settings and themes to suit your preferences.</p>
-<h2>Why should you play crossword puzzle apk?</h2>
-<h3>Crossword puzzles are good for your brain health and cognitive skills</h3>
-<p>Playing crossword puzzles can benefit your brain in many ways. According to research, crossword puzzles can improve your memory, vocabulary, spelling, logic, reasoning, problem-solving, and general knowledge. They can also prevent cognitive decline and dementia by keeping your brain active and stimulated. Crossword puzzles can also reduce stress and improve your mood by providing a sense of accomplishment and satisfaction.</p>
-<h3>Crossword puzzles are fun and entertaining for all ages and levels</h3>
-<p>Playing crossword puzzles can also be a lot of fun and entertainment. You can challenge yourself with the check button on the top right corner of the screen. The app will highlight any incorrect or incomplete words in red. You can also reveal the solution by tapping on the reveal button on the top left corner of the screen. The app will show you the complete and correct grid. However, this will end your game and you will not get any points or achievements.</p>
-<h2>What are some features of crossword puzzle apk?</h2>
-<h3>Hundreds of crossword puzzles in different categories and difficulties</h3>
-<p>One of the main features of crossword puzzle apk is that it has hundreds of crossword puzzles in different categories and difficulties. You can choose from various themes and topics, such as sports, movies, history, science, and more. You can also select the level of difficulty that suits your skill and interest, such as easy, medium, hard, or expert. You will never run out of crossword puzzles to play with this app.</p>
-<h3>Customizable settings and themes to suit your preferences</h3>
-<p>Another feature of crossword puzzle apk is that it has customizable settings and themes to suit your preferences. You can change the font size, color, and style of the clues and words. You can also change the background color and image of the grid. You can choose from various themes, such as classic, modern, wood, paper, or dark. You can also adjust the sound effects and music volume of the app.</p>
-<h3>Offline mode and cloud sync to play anytime and anywhere</h3>
-<p>A third feature of crossword puzzle apk is that it has offline mode and cloud sync to play anytime and anywhere. You can play crossword puzzles without an internet connection by downloading them to your device. You can also sync your progress and achievements to the cloud by signing in with your Google account. This way, you can access your crossword puzzles on any device and resume your game from where you left off.</p>
-<p>cross word puzzle game apk download<br />
-cross word puzzle app for android free<br />
-best cross word puzzle apk offline<br />
-cross word puzzle solver apk mod<br />
-cross word puzzle maker apk pro<br />
-cross word puzzle apk with hints and clues<br />
-cross word puzzle generator apk online<br />
-cross word puzzle editor apk full version<br />
-cross word puzzle apk for kids and adults<br />
-cross word puzzle creator apk premium<br />
-cross word puzzle apk with daily challenges<br />
-cross word puzzle app for android tablet<br />
-cross word puzzle apk no ads and in-app purchases<br />
-cross word puzzle builder apk cracked<br />
-cross word puzzle apk with custom themes<br />
-cross word puzzle designer apk unlocked<br />
-cross word puzzle apk with voice input and output<br />
-cross word puzzle app for android tv<br />
-cross word puzzle apk no internet required<br />
-cross word puzzle filler apk latest version<br />
-cross word puzzle apk with different languages<br />
-cross word puzzle app for android wear<br />
-cross word puzzle apk with crossword dictionary<br />
-cross word puzzle formatter apk updated<br />
-cross word puzzle apk with multiple levels of difficulty<br />
-cross word puzzle app for android auto<br />
-cross word puzzle apk with synonyms and antonyms<br />
-cross word puzzle grader apk new<br />
-cross word puzzle apk with timer and score<br />
-cross word puzzle app for android box<br />
-cross word puzzle apk with anagrams and acronyms<br />
-cross word puzzle helper apk old version<br />
-cross word puzzle apk with images and emojis<br />
-cross word puzzle app for android phone<br />
-cross word puzzle apk with trivia and facts<br />
-cross word puzzle instructor apk beta version<br />
-cross word puzzle apk with categories and topics<br />
-cross word puzzle app for android emulator<br />
-cross word puzzle apk with hints and answers<br />
-cross word puzzle learner apk alpha version</p>
-<h3>Leaderboards and achievements to track your progress and compete with others</h3>
-<p>A fourth feature of crossword puzzle apk is that it has leaderboards and achievements to track your progress and compete with others. You can earn points and stars for completing crossword puzzles and unlocking new levels. You can also earn achievements for reaching certain milestones or completing certain challenges. You can view your rank and score on the global or local leaderboards, and compare them with other players around the world or in your area.</p>
-<h2>Conclusion</h2>
-<p>Crossword puzzle apk is a fun and challenging game for your brain. It lets you play crossword puzzles on your Android device using an apk file. It has many benefits for your brain health and cognitive skills, as well as for your fun and entertainment. It also has many features that make it convenient and accessible, such as hundreds of crossword puzzles in different categories and difficulties, customizable settings and themes, offline mode and cloud sync, and leaderboards and achievements. If you love word games and puzzles, you should definitely try playing crossword puzzle apk. You will not regret it!</p>
-<h2>FAQs</h2>
-<h3>What is the best source to download crossword puzzle apk?</h3>
-<p>There are many sources to download crossword puzzle apk, but not all of them are safe and reliable. You should only download apk files from trusted and reputable sources, such as official websites, app stores, or file-sharing platforms. You should also check the reviews and ratings of the apk files before downloading them.</p>
-<h3>How can I create my own crossword puzzle using the app?</h3>
-<p>You can create your own crossword puzzle using the app's editor. You can choose the size of the grid, the theme of the puzzle, and the clues and words that you want to use. You can also save your puzzle and share it with others. To access the editor, you need to tap on the menu button on the top left corner of the screen, and then tap on "Create Puzzle".</p>
-<h3>How can I change the theme of the app?</h3>
-<p>You can change the theme of the app by tapping on the settings button on the top right corner of the screen, and then tapping on "Theme". You can choose from various themes, such as classic, modern, wood, paper, or dark. You can also change the background color and image of the grid.</p>
-<h3>How can I play offline or sync my progress to the cloud?</h3>
-<p>You can play offline by downloading the puzzles to your device. You can also sync your progress and achievements to the cloud by signing in with your Google account. To do either of these, you need to tap on the menu button on the top left corner of the screen, and then tap on "Offline Mode" or "Cloud Sync".</p>
-<h3>How can I compete with other players online?</h3>
-<p>You can compete with other players online by viewing your rank and score on the global or local leaderboards. You can also earn achievements for reaching certain milestones or completing certain challenges. To access these features, you need to tap on the menu button on the top left corner of the screen, and then tap on "Leaderboards" or "Achievements".</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/pipelines/vq_diffusion/pipeline_vq_diffusion.py

@@ -1,346 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 Microsoft and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import Callable, List, Optional, Tuple, Union
-
-import paddle
-import paddle.nn as nn
-
-from paddlenlp.transformers import CLIPTextModel, CLIPTokenizer
-
-from ...configuration_utils import ConfigMixin, register_to_config
-from ...modeling_utils import ModelMixin
-from ...models import Transformer2DModel, VQModel
-from ...pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-from ...schedulers import VQDiffusionScheduler
-from ...utils import logging
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-INF = 1e9
-
-
-# paddle logsumexp may has bug
-def logsumexp(x, axis=None, keepdim=False):
-    return paddle.log(x.exp().sum(axis=axis, keepdim=keepdim))
-
-
-class LearnedClassifierFreeSamplingEmbeddings(ModelMixin, ConfigMixin):
-    """
-    Utility class for storing learned text embeddings for classifier free sampling
-    """
-
-    @register_to_config
-    def __init__(self, learnable: bool, hidden_size: Optional[int] = None, length: Optional[int] = None):
-        super().__init__()
-
-        self.learnable = learnable
-
-        if self.learnable:
-            assert hidden_size is not None, "learnable=True requires `hidden_size` to be set"
-            assert length is not None, "learnable=True requires `length` to be set"
-
-            embeddings = paddle.zeros([length, hidden_size])
-            self.embeddings = self.create_parameter(
-                embeddings.shape, default_initializer=nn.initializer.Assign(embeddings)
-            )
-        else:
-            self.embeddings = None
-
-
-class VQDiffusionPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for text-to-image generation using VQ Diffusion
-
-    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:
-        vqvae ([`VQModel`]):
-            Vector Quantized Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent
-            representations.
-        text_encoder ([`CLIPTextModel`]):
-            Frozen text-encoder. VQ Diffusion uses the text portion of
-            [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
-            the [clip-vit-base-patch32](https://huggingface.co/openai/clip-vit-base-patch32) variant.
-        tokenizer (`CLIPTokenizer`):
-            Tokenizer of class
-            [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
-        transformer ([`Transformer2DModel`]):
-            Conditional transformer to denoise the encoded image latents.
-        scheduler ([`VQDiffusionScheduler`]):
-            A scheduler to be used in combination with `transformer` to denoise the encoded image latents.
-    """
-
-    vqvae: VQModel
-    text_encoder: CLIPTextModel
-    tokenizer: CLIPTokenizer
-    transformer: Transformer2DModel
-    learned_classifier_free_sampling_embeddings: LearnedClassifierFreeSamplingEmbeddings
-    scheduler: VQDiffusionScheduler
-
-    def __init__(
-        self,
-        vqvae: VQModel,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        transformer: Transformer2DModel,
-        scheduler: VQDiffusionScheduler,
-        learned_classifier_free_sampling_embeddings: LearnedClassifierFreeSamplingEmbeddings,
-    ):
-        super().__init__()
-
-        self.register_modules(
-            vqvae=vqvae,
-            transformer=transformer,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            scheduler=scheduler,
-            learned_classifier_free_sampling_embeddings=learned_classifier_free_sampling_embeddings,
-        )
-
-    def _encode_prompt(self, prompt, num_images_per_prompt, do_classifier_free_guidance):
-        batch_size = len(prompt) if isinstance(prompt, list) else 1
-
-        # get prompt text embeddings
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            return_tensors="pd",
-        )
-        text_input_ids = text_inputs.input_ids
-
-        if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
-            removed_text = self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :])
-            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}"
-            )
-            text_input_ids = text_input_ids[:, : self.tokenizer.model_max_length]
-        text_embeddings = self.text_encoder(text_input_ids)[0]
-
-        # NOTE: This additional step of normalizing the text embeddings is from VQ-Diffusion.
-        # While CLIP does normalize the pooled output of the text transformer when combining
-        # the image and text embeddings, CLIP does not directly normalize the last hidden state.
-        #
-        # CLIP normalizing the pooled output.
-        # https://github.com/huggingface/transformers/blob/d92e22d1f28324f513f3080e5c47c071a3916721/src/transformers/models/clip/modeling_clip.py#L1052-L1053
-        text_embeddings = text_embeddings / text_embeddings.norm(axis=-1, keepdim=True)
-
-        # 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])
-
-        if do_classifier_free_guidance:
-            if self.learned_classifier_free_sampling_embeddings.learnable:
-                uncond_embeddings = self.learned_classifier_free_sampling_embeddings.embeddings
-                uncond_embeddings = uncond_embeddings.unsqueeze(0).tile([batch_size, 1, 1])
-            else:
-                uncond_tokens = [""] * batch_size
-
-                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",
-                )
-                uncond_embeddings = self.text_encoder(uncond_input.input_ids)[0]
-                # See comment for normalizing text embeddings
-                uncond_embeddings = uncond_embeddings / uncond_embeddings.norm(axis=-1, keepdim=True)
-
-            # 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
-
-    @paddle.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        num_inference_steps: int = 100,
-        guidance_scale: float = 5.0,
-        truncation_rate: float = 1.0,
-        num_images_per_prompt: int = 1,
-        generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None,
-        latents: Optional[paddle.Tensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, paddle.Tensor], None]] = None,
-        callback_steps: Optional[int] = 1,
-    ) -> Union[ImagePipelineOutput, Tuple]:
-        """
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`):
-                The prompt or prompts to guide the image generation.
-            num_inference_steps (`int`, *optional*, defaults to 100):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            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.
-            truncation_rate (`float`, *optional*, defaults to 1.0 (equivalent to no truncation)):
-                Used to "truncate" the predicted classes for x_0 such that the cumulative probability for a pixel is at
-                most `truncation_rate`. The lowest probabilities that would increase the cumulative probability above
-                `truncation_rate` are set to zero.
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            generator (`paddle.Generator`, *optional*):
-                One or a list of paddle generator(s) to make generation deterministic.
-            latents (`paddle.Tensor` of shape (batch), *optional*):
-                Pre-generated noisy latents to be used as inputs for image generation. Must be valid embedding indices.
-                Can be used to tweak the same generation with different prompts. If not provided, a latents tensor will
-                be generated of completely masked latent pixels.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generated 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 [`~pipeline_utils.ImagePipelineOutput`] 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:
-            [`~pipeline_utils.ImagePipelineOutput`] or `tuple`: [`~ pipeline_utils.ImagePipelineOutput `] if
-            `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the
-            generated images.
-        """
-        if isinstance(prompt, str):
-            batch_size = 1
-        elif isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        batch_size = batch_size * num_images_per_prompt
-
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        text_embeddings = self._encode_prompt(prompt, num_images_per_prompt, do_classifier_free_guidance)
-
-        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)}."
-            )
-
-        # get the initial completely masked latents unless the user supplied it
-
-        latents_shape = [batch_size, self.transformer.num_latent_pixels]
-        if latents is None:
-            mask_class = self.transformer.num_vector_embeds - 1
-            latents = paddle.full(latents_shape, mask_class, dtype="int64")
-        else:
-            if latents.shape != latents_shape:
-                raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}")
-            if (latents < 0).any() or (latents >= self.transformer.num_vector_embeds).any():
-                raise ValueError(
-                    "Unexpected latents value(s). All latents be valid embedding indices i.e. in the range 0,"
-                    f" {self.transformer.num_vector_embeds - 1} (inclusive)."
-                )
-
-        # set timesteps
-        self.scheduler.set_timesteps(num_inference_steps)
-
-        timesteps_tensor = self.scheduler.timesteps
-
-        sample = latents
-
-        for i, t in enumerate(self.progress_bar(timesteps_tensor)):
-            # expand the sample if we are doing classifier free guidance
-            latent_model_input = paddle.concat([sample] * 2) if do_classifier_free_guidance else sample
-
-            # predict the un-noised image
-            # model_output == `log_p_x_0`
-            model_output = self.transformer(
-                latent_model_input, encoder_hidden_states=text_embeddings, timestep=t
-            ).sample
-
-            if do_classifier_free_guidance:
-                model_output_uncond, model_output_text = model_output.chunk(2)
-                model_output = model_output_uncond + guidance_scale * (model_output_text - model_output_uncond)
-                model_output -= logsumexp(model_output, axis=1, keepdim=True)
-
-            model_output = self.truncate(model_output, truncation_rate)
-
-            # remove `log(0)`'s (`-inf`s)
-            model_output = model_output.clip(-70)
-
-            # compute the previous noisy sample x_t -> x_t-1
-            sample = self.scheduler.step(model_output, timestep=t, sample=sample, generator=generator).prev_sample
-
-            # call the callback, if provided
-            if callback is not None and i % callback_steps == 0:
-                callback(i, t, sample)
-
-        embedding_channels = self.vqvae.config.vq_embed_dim
-        embeddings_shape = (batch_size, self.transformer.height, self.transformer.width, embedding_channels)
-        embeddings = self.vqvae.quantize.get_codebook_entry(sample, shape=embeddings_shape)
-        image = self.vqvae.decode(embeddings, force_not_quantize=True).sample
-
-        image = (image / 2 + 0.5).clip(0, 1)
-        image = image.transpose([0, 2, 3, 1]).cast("float32").numpy()
-
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        if not return_dict:
-            return (image,)
-
-        return ImagePipelineOutput(images=image)
-
-    def truncate(self, log_p_x_0: paddle.Tensor, truncation_rate: float) -> paddle.Tensor:
-        """
-        Truncates log_p_x_0 such that for each column vector, the total cumulative probability is `truncation_rate` The
-        lowest probabilities that would increase the cumulative probability above `truncation_rate` are set to zero.
-        """
-        sorted_log_p_x_0, indices = paddle.topk(log_p_x_0, k=log_p_x_0.shape[1], axis=1)
-        sorted_p_x_0 = paddle.exp(sorted_log_p_x_0)
-        keep_mask = (sorted_p_x_0.cumsum(axis=1) < truncation_rate).cast("int64")
-
-        # Ensure that at least the largest probability is not zeroed out
-        all_true = paddle.full_like(keep_mask[:, 0:1, :], 1)
-        keep_mask = paddle.concat((all_true, keep_mask), axis=1)
-        keep_mask = keep_mask[:, :-1, :]
-
-        keep_mask = paddle.take_along_axis(keep_mask, indices.argsort(1), axis=1).cast(
-            "bool"
-        )  # keep_mask.gather(indices.argsort(1), axis=1)
-
-        rv = log_p_x_0.clone()
-        # rv[~keep_mask] = -INF  # -inf = log(0)
-        rv = paddle.where(keep_mask, rv, paddle.to_tensor(-INF, dtype="float32"))
-
-        return rv

spaces/44ov41za8i/FreeVC/app.py

@@ -1,103 +0,0 @@
-import os
-import torch
-import librosa
-import gradio as gr
-from scipy.io.wavfile import write
-from transformers import WavLMModel
-
-import utils
-from models import SynthesizerTrn
-from mel_processing import mel_spectrogram_torch
-from speaker_encoder.voice_encoder import SpeakerEncoder
-
-'''
-def get_wavlm():
-    os.system('gdown https://drive.google.com/uc?id=12-cB34qCTvByWT-QtOcZaqwwO21FLSqU')
-    shutil.move('WavLM-Large.pt', 'wavlm')
-'''
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-print("Loading FreeVC...")
-hps = utils.get_hparams_from_file("configs/freevc.json")
-freevc = SynthesizerTrn(
-    hps.data.filter_length // 2 + 1,
-    hps.train.segment_size // hps.data.hop_length,
-    **hps.model).to(device)
-_ = freevc.eval()
-_ = utils.load_checkpoint("checkpoints/freevc.pth", freevc, None)
-smodel = SpeakerEncoder('speaker_encoder/ckpt/pretrained_bak_5805000.pt')
-
-print("Loading FreeVC(24k)...")
-hps = utils.get_hparams_from_file("configs/freevc-24.json")
-freevc_24 = SynthesizerTrn(
-    hps.data.filter_length // 2 + 1,
-    hps.train.segment_size // hps.data.hop_length,
-    **hps.model).to(device)
-_ = freevc_24.eval()
-_ = utils.load_checkpoint("checkpoints/freevc-24.pth", freevc_24, None)
-
-print("Loading FreeVC-s...")
-hps = utils.get_hparams_from_file("configs/freevc-s.json")
-freevc_s = SynthesizerTrn(
-    hps.data.filter_length // 2 + 1,
-    hps.train.segment_size // hps.data.hop_length,
-    **hps.model).to(device)
-_ = freevc_s.eval()
-_ = utils.load_checkpoint("checkpoints/freevc-s.pth", freevc_s, None)
-
-print("Loading WavLM for content...")
-cmodel = WavLMModel.from_pretrained("microsoft/wavlm-large").to(device)
- 
-def convert(model, src, tgt):
-    with torch.no_grad():
-        # tgt
-        wav_tgt, _ = librosa.load(tgt, sr=hps.data.sampling_rate)
-        wav_tgt, _ = librosa.effects.trim(wav_tgt, top_db=20)
-        if model == "FreeVC" or model == "FreeVC (24kHz)":
-            g_tgt = smodel.embed_utterance(wav_tgt)
-            g_tgt = torch.from_numpy(g_tgt).unsqueeze(0).to(device)
-        else:
-            wav_tgt = torch.from_numpy(wav_tgt).unsqueeze(0).to(device)
-            mel_tgt = mel_spectrogram_torch(
-                wav_tgt, 
-                hps.data.filter_length,
-                hps.data.n_mel_channels,
-                hps.data.sampling_rate,
-                hps.data.hop_length,
-                hps.data.win_length,
-                hps.data.mel_fmin,
-                hps.data.mel_fmax
-            )
-        # src
-        wav_src, _ = librosa.load(src, sr=hps.data.sampling_rate)
-        wav_src = torch.from_numpy(wav_src).unsqueeze(0).to(device)
-        c = cmodel(wav_src).last_hidden_state.transpose(1, 2).to(device)
-        # infer
-        if model == "FreeVC":
-            audio = freevc.infer(c, g=g_tgt)
-        elif model == "FreeVC-s":
-            audio = freevc_s.infer(c, mel=mel_tgt)
-        else:
-            audio = freevc_24.infer(c, g=g_tgt)
-        audio = audio[0][0].data.cpu().float().numpy()
-        if model == "FreeVC" or model == "FreeVC-s":
-            write("out.wav", hps.data.sampling_rate, audio)
-        else:
-            write("out.wav", 24000, audio)
-    out = "out.wav"
-    return out
-    
-model = gr.Dropdown(choices=["FreeVC", "FreeVC-s", "FreeVC (24kHz)"], value="FreeVC",type="value", label="Model") 
-audio1 = gr.inputs.Audio(label="Source Audio", type='filepath')
-audio2 = gr.inputs.Audio(label="Reference Audio", type='filepath')
-inputs = [model, audio1, audio2]
-outputs =  gr.outputs.Audio(label="Output Audio", type='filepath')
-
-title = "FreeVC"
-description = "Gradio Demo for FreeVC: Towards High-Quality Text-Free One-Shot Voice Conversion. To use it, simply upload your audio, or click the example to load. Read more at the links below. Note: It seems that the WavLM checkpoint in HuggingFace is a little different from the one used to train FreeVC, which may degrade the performance a bit. In addition, speaker similarity can be largely affected if there are too much silence in the reference audio, so please <strong>trim</strong> it before submitting."
-article = "<p style='text-align: center'><a href='https://arxiv.org/abs/2210.15418' target='_blank'>Paper</a> | <a href='https://github.com/OlaWod/FreeVC' target='_blank'>Github Repo</a></p>"
-
-examples=[["FreeVC", 'p225_001.wav', 'p226_002.wav'], ["FreeVC-s", 'p226_002.wav', 'p225_001.wav'], ["FreeVC (24kHz)", 'p225_001.wav', 'p226_002.wav']]
-
-gr.Interface(convert, inputs, outputs, title=title, description=description, article=article, examples=examples, enable_queue=True).launch()

spaces/801artistry/RVC801/lib/uvr5_pack/lib_v5/model_param_init.py

@@ -1,69 +0,0 @@
-import json
-import os
-import pathlib
-
-default_param = {}
-default_param["bins"] = 768
-default_param["unstable_bins"] = 9  # training only
-default_param["reduction_bins"] = 762  # training only
-default_param["sr"] = 44100
-default_param["pre_filter_start"] = 757
-default_param["pre_filter_stop"] = 768
-default_param["band"] = {}
-
-
-default_param["band"][1] = {
-    "sr": 11025,
-    "hl": 128,
-    "n_fft": 960,
-    "crop_start": 0,
-    "crop_stop": 245,
-    "lpf_start": 61,  # inference only
-    "res_type": "polyphase",
-}
-
-default_param["band"][2] = {
-    "sr": 44100,
-    "hl": 512,
-    "n_fft": 1536,
-    "crop_start": 24,
-    "crop_stop": 547,
-    "hpf_start": 81,  # inference only
-    "res_type": "sinc_best",
-}
-
-
-def int_keys(d):
-    r = {}
-    for k, v in d:
-        if k.isdigit():
-            k = int(k)
-        r[k] = v
-    return r
-
-
-class ModelParameters(object):
-    def __init__(self, config_path=""):
-        if ".pth" == pathlib.Path(config_path).suffix:
-            import zipfile
-
-            with zipfile.ZipFile(config_path, "r") as zip:
-                self.param = json.loads(
-                    zip.read("param.json"), object_pairs_hook=int_keys
-                )
-        elif ".json" == pathlib.Path(config_path).suffix:
-            with open(config_path, "r") as f:
-                self.param = json.loads(f.read(), object_pairs_hook=int_keys)
-        else:
-            self.param = default_param
-
-        for k in [
-            "mid_side",
-            "mid_side_b",
-            "mid_side_b2",
-            "stereo_w",
-            "stereo_n",
-            "reverse",
-        ]:
-            if not k in self.param:
-                self.param[k] = False

spaces/AI-Dashboards/CP.Matplotlib.NetworkX.Streamlit.PyVis.Graphviz/app.py

@@ -1,267 +0,0 @@
-import streamlit as st
-import streamlit.components.v1 as components
-import networkx as nx
-import matplotlib.pyplot as plt
-from pyvis.network import Network
-import got 
-import numpy as np
-import pandas as pd
-import time
-import re
-import graphviz as graphviz
-import pydeck as pdk
-
-from st_click_detector import click_detector
-
-st.graphviz_chart('''
-    digraph {
-Income ->  AbleToBuyOnlyNecessities
-Income ->  DifficultyBuyingNecessities
-Income ->  DifficultyWithMoneyManagement
-Income ->  LowNoIncome
-Income ->  UninsuredMedicalExpenses
-            }
-''')
-
-st.graphviz_chart('''
-    digraph {
-Income ->  Continuityof  ->  Care
-Income ->  Durable  ->  Medical  ->  Equipment
-Income ->  Finances
-Income ->  LegalSystem
-Income ->  Medical  ->  Dental  ->  Care
-Income ->  Medication  ->  Coordination  ->  Ordering
-Income ->  Other  ->  Community  ->  Resources
-Income ->  SocialWork  ->  Counseling  ->  Care
-Income ->  Supplies
-            }
-''')
-
-st.graphviz_chart('''
-    digraph {
-MentalHealth ->  Apprehension  ->  Undefined  ->  Fear  ->  Anxious
-MentalHealth ->  Attempts  ->  Suicide  ->  Homicide
-MentalHealth ->  Difficulty  ->  Managing  ->  Anger
-MentalHealth ->  Difficulty  ->  Managing  ->  Stress
-MentalHealth ->  Expresses  ->  Suicidal  ->  Homicidal  ->  Thoughts
-MentalHealth ->  False  ->  Beliefs  ->  Delusions
-MentalHealth ->  False  ->  Perceptions  ->  Hallucinations  ->  Illusions
-MentalHealth ->  FlatAffect  ->  LackofEmotion
-MentalHealth ->  Irritable  ->  Agitated  ->  Aggressive
-MentalHealth ->  LossofInterest  ->  Involvementin  ->  ActivitiesSelfCare
-MentalHealth ->  MoodSwings
-MentalHealth ->  Narrowedto  ->  Scattered  ->  Attention  ->  Focus
-MentalHealth ->  Purposeless  ->  Compulsive  ->  RepetitiveActivity
-MentalHealth ->  Sadness  ->  Hopelessness  ->  Decreased  ->  SelfEsteem
-MentalHealth ->  Somatic  ->  Complaints  ->  Fatigue
-            }
-''')
-
-st.graphviz_chart('''
-    digraph {
-MentalHealth ->  Anger  ->  Management
-MentalHealth ->  Behavioral  ->  Health  ->  Care
-MentalHealth ->  Communication
-MentalHealth ->  Continuityof  ->  Care
-MentalHealth ->  Coping  ->  Skills
-MentalHealth ->  Dietary  ->  Management
-MentalHealth ->  Discipline
-MentalHealth ->  EndofLife  ->  Care
-MentalHealth ->  Interaction
-MentalHealth ->  LegalSystem
-MentalHealth ->  Medical  ->  Dental  ->  Care
-MentalHealth ->  Medication  ->  ActionSideEffects
-MentalHealth ->  Medication  ->  Administration
-MentalHealth ->  Medication  ->  CoordinationOrdering
-MentalHealth ->  Nursing  ->  Care
-MentalHealth ->  Nutritionist  ->  Care
-MentalHealth ->  Other  ->  Community  ->  Resources
-MentalHealth ->  Relaxation  ->  Breathing  ->  Techniques
-MentalHealth ->  Rest  ->  Sleep
-MentalHealth ->  Safety
-MentalHealth ->  Screening  ->  Procedures
-MentalHealth ->  SignsSymptoms  ->  MentalEmotional
-MentalHealth ->  SignsSymptoms  ->  Physical
-MentalHealth ->  SocialWork  ->  Counseling  ->  Care
-MentalHealth ->  Stress  ->  Management
-MentalHealth ->  Support  ->  Group
-MentalHealth ->  Support  ->  System
-MentalHealth ->  Wellness
-            }
-''')
-
-
-st.graphviz_chart('''
-    digraph {
-Respiration ->  Abnormal  ->  BreathSoundsCrackles
-Respiration ->  Abnormal  ->  IrregularBreathPatterns
-Respiration ->  Abnormal  ->  RespiratoryLaboratoryResults
-Respiration ->  Abnormal  ->  Sputum
-Respiration ->  Cough
-Respiration ->  Noisy  ->  RespirationswheezingRalesRhonchi
-Respiration ->  Rhinorrhea  ->  NasalCongestion
-Respiration ->  UnabletoBreathe  ->  Independently
-            }
-''')
-
-st.graphviz_chart('''
-    digraph {
-Respiration ->  Anatomy  ->  Physiology
-Respiration ->  Continuityof  ->  Care
-Respiration ->  Coping  ->  Skills
-Respiration ->  Dietary  ->  Management
-Respiration ->  Durable  ->  Medical  ->  Equipment
-Respiration ->  Education
-Respiration ->  EndofLife  ->  Care
-Respiration ->  Environment
-Respiration ->  Exercises
-Respiration ->  Infection  ->  Precautions
-Respiration ->  Laboratory  ->  Findings
-Respiration ->  Medical  ->  Dental  ->  Care
-Respiration ->  Medication  ->  Action  ->  SideEffects
-Respiration ->  Medication  ->  Administration
-Respiration ->  Medication  ->  Prescription
-Respiration ->  Medication  ->  SetUp
-Respiration ->  Mobility  ->  Transfers
-Respiration ->  Nursing  ->  Care
-Respiration ->  Positioning
-Respiration ->  Relaxation  ->  Breathing  ->  Techniques
-Respiration ->  Respiratory  ->  Care
-Respiration ->  Respiratory  ->  Therapy  ->  Care
-Respiration ->  Safety
-Respiration ->  Screening  ->  Procedures
-Respiration ->  SignsSymptoms  ->  MentalEmotional
-Respiration ->  SignsSymptoms  ->  Physical
-Respiration ->  Specimen  ->  Collection
-Respiration ->  Supplies
-Respiration ->  Support  ->  Group
-Respiration ->  Support  ->  System
-Respiration ->  Wellness
-            }
-''')
-
-
-st.graphviz_chart('''
-    digraph {
-Circulation ->  Abnormal  ->  BloodPressureReading
-Circulation ->  Abnormal  ->  CardiacLaboratoryResults
-Circulation ->  Abnormal  ->  Clotting
-Circulation ->  Abnormal  ->  HeartSoundsMurmurs
-Circulation ->  Anginal  ->  Pain
-Circulation ->  Cramping  ->  Pain  ->  ofExtremities
-Circulation ->  Decreased  ->  Pulses
-Circulation ->  Discoloration  ->  ofSkinCyanosis
-Circulation ->  EdemaSwelling  ->  inlegsarmsfeet
-Circulation ->  ExcessivelyRapid  ->  HeartRate
-Circulation ->  IrregularHeartRate
-Circulation ->  SyncopalEpisodes  ->  Fainting  ->  Dizziness
-Circulation ->  TemperatureChange  ->  inAffectedArea
-Circulation ->  Varicosities
-            }
-''')
-
-st.graphviz_chart('''
-    digraph {
-Circulation ->  Anatomy  ->  Physiology
-Circulation ->  Cardiac  ->  Care
-Circulation ->  Continuityof  ->  Care
-Circulation ->  Coping  ->  Skills
-Circulation ->  Dietary  ->  Management
-Circulation ->  Durable  ->  Medical  ->  Equipment
-Circulation ->  Exercises
-Circulation ->  Finances
-Circulation ->  Infection  ->  Precautions
-Circulation ->  Laboratory  ->  Findings
-Circulation ->  Medical  ->  Dental  ->  Care
-Circulation ->  Medication  ->  Action  ->  SideEffects
-Circulation ->  Medication  ->  Administration
-Circulation ->  Medication  ->  SetUp
-Circulation ->  Mobility  ->  Transfers
-Circulation ->  Nursing  ->  Care
-Circulation ->  Personal  ->  Hygiene
-Circulation ->  Relaxation  ->  Breathing  ->  Techniques
-Circulation ->  Safety
-Circulation ->  Screening  ->  Procedures
-Circulation ->  SignsSymptoms  ->  MentalEmotional
-Circulation ->  SignsSymptoms  ->  Physical
-Circulation ->  Support  ->  Group
-Circulation ->  Support  ->  System
-Circulation ->  Wellness
-            }
-''')
-
-df = pd.read_csv("testfile.csv")
-@st.cache
-def convert_df(df):
-   return df.to_csv().encode('utf-8')
-csv = convert_df(df)
-st.download_button(
-   "Press to Download",
-   csv,
-   "testfile.csv",
-   "text/csv",
-   key='download-csv'
-)
-
-
-st.title('Streamlit Visualization')
-dataframe = pd.DataFrame(np.random.randn(10, 20),
-  columns = ('col %d' % i
-    for i in range(20)))
-st.write(dataframe)
-
-dataframe = pd.DataFrame(np.random.randn(10, 5),
-  columns = ('col %d' % i
-    for i in range(5)))
-dataframe
-st.write('This is a line_chart.')
-st.line_chart(dataframe)
-
-st.write('This is a area_chart.')
-st.area_chart(dataframe)
-
-st.write('This is a bar_chart.')
-st.bar_chart(dataframe)
-
-st.write('Map data')
-data_of_map = pd.DataFrame(
-  np.random.randn(1000, 2) / [60, 60] + [36.66, -121.6],
-  columns = ['latitude', 'longitude'])
-st.map(data_of_map)
-
-
-st.title('Pyvis VisJS DOTlang Legend')
-
-Network(notebook=True)
-# make Network show itself with repr_html
-
-def net_repr_html(self):
-  nodes, edges, height, width, options = self.get_network_data()
-  html = self.template.render(height=height, width=width, nodes=nodes, edges=edges, options=options)
-  return html
-
-Network._repr_html_ = net_repr_html
-
-st.sidebar.title('Choose your favorite Graph')
-option=st.sidebar.selectbox('select graph',('Simple','Karate', 'GOT'))
-physics=st.sidebar.checkbox('add physics interactivity?')
-got.simple_func(physics)
-
-if option=='Simple':
-  HtmlFile = open("test.html", 'r', encoding='utf-8')
-  source_code = HtmlFile.read() 
-  components.html(source_code, height = 900,width=900)
-
-got.got_func(physics)
-
-if option=='GOT':
-  HtmlFile = open("gameofthrones.html", 'r', encoding='utf-8')
-  source_code = HtmlFile.read() 
-  components.html(source_code, height = 1200,width=1000)
-
-got.karate_func(physics)
-
-if option=='Karate':
-  HtmlFile = open("karate.html", 'r', encoding='utf-8')
-  source_code = HtmlFile.read() 
-  components.html(source_code, height = 1200,width=1000)

spaces/AIARTCHAN/openpose_editor/style.css

@@ -1,28 +0,0 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}

spaces/AIConsultant/MusicGen/audiocraft/metrics/kld.py

@@ -1,218 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import contextlib
-from functools import partial
-import logging
-import os
-import typing as tp
-
-import torch
-import torchmetrics
-
-from ..data.audio_utils import convert_audio
-
-
-logger = logging.getLogger(__name__)
-
-
-class _patch_passt_stft:
-    """Decorator to patch torch.stft in PaSST."""
-    def __init__(self):
-        self.old_stft = torch.stft
-
-    def __enter__(self):
-        # return_complex is a mandatory parameter in latest torch versions
-        # torch is throwing RuntimeErrors when not set
-        torch.stft = partial(torch.stft, return_complex=False)
-
-    def __exit__(self, *exc):
-        torch.stft = self.old_stft
-
-
-def kl_divergence(pred_probs: torch.Tensor, target_probs: torch.Tensor, epsilon: float = 1e-6) -> torch.Tensor:
-    """Computes the elementwise KL-Divergence loss between probability distributions
-    from generated samples and target samples.
-
-    Args:
-        pred_probs (torch.Tensor): Probabilities for each label obtained
-            from a classifier on generated audio. Expected shape is [B, num_classes].
-        target_probs (torch.Tensor): Probabilities for each label obtained
-            from a classifier on target audio. Expected shape is [B, num_classes].
-        epsilon (float): Epsilon value.
-    Returns:
-        kld (torch.Tensor): KLD loss between each generated sample and target pair.
-    """
-    kl_div = torch.nn.functional.kl_div((pred_probs + epsilon).log(), target_probs, reduction="none")
-    return kl_div.sum(-1)
-
-
-class KLDivergenceMetric(torchmetrics.Metric):
-    """Base implementation for KL Divergence metric.
-
-    The KL divergence is measured between probability distributions
-    of class predictions returned by a pre-trained audio classification model.
-    When the KL-divergence is low, the generated audio is expected to
-    have similar acoustic characteristics as the reference audio,
-    according to the classifier.
-    """
-    def __init__(self):
-        super().__init__()
-        self.add_state("kld_pq_sum", default=torch.tensor(0.), dist_reduce_fx="sum")
-        self.add_state("kld_qp_sum", default=torch.tensor(0.), dist_reduce_fx="sum")
-        self.add_state("kld_all_sum", default=torch.tensor(0.), dist_reduce_fx="sum")
-        self.add_state("weight", default=torch.tensor(0), dist_reduce_fx="sum")
-
-    def _get_label_distribution(self, x: torch.Tensor, sizes: torch.Tensor,
-                                sample_rates: torch.Tensor) -> tp.Optional[torch.Tensor]:
-        """Get model output given provided input tensor.
-
-        Args:
-            x (torch.Tensor): Input audio tensor of shape [B, C, T].
-            sizes (torch.Tensor): Actual audio sample length, of shape [B].
-            sample_rates (torch.Tensor): Actual audio sample rate, of shape [B].
-        Returns:
-            probs (torch.Tensor): Probabilities over labels, of shape [B, num_classes].
-        """
-        raise NotImplementedError("implement method to extract label distributions from the model.")
-
-    def update(self, preds: torch.Tensor, targets: torch.Tensor,
-               sizes: torch.Tensor, sample_rates: torch.Tensor) -> None:
-        """Calculates running KL-Divergence loss between batches of audio
-        preds (generated) and target (ground-truth)
-        Args:
-            preds (torch.Tensor): Audio samples to evaluate, of shape [B, C, T].
-            targets (torch.Tensor): Target samples to compare against, of shape [B, C, T].
-            sizes (torch.Tensor): Actual audio sample length, of shape [B].
-            sample_rates (torch.Tensor): Actual audio sample rate, of shape [B].
-        """
-        assert preds.shape == targets.shape
-        assert preds.size(0) > 0, "Cannot update the loss with empty tensors"
-        preds_probs = self._get_label_distribution(preds, sizes, sample_rates)
-        targets_probs = self._get_label_distribution(targets, sizes, sample_rates)
-        if preds_probs is not None and targets_probs is not None:
-            assert preds_probs.shape == targets_probs.shape
-            kld_scores = kl_divergence(preds_probs, targets_probs)
-            assert not torch.isnan(kld_scores).any(), "kld_scores contains NaN value(s)!"
-            self.kld_pq_sum += torch.sum(kld_scores)
-            kld_qp_scores = kl_divergence(targets_probs, preds_probs)
-            self.kld_qp_sum += torch.sum(kld_qp_scores)
-            self.weight += torch.tensor(kld_scores.size(0))
-
-    def compute(self) -> dict:
-        """Computes KL-Divergence across all evaluated pred/target pairs."""
-        weight: float = float(self.weight.item())  # type: ignore
-        assert weight > 0, "Unable to compute with total number of comparisons <= 0"
-        logger.info(f"Computing KL divergence on a total of {weight} samples")
-        kld_pq = self.kld_pq_sum.item() / weight  # type: ignore
-        kld_qp = self.kld_qp_sum.item() / weight  # type: ignore
-        kld_both = kld_pq + kld_qp
-        return {'kld': kld_pq, 'kld_pq': kld_pq, 'kld_qp': kld_qp, 'kld_both': kld_both}
-
-
-class PasstKLDivergenceMetric(KLDivergenceMetric):
-    """KL-Divergence metric based on pre-trained PASST classifier on AudioSet.
-
-    From: PaSST: Efficient Training of Audio Transformers with Patchout
-    Paper: https://arxiv.org/abs/2110.05069
-    Implementation: https://github.com/kkoutini/PaSST
-
-    Follow instructions from the github repo:
-    ```
-    pip install 'git+https://github.com/kkoutini/[email protected]#egg=hear21passt'
-    ```
-
-    Args:
-        pretrained_length (float, optional): Audio duration used for the pretrained model.
-    """
-    def __init__(self, pretrained_length: tp.Optional[float] = None):
-        super().__init__()
-        self._initialize_model(pretrained_length)
-
-    def _initialize_model(self, pretrained_length: tp.Optional[float] = None):
-        """Initialize underlying PaSST audio classifier."""
-        model, sr, max_frames, min_frames = self._load_base_model(pretrained_length)
-        self.min_input_frames = min_frames
-        self.max_input_frames = max_frames
-        self.model_sample_rate = sr
-        self.model = model
-        self.model.eval()
-        self.model.to(self.device)
-
-    def _load_base_model(self, pretrained_length: tp.Optional[float]):
-        """Load pretrained model from PaSST."""
-        try:
-            if pretrained_length == 30:
-                from hear21passt.base30sec import get_basic_model  # type: ignore
-                max_duration = 30
-            elif pretrained_length == 20:
-                from hear21passt.base20sec import get_basic_model  # type: ignore
-                max_duration = 20
-            else:
-                from hear21passt.base import get_basic_model  # type: ignore
-                # Original PASST was trained on AudioSet with 10s-long audio samples
-                max_duration = 10
-            min_duration = 0.15
-            min_duration = 0.15
-        except ModuleNotFoundError:
-            raise ModuleNotFoundError(
-                "Please install hear21passt to compute KL divergence: ",
-                "pip install 'git+https://github.com/kkoutini/[email protected]#egg=hear21passt'"
-            )
-        model_sample_rate = 32_000
-        max_input_frames = int(max_duration * model_sample_rate)
-        min_input_frames = int(min_duration * model_sample_rate)
-        with open(os.devnull, 'w') as f, contextlib.redirect_stdout(f):
-            model = get_basic_model(mode='logits')
-        return model, model_sample_rate, max_input_frames, min_input_frames
-
-    def _process_audio(self, wav: torch.Tensor, sample_rate: int, wav_len: int) -> tp.Optional[torch.Tensor]:
-        wav = wav.unsqueeze(0)
-        wav = wav[..., :wav_len]
-        wav = convert_audio(wav, from_rate=sample_rate, to_rate=self.model_sample_rate, to_channels=1)
-        wav = wav.squeeze(0)
-        # create chunks of audio to match the classifier processing length
-        segments = torch.split(wav, self.max_input_frames, dim=-1)
-        valid_segments = []
-        for s in segments:
-            if s.size(-1) > self.min_input_frames:
-                s = torch.nn.functional.pad(s, (0, self.max_input_frames - s.shape[-1]))
-                valid_segments.append(s)
-        if len(valid_segments) > 0:
-            return torch.stack(valid_segments, dim=0)
-        else:
-            return None
-
-    def _get_label_distribution(self, x: torch.Tensor, sizes: torch.Tensor,
-                                sample_rates: torch.Tensor) -> tp.Optional[torch.Tensor]:
-        """Get model output given provided input tensor.
-
-        Args:
-            x (torch.Tensor): Input audio tensor of shape [B, C, T].
-            sizes (torch.Tensor): Actual audio sample length, of shape [B].
-            sample_rates (torch.Tensor): Actual audio sample rate, of shape [B].
-        Returns:
-            probs (torch.Tensor, optional): Probabilities over labels, of shape [B, num_classes].
-        """
-        all_probs: tp.List[torch.Tensor] = []
-        for i, wav in enumerate(x):
-            sample_rate = int(sample_rates[i].item())
-            wav_len = int(sizes[i].item())
-            wav = self._process_audio(wav, sample_rate, wav_len)
-            if wav is not None:
-                assert wav.dim() == 3, f"Unexpected number of dims for preprocessed wav: {wav.shape}"
-                wav = wav.mean(dim=1)
-                # PaSST is printing a lot of infos that we are not interested in
-                with open(os.devnull, 'w') as f, contextlib.redirect_stdout(f):
-                    with torch.no_grad(), _patch_passt_stft():
-                        logits = self.model(wav.to(self.device))
-                        probs = torch.softmax(logits, dim=-1)
-                        probs = probs.mean(dim=0)
-                        all_probs.append(probs)
-        if len(all_probs) > 0:
-            return torch.stack(all_probs, dim=0)
-        else:
-            return None

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_0_ClothesDetection/mmyolo/configs/yolov5/yolov5_s-p6-v62_syncbn_fast_8xb16-300e_coco.py

@@ -1,138 +0,0 @@
-_base_ = 'yolov5_s-v61_syncbn_fast_8xb16-300e_coco.py'
-
-# ========================modified parameters======================
-img_scale = (1280, 1280)  # width, height
-num_classes = 80  # Number of classes for classification
-# Config of batch shapes. Only on val.
-# It means not used if batch_shapes_cfg is None.
-batch_shapes_cfg = dict(
-    img_size=img_scale[0],
-    # The image scale of padding should be divided by pad_size_divisor
-    size_divisor=64)
-# Basic size of multi-scale prior box
-anchors = [
-    [(19, 27), (44, 40), (38, 94)],  # P3/8
-    [(96, 68), (86, 152), (180, 137)],  # P4/16
-    [(140, 301), (303, 264), (238, 542)],  # P5/32
-    [(436, 615), (739, 380), (925, 792)]  # P6/64
-]
-# Strides of multi-scale prior box
-strides = [8, 16, 32, 64]
-num_det_layers = 4  # The number of model output scales
-loss_cls_weight = 0.5
-loss_bbox_weight = 0.05
-loss_obj_weight = 1.0
-# The obj loss weights of the three output layers
-obj_level_weights = [4.0, 1.0, 0.25, 0.06]
-affine_scale = 0.5  # YOLOv5RandomAffine scaling ratio
-
-tta_img_scales = [(1280, 1280), (1024, 1024), (1536, 1536)]
-# =======================Unmodified in most cases==================
-model = dict(
-    backbone=dict(arch='P6', out_indices=(2, 3, 4, 5)),
-    neck=dict(
-        in_channels=[256, 512, 768, 1024], out_channels=[256, 512, 768, 1024]),
-    bbox_head=dict(
-        head_module=dict(
-            in_channels=[256, 512, 768, 1024], featmap_strides=strides),
-        prior_generator=dict(base_sizes=anchors, strides=strides),
-        # scaled based on number of detection layers
-        loss_cls=dict(loss_weight=loss_cls_weight *
-                      (num_classes / 80 * 3 / num_det_layers)),
-        loss_bbox=dict(loss_weight=loss_bbox_weight * (3 / num_det_layers)),
-        loss_obj=dict(loss_weight=loss_obj_weight *
-                      ((img_scale[0] / 640)**2 * 3 / num_det_layers)),
-        obj_level_weights=obj_level_weights))
-
-pre_transform = _base_.pre_transform
-albu_train_transforms = _base_.albu_train_transforms
-
-train_pipeline = [
-    *pre_transform,
-    dict(
-        type='Mosaic',
-        img_scale=img_scale,
-        pad_val=114.0,
-        pre_transform=pre_transform),
-    dict(
-        type='YOLOv5RandomAffine',
-        max_rotate_degree=0.0,
-        max_shear_degree=0.0,
-        scaling_ratio_range=(1 - affine_scale, 1 + affine_scale),
-        # img_scale is (width, height)
-        border=(-img_scale[0] // 2, -img_scale[1] // 2),
-        border_val=(114, 114, 114)),
-    dict(
-        type='mmdet.Albu',
-        transforms=albu_train_transforms,
-        bbox_params=dict(
-            type='BboxParams',
-            format='pascal_voc',
-            label_fields=['gt_bboxes_labels', 'gt_ignore_flags']),
-        keymap={
-            'img': 'image',
-            'gt_bboxes': 'bboxes'
-        }),
-    dict(type='YOLOv5HSVRandomAug'),
-    dict(type='mmdet.RandomFlip', prob=0.5),
-    dict(
-        type='mmdet.PackDetInputs',
-        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip',
-                   'flip_direction'))
-]
-
-train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
-
-test_pipeline = [
-    dict(type='LoadImageFromFile', file_client_args=_base_.file_client_args),
-    dict(type='YOLOv5KeepRatioResize', scale=img_scale),
-    dict(
-        type='LetterResize',
-        scale=img_scale,
-        allow_scale_up=False,
-        pad_val=dict(img=114)),
-    dict(type='LoadAnnotations', with_bbox=True, _scope_='mmdet'),
-    dict(
-        type='mmdet.PackDetInputs',
-        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
-                   'scale_factor', 'pad_param'))
-]
-
-val_dataloader = dict(
-    dataset=dict(pipeline=test_pipeline, batch_shapes_cfg=batch_shapes_cfg))
-
-test_dataloader = val_dataloader
-
-# Config for Test Time Augmentation. (TTA)
-_multiscale_resize_transforms = [
-    dict(
-        type='Compose',
-        transforms=[
-            dict(type='YOLOv5KeepRatioResize', scale=s),
-            dict(
-                type='LetterResize',
-                scale=s,
-                allow_scale_up=False,
-                pad_val=dict(img=114))
-        ]) for s in tta_img_scales
-]
-
-tta_pipeline = [
-    dict(type='LoadImageFromFile', file_client_args=_base_.file_client_args),
-    dict(
-        type='TestTimeAug',
-        transforms=[
-            _multiscale_resize_transforms,
-            [
-                dict(type='mmdet.RandomFlip', prob=1.),
-                dict(type='mmdet.RandomFlip', prob=0.)
-            ], [dict(type='mmdet.LoadAnnotations', with_bbox=True)],
-            [
-                dict(
-                    type='mmdet.PackDetInputs',
-                    meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
-                               'scale_factor', 'pad_param', 'flip',
-                               'flip_direction'))
-            ]
-        ])
-]

spaces/Ababababababbababa/Ashaar/poetry_diacritizer/util/learning_rates.py

@@ -1,70 +0,0 @@
-import numpy as np
-import math
-
-
-class LearningRateDecay:
-    def __init__(self, lr=0.002, warmup_steps=4000.0) -> None:
-        self.lr = lr
-        self.warmup_steps = warmup_steps
-
-    def __call__(self, global_step) -> float:
-        step = global_step + 1.0
-        lr = (
-            self.lr
-            * self.warmup_steps ** 0.5
-            * np.minimum(step * self.warmup_steps ** -1.5, step ** -0.5)
-        )
-
-        return lr
-
-class SquareRootScheduler:
-    def __init__(self, lr=0.1):
-        self.lr = lr
-
-    def __call__(self, global_step):
-        global_step = global_step // 1000
-        return self.lr * pow(global_step + 1.0, -0.5)
-
-
-class CosineScheduler:
-    def __init__(
-        self, max_update, base_lr=0.02, final_lr=0, warmup_steps=0, warmup_begin_lr=0
-    ):
-        self.base_lr_orig = base_lr
-        self.max_update = max_update
-        self.final_lr = final_lr
-        self.warmup_steps = warmup_steps
-        self.warmup_begin_lr = warmup_begin_lr
-        self.max_steps = self.max_update - self.warmup_steps
-
-    def get_warmup_lr(self, global_step):
-        increase = (
-            (self.base_lr_orig - self.warmup_begin_lr)
-            * float(global_step)
-            / float(self.warmup_steps)
-        )
-        return self.warmup_begin_lr + increase
-
-    def __call__(self, global_step):
-        if global_step < self.warmup_steps:
-            return self.get_warmup_lr(global_step)
-        if global_step <= self.max_update:
-            self.base_lr = (
-                self.final_lr
-                + (self.base_lr_orig - self.final_lr)
-                * (
-                    1
-                    + math.cos(
-                        math.pi * (global_step - self.warmup_steps) / self.max_steps
-                    )
-                )
-                / 2
-            )
-        return self.base_lr
-
-def adjust_learning_rate(optimizer, global_step):
-    lr = LearningRateDecay()(global_step=global_step)
-    for param_group in optimizer.param_groups:
-        param_group["lr"] = lr
-    return lr
-

spaces/AgentVerse/agentVerse/agentverse/environments/simulation_env/rules/selector/base.py

@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, List
-
-from pydantic import BaseModel
-
-from agentverse.message import Message
-
-from . import selector_registry as SelectorRegistry
-from abc import abstractmethod
-
-if TYPE_CHECKING:
-    from agentverse.environments import BaseEnvironment
-
-
-@SelectorRegistry.register("base")
-class BaseSelector(BaseModel):
-    """
-    Base class for all selecters
-    """
-
-    @abstractmethod
-    def select_message(
-        self, environment: BaseEnvironment, messages: List[Message]
-    ) -> List[Message]:
-        """Selects a set of valid messages from all messages"""
-        pass
-
-    def reset(self) -> None:
-        pass

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/circularprogresscanvas/CircularProgressCanvas.js

@@ -1,2 +0,0 @@
-import CircularProgressCanvas from '../../../plugins/circularprogresscanvas.js';
-export default CircularProgressCanvas;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/container/Container.d.ts

@@ -1,2 +0,0 @@
-import Container from '../../../plugins/containerlite';
-export default Container;

spaces/AkitoP/umamusume_bert_vits2/attentions.py

@@ -1,464 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class LayerNorm(nn.Module):
-    def __init__(self, channels, eps=1e-5):
-        super().__init__()
-        self.channels = channels
-        self.eps = eps
-
-        self.gamma = nn.Parameter(torch.ones(channels))
-        self.beta = nn.Parameter(torch.zeros(channels))
-
-    def forward(self, x):
-        x = x.transpose(1, -1)
-        x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-        return x.transpose(1, -1)
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
-    n_channels_int = n_channels[0]
-    in_act = input_a + input_b
-    t_act = torch.tanh(in_act[:, :n_channels_int, :])
-    s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
-    acts = t_act * s_act
-    return acts
-
-
-class Encoder(nn.Module):
-    def __init__(
-        self,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size=1,
-        p_dropout=0.0,
-        window_size=4,
-        isflow=True,
-        **kwargs
-    ):
-        super().__init__()
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.window_size = window_size
-        # if isflow:
-        #  cond_layer = torch.nn.Conv1d(256, 2*hidden_channels*n_layers, 1)
-        #  self.cond_pre = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, 1)
-        #  self.cond_layer = weight_norm(cond_layer, name='weight')
-        #  self.gin_channels = 256
-        self.cond_layer_idx = self.n_layers
-        if "gin_channels" in kwargs:
-            self.gin_channels = kwargs["gin_channels"]
-            if self.gin_channels != 0:
-                self.spk_emb_linear = nn.Linear(self.gin_channels, self.hidden_channels)
-                # vits2 says 3rd block, so idx is 2 by default
-                self.cond_layer_idx = (
-                    kwargs["cond_layer_idx"] if "cond_layer_idx" in kwargs else 2
-                )
-                logging.debug(self.gin_channels, self.cond_layer_idx)
-                assert (
-                    self.cond_layer_idx < self.n_layers
-                ), "cond_layer_idx should be less than n_layers"
-        self.drop = nn.Dropout(p_dropout)
-        self.attn_layers = nn.ModuleList()
-        self.norm_layers_1 = nn.ModuleList()
-        self.ffn_layers = nn.ModuleList()
-        self.norm_layers_2 = nn.ModuleList()
-        for i in range(self.n_layers):
-            self.attn_layers.append(
-                MultiHeadAttention(
-                    hidden_channels,
-                    hidden_channels,
-                    n_heads,
-                    p_dropout=p_dropout,
-                    window_size=window_size,
-                )
-            )
-            self.norm_layers_1.append(LayerNorm(hidden_channels))
-            self.ffn_layers.append(
-                FFN(
-                    hidden_channels,
-                    hidden_channels,
-                    filter_channels,
-                    kernel_size,
-                    p_dropout=p_dropout,
-                )
-            )
-            self.norm_layers_2.append(LayerNorm(hidden_channels))
-
-    def forward(self, x, x_mask, g=None):
-        attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-        x = x * x_mask
-        for i in range(self.n_layers):
-            if i == self.cond_layer_idx and g is not None:
-                g = self.spk_emb_linear(g.transpose(1, 2))
-                g = g.transpose(1, 2)
-                x = x + g
-                x = x * x_mask
-            y = self.attn_layers[i](x, x, attn_mask)
-            y = self.drop(y)
-            x = self.norm_layers_1[i](x + y)
-
-            y = self.ffn_layers[i](x, x_mask)
-            y = self.drop(y)
-            x = self.norm_layers_2[i](x + y)
-        x = x * x_mask
-        return x
-
-
-class Decoder(nn.Module):
-    def __init__(
-        self,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size=1,
-        p_dropout=0.0,
-        proximal_bias=False,
-        proximal_init=True,
-        **kwargs
-    ):
-        super().__init__()
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.proximal_bias = proximal_bias
-        self.proximal_init = proximal_init
-
-        self.drop = nn.Dropout(p_dropout)
-        self.self_attn_layers = nn.ModuleList()
-        self.norm_layers_0 = nn.ModuleList()
-        self.encdec_attn_layers = nn.ModuleList()
-        self.norm_layers_1 = nn.ModuleList()
-        self.ffn_layers = nn.ModuleList()
-        self.norm_layers_2 = nn.ModuleList()
-        for i in range(self.n_layers):
-            self.self_attn_layers.append(
-                MultiHeadAttention(
-                    hidden_channels,
-                    hidden_channels,
-                    n_heads,
-                    p_dropout=p_dropout,
-                    proximal_bias=proximal_bias,
-                    proximal_init=proximal_init,
-                )
-            )
-            self.norm_layers_0.append(LayerNorm(hidden_channels))
-            self.encdec_attn_layers.append(
-                MultiHeadAttention(
-                    hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout
-                )
-            )
-            self.norm_layers_1.append(LayerNorm(hidden_channels))
-            self.ffn_layers.append(
-                FFN(
-                    hidden_channels,
-                    hidden_channels,
-                    filter_channels,
-                    kernel_size,
-                    p_dropout=p_dropout,
-                    causal=True,
-                )
-            )
-            self.norm_layers_2.append(LayerNorm(hidden_channels))
-
-    def forward(self, x, x_mask, h, h_mask):
-        """
-        x: decoder input
-        h: encoder output
-        """
-        self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(
-            device=x.device, dtype=x.dtype
-        )
-        encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-        x = x * x_mask
-        for i in range(self.n_layers):
-            y = self.self_attn_layers[i](x, x, self_attn_mask)
-            y = self.drop(y)
-            x = self.norm_layers_0[i](x + y)
-
-            y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
-            y = self.drop(y)
-            x = self.norm_layers_1[i](x + y)
-
-            y = self.ffn_layers[i](x, x_mask)
-            y = self.drop(y)
-            x = self.norm_layers_2[i](x + y)
-        x = x * x_mask
-        return x
-
-
-class MultiHeadAttention(nn.Module):
-    def __init__(
-        self,
-        channels,
-        out_channels,
-        n_heads,
-        p_dropout=0.0,
-        window_size=None,
-        heads_share=True,
-        block_length=None,
-        proximal_bias=False,
-        proximal_init=False,
-    ):
-        super().__init__()
-        assert channels % n_heads == 0
-
-        self.channels = channels
-        self.out_channels = out_channels
-        self.n_heads = n_heads
-        self.p_dropout = p_dropout
-        self.window_size = window_size
-        self.heads_share = heads_share
-        self.block_length = block_length
-        self.proximal_bias = proximal_bias
-        self.proximal_init = proximal_init
-        self.attn = None
-
-        self.k_channels = channels // n_heads
-        self.conv_q = nn.Conv1d(channels, channels, 1)
-        self.conv_k = nn.Conv1d(channels, channels, 1)
-        self.conv_v = nn.Conv1d(channels, channels, 1)
-        self.conv_o = nn.Conv1d(channels, out_channels, 1)
-        self.drop = nn.Dropout(p_dropout)
-
-        if window_size is not None:
-            n_heads_rel = 1 if heads_share else n_heads
-            rel_stddev = self.k_channels**-0.5
-            self.emb_rel_k = nn.Parameter(
-                torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
-                * rel_stddev
-            )
-            self.emb_rel_v = nn.Parameter(
-                torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels)
-                * rel_stddev
-            )
-
-        nn.init.xavier_uniform_(self.conv_q.weight)
-        nn.init.xavier_uniform_(self.conv_k.weight)
-        nn.init.xavier_uniform_(self.conv_v.weight)
-        if proximal_init:
-            with torch.no_grad():
-                self.conv_k.weight.copy_(self.conv_q.weight)
-                self.conv_k.bias.copy_(self.conv_q.bias)
-
-    def forward(self, x, c, attn_mask=None):
-        q = self.conv_q(x)
-        k = self.conv_k(c)
-        v = self.conv_v(c)
-
-        x, self.attn = self.attention(q, k, v, mask=attn_mask)
-
-        x = self.conv_o(x)
-        return x
-
-    def attention(self, query, key, value, mask=None):
-        # reshape [b, d, t] -> [b, n_h, t, d_k]
-        b, d, t_s, t_t = (*key.size(), query.size(2))
-        query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
-        key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-        value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-
-        scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
-        if self.window_size is not None:
-            assert (
-                t_s == t_t
-            ), "Relative attention is only available for self-attention."
-            key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
-            rel_logits = self._matmul_with_relative_keys(
-                query / math.sqrt(self.k_channels), key_relative_embeddings
-            )
-            scores_local = self._relative_position_to_absolute_position(rel_logits)
-            scores = scores + scores_local
-        if self.proximal_bias:
-            assert t_s == t_t, "Proximal bias is only available for self-attention."
-            scores = scores + self._attention_bias_proximal(t_s).to(
-                device=scores.device, dtype=scores.dtype
-            )
-        if mask is not None:
-            scores = scores.masked_fill(mask == 0, -1e4)
-            if self.block_length is not None:
-                assert (
-                    t_s == t_t
-                ), "Local attention is only available for self-attention."
-                block_mask = (
-                    torch.ones_like(scores)
-                    .triu(-self.block_length)
-                    .tril(self.block_length)
-                )
-                scores = scores.masked_fill(block_mask == 0, -1e4)
-        p_attn = F.softmax(scores, dim=-1)  # [b, n_h, t_t, t_s]
-        p_attn = self.drop(p_attn)
-        output = torch.matmul(p_attn, value)
-        if self.window_size is not None:
-            relative_weights = self._absolute_position_to_relative_position(p_attn)
-            value_relative_embeddings = self._get_relative_embeddings(
-                self.emb_rel_v, t_s
-            )
-            output = output + self._matmul_with_relative_values(
-                relative_weights, value_relative_embeddings
-            )
-        output = (
-            output.transpose(2, 3).contiguous().view(b, d, t_t)
-        )  # [b, n_h, t_t, d_k] -> [b, d, t_t]
-        return output, p_attn
-
-    def _matmul_with_relative_values(self, x, y):
-        """
-        x: [b, h, l, m]
-        y: [h or 1, m, d]
-        ret: [b, h, l, d]
-        """
-        ret = torch.matmul(x, y.unsqueeze(0))
-        return ret
-
-    def _matmul_with_relative_keys(self, x, y):
-        """
-        x: [b, h, l, d]
-        y: [h or 1, m, d]
-        ret: [b, h, l, m]
-        """
-        ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
-        return ret
-
-    def _get_relative_embeddings(self, relative_embeddings, length):
-        2 * self.window_size + 1
-        # Pad first before slice to avoid using cond ops.
-        pad_length = max(length - (self.window_size + 1), 0)
-        slice_start_position = max((self.window_size + 1) - length, 0)
-        slice_end_position = slice_start_position + 2 * length - 1
-        if pad_length > 0:
-            padded_relative_embeddings = F.pad(
-                relative_embeddings,
-                commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]),
-            )
-        else:
-            padded_relative_embeddings = relative_embeddings
-        used_relative_embeddings = padded_relative_embeddings[
-            :, slice_start_position:slice_end_position
-        ]
-        return used_relative_embeddings
-
-    def _relative_position_to_absolute_position(self, x):
-        """
-        x: [b, h, l, 2*l-1]
-        ret: [b, h, l, l]
-        """
-        batch, heads, length, _ = x.size()
-        # Concat columns of pad to shift from relative to absolute indexing.
-        x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, 1]]))
-
-        # Concat extra elements so to add up to shape (len+1, 2*len-1).
-        x_flat = x.view([batch, heads, length * 2 * length])
-        x_flat = F.pad(
-            x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [0, length - 1]])
-        )
-
-        # Reshape and slice out the padded elements.
-        x_final = x_flat.view([batch, heads, length + 1, 2 * length - 1])[
-            :, :, :length, length - 1 :
-        ]
-        return x_final
-
-    def _absolute_position_to_relative_position(self, x):
-        """
-        x: [b, h, l, l]
-        ret: [b, h, l, 2*l-1]
-        """
-        batch, heads, length, _ = x.size()
-        # pad along column
-        x = F.pad(
-            x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length - 1]])
-        )
-        x_flat = x.view([batch, heads, length**2 + length * (length - 1)])
-        # add 0's in the beginning that will skew the elements after reshape
-        x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
-        x_final = x_flat.view([batch, heads, length, 2 * length])[:, :, :, 1:]
-        return x_final
-
-    def _attention_bias_proximal(self, length):
-        """Bias for self-attention to encourage attention to close positions.
-        Args:
-          length: an integer scalar.
-        Returns:
-          a Tensor with shape [1, 1, length, length]
-        """
-        r = torch.arange(length, dtype=torch.float32)
-        diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
-        return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
-
-
-class FFN(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        filter_channels,
-        kernel_size,
-        p_dropout=0.0,
-        activation=None,
-        causal=False,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.filter_channels = filter_channels
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.activation = activation
-        self.causal = causal
-
-        if causal:
-            self.padding = self._causal_padding
-        else:
-            self.padding = self._same_padding
-
-        self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
-        self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
-        self.drop = nn.Dropout(p_dropout)
-
-    def forward(self, x, x_mask):
-        x = self.conv_1(self.padding(x * x_mask))
-        if self.activation == "gelu":
-            x = x * torch.sigmoid(1.702 * x)
-        else:
-            x = torch.relu(x)
-        x = self.drop(x)
-        x = self.conv_2(self.padding(x * x_mask))
-        return x * x_mask
-
-    def _causal_padding(self, x):
-        if self.kernel_size == 1:
-            return x
-        pad_l = self.kernel_size - 1
-        pad_r = 0
-        padding = [[0, 0], [0, 0], [pad_l, pad_r]]
-        x = F.pad(x, commons.convert_pad_shape(padding))
-        return x
-
-    def _same_padding(self, x):
-        if self.kernel_size == 1:
-            return x
-        pad_l = (self.kernel_size - 1) // 2
-        pad_r = self.kernel_size // 2
-        padding = [[0, 0], [0, 0], [pad_l, pad_r]]
-        x = F.pad(x, commons.convert_pad_shape(padding))
-        return x

spaces/AkitoP/umamusume_bert_vits2/losses.py

@@ -1,58 +0,0 @@
-import torch
-
-
-def feature_loss(fmap_r, fmap_g):
-    loss = 0
-    for dr, dg in zip(fmap_r, fmap_g):
-        for rl, gl in zip(dr, dg):
-            rl = rl.float().detach()
-            gl = gl.float()
-            loss += torch.mean(torch.abs(rl - gl))
-
-    return loss * 2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
-    loss = 0
-    r_losses = []
-    g_losses = []
-    for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
-        dr = dr.float()
-        dg = dg.float()
-        r_loss = torch.mean((1 - dr) ** 2)
-        g_loss = torch.mean(dg**2)
-        loss += r_loss + g_loss
-        r_losses.append(r_loss.item())
-        g_losses.append(g_loss.item())
-
-    return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
-    loss = 0
-    gen_losses = []
-    for dg in disc_outputs:
-        dg = dg.float()
-        l = torch.mean((1 - dg) ** 2)
-        gen_losses.append(l)
-        loss += l
-
-    return loss, gen_losses
-
-
-def kl_loss(z_p, logs_q, m_p, logs_p, z_mask):
-    """
-    z_p, logs_q: [b, h, t_t]
-    m_p, logs_p: [b, h, t_t]
-    """
-    z_p = z_p.float()
-    logs_q = logs_q.float()
-    m_p = m_p.float()
-    logs_p = logs_p.float()
-    z_mask = z_mask.float()
-
-    kl = logs_p - logs_q - 0.5
-    kl += 0.5 * ((z_p - m_p) ** 2) * torch.exp(-2.0 * logs_p)
-    kl = torch.sum(kl * z_mask)
-    l = kl / torch.sum(z_mask)
-    return l

spaces/Akmyradov/TurkmenTTSweSTT/README.md

@@ -1,14 +0,0 @@
----
-title: MMS
-emoji: ⚡
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.32.0
-app_file: app.py
-pinned: false
-license: cc-by-nc-4.0
-duplicated_from: facebook/MMS
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AlexZou/Deploy_Restoration/net/SGFMT.py

@@ -1,126 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Author  : Lintao Peng
-# @File    : SGFMT.py
-# coding=utf-8
-# Design based on the Vit
-
-import torch.nn as nn
-from net.IntmdSequential import IntermediateSequential
-
-
-#实现了自注意力机制，相当于unet的bottleneck层
-class SelfAttention(nn.Module):
-    def __init__(
-        self, dim, heads=8, qkv_bias=False, qk_scale=None, dropout_rate=0.0
-    ):
-        super().__init__()
-        self.num_heads = heads
-        head_dim = dim // heads
-        self.scale = qk_scale or head_dim ** -0.5
-
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(dropout_rate)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(dropout_rate)
-
-    def forward(self, x):
-        B, N, C = x.shape
-        qkv = (
-            self.qkv(x)
-            .reshape(B, N, 3, self.num_heads, C // self.num_heads)
-            .permute(2, 0, 3, 1, 4)
-        )
-        q, k, v = (
-            qkv[0],
-            qkv[1],
-            qkv[2],
-        )  # make torchscript happy (cannot use tensor as tuple)
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale 
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-
-
-class Residual(nn.Module):
-    def __init__(self, fn):
-        super().__init__()
-        self.fn = fn
-
-    def forward(self, x):
-        return self.fn(x) + x
-
-
-class PreNorm(nn.Module):
-    def __init__(self, dim, fn):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.fn = fn
-
-    def forward(self, x):
-        return self.fn(self.norm(x))
-
-
-class PreNormDrop(nn.Module):
-    def __init__(self, dim, dropout_rate, fn):
-        super().__init__()
-        self.norm = nn.LayerNorm(dim)
-        self.dropout = nn.Dropout(p=dropout_rate)
-        self.fn = fn
-
-    def forward(self, x):
-        return self.dropout(self.fn(self.norm(x)))
-
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, hidden_dim, dropout_rate):
-        super().__init__()
-        self.net = nn.Sequential(
-            nn.Linear(dim, hidden_dim),
-            nn.GELU(),
-            nn.Dropout(p=dropout_rate),
-            nn.Linear(hidden_dim, dim),
-            nn.Dropout(p=dropout_rate),
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-
-class TransformerModel(nn.Module):
-    def __init__(
-        self,
-        dim,  #512
-        depth,  #4
-        heads,  #8
-        mlp_dim,  #4096
-        dropout_rate=0.1,
-        attn_dropout_rate=0.1,
-    ):
-        super().__init__()
-        layers = []
-        for _ in range(depth):
-            layers.extend(
-                [
-                    Residual(
-                        PreNormDrop(
-                            dim,
-                            dropout_rate,
-                            SelfAttention(dim, heads=heads, dropout_rate=attn_dropout_rate),
-                        )
-                    ),
-                    Residual(
-                        PreNorm(dim, FeedForward(dim, mlp_dim, dropout_rate))
-                    ),
-                ]
-            )
-            # dim = dim / 2
-        self.net = IntermediateSequential(*layers)
-
-
-    def forward(self, x):
-        return self.net(x)

spaces/Amon1/ChatGPTForAcadamic/theme.py

@@ -1,152 +0,0 @@
-import gradio as gr 
-
-# gradio可用颜色列表
-# gr.themes.utils.colors.slate (石板色)
-# gr.themes.utils.colors.gray (灰色)
-# gr.themes.utils.colors.zinc (锌色)
-# gr.themes.utils.colors.neutral (中性色)
-# gr.themes.utils.colors.stone (石头色)
-# gr.themes.utils.colors.red (红色)
-# gr.themes.utils.colors.orange (橙色)
-# gr.themes.utils.colors.amber (琥珀色)
-# gr.themes.utils.colors.yellow (黄色)
-# gr.themes.utils.colors.lime (酸橙色)
-# gr.themes.utils.colors.green (绿色)
-# gr.themes.utils.colors.emerald (祖母绿)
-# gr.themes.utils.colors.teal (青蓝色)
-# gr.themes.utils.colors.cyan (青色)
-# gr.themes.utils.colors.sky (天蓝色)
-# gr.themes.utils.colors.blue (蓝色)
-# gr.themes.utils.colors.indigo (靛蓝色)
-# gr.themes.utils.colors.violet (紫罗兰色)
-# gr.themes.utils.colors.purple (紫色)
-# gr.themes.utils.colors.fuchsia (洋红色)
-# gr.themes.utils.colors.pink (粉红色)
-# gr.themes.utils.colors.rose (玫瑰色)
-
-def adjust_theme():
-    try: 
-        color_er = gr.themes.utils.colors.pink
-        set_theme = gr.themes.Default( 
-                        primary_hue=gr.themes.utils.colors.orange,
-                        neutral_hue=gr.themes.utils.colors.gray,
-                        font=["sans-serif", "Microsoft YaHei", "ui-sans-serif", "system-ui", "sans-serif", gr.themes.utils.fonts.GoogleFont("Source Sans Pro")], 
-                        font_mono=["ui-monospace", "Consolas", "monospace", gr.themes.utils.fonts.GoogleFont("IBM Plex Mono")])
-        set_theme.set(
-            # Colors
-            input_background_fill_dark="*neutral_800",
-            # Transition
-            button_transition="none",
-            # Shadows
-            button_shadow="*shadow_drop",
-            button_shadow_hover="*shadow_drop_lg",
-            button_shadow_active="*shadow_inset",
-            input_shadow="0 0 0 *shadow_spread transparent, *shadow_inset",
-            input_shadow_focus="0 0 0 *shadow_spread *secondary_50, *shadow_inset",
-            input_shadow_focus_dark="0 0 0 *shadow_spread *neutral_700, *shadow_inset",
-            checkbox_label_shadow="*shadow_drop",
-            block_shadow="*shadow_drop",
-            form_gap_width="1px",
-            # Button borders
-            input_border_width="1px",
-            input_background_fill="white",
-            # Gradients
-            stat_background_fill="linear-gradient(to right, *primary_400, *primary_200)",
-            stat_background_fill_dark="linear-gradient(to right, *primary_400, *primary_600)",
-            error_background_fill=f"linear-gradient(to right, {color_er.c100}, *background_fill_secondary)",
-            error_background_fill_dark="*background_fill_primary",
-            checkbox_label_background_fill="linear-gradient(to top, *neutral_50, white)",
-            checkbox_label_background_fill_dark="linear-gradient(to top, *neutral_900, *neutral_800)",
-            checkbox_label_background_fill_hover="linear-gradient(to top, *neutral_100, white)",
-            checkbox_label_background_fill_hover_dark="linear-gradient(to top, *neutral_900, *neutral_800)",
-            button_primary_background_fill="linear-gradient(to bottom right, *primary_100, *primary_300)",
-            button_primary_background_fill_dark="linear-gradient(to bottom right, *primary_500, *primary_600)",
-            button_primary_background_fill_hover="linear-gradient(to bottom right, *primary_100, *primary_200)",
-            button_primary_background_fill_hover_dark="linear-gradient(to bottom right, *primary_500, *primary_500)",
-            button_primary_border_color_dark="*primary_500",
-            button_secondary_background_fill="linear-gradient(to bottom right, *neutral_100, *neutral_200)",
-            button_secondary_background_fill_dark="linear-gradient(to bottom right, *neutral_600, *neutral_700)",
-            button_secondary_background_fill_hover="linear-gradient(to bottom right, *neutral_100, *neutral_100)",
-            button_secondary_background_fill_hover_dark="linear-gradient(to bottom right, *neutral_600, *neutral_600)",
-            button_cancel_background_fill=f"linear-gradient(to bottom right, {color_er.c100}, {color_er.c200})",
-            button_cancel_background_fill_dark=f"linear-gradient(to bottom right, {color_er.c600}, {color_er.c700})",
-            button_cancel_background_fill_hover=f"linear-gradient(to bottom right, {color_er.c100}, {color_er.c100})",
-            button_cancel_background_fill_hover_dark=f"linear-gradient(to bottom right, {color_er.c600}, {color_er.c600})",
-            button_cancel_border_color=color_er.c200,
-            button_cancel_border_color_dark=color_er.c600,
-            button_cancel_text_color=color_er.c600,
-            button_cancel_text_color_dark="white",
-        )
-    except: 
-        set_theme = None; print('gradio版本较旧, 不能自定义字体和颜色')
-    return set_theme
-
-advanced_css = """
-/* 设置表格的外边距为1em，内部单元格之间边框合并，空单元格显示. */
-.markdown-body table {
-    margin: 1em 0;
-    border-collapse: collapse;
-    empty-cells: show;
-}
-
-/* 设置表格单元格的内边距为5px，边框粗细为1.2px，颜色为--border-color-primary. */
-.markdown-body th, .markdown-body td {
-    border: 1.2px solid var(--border-color-primary);
-    padding: 5px;
-}
-
-/* 设置表头背景颜色为rgba(175,184,193,0.2)，透明度为0.2. */
-.markdown-body thead {
-    background-color: rgba(175,184,193,0.2);
-}
-
-/* 设置表头单元格的内边距为0.5em和0.2em. */
-.markdown-body thead th {
-    padding: .5em .2em;
-}
-
-/* 去掉列表前缀的默认间距，使其与文本线对齐. */
-.markdown-body ol, .markdown-body ul {
-    padding-inline-start: 2em !important;
-}
-
-/* 设定聊天气泡的样式，包括圆角、最大宽度和阴影等. */
-[class *= "message"] {
-    border-radius: var(--radius-xl) !important;
-    /* padding: var(--spacing-xl) !important; */
-    /* font-size: var(--text-md) !important; */
-    /* line-height: var(--line-md) !important; */
-    /* min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl)); */
-    /* min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl)); */
-}
-[data-testid = "bot"] {
-    max-width: 95%;
-    /* width: auto !important; */
-    border-bottom-left-radius: 0 !important;
-}
-[data-testid = "user"] {
-    max-width: 100%;
-    /* width: auto !important; */
-    border-bottom-right-radius: 0 !important;
-}
-
-/* 行内代码的背景设为淡灰色，设定圆角和间距. */
-.markdown-body code {
-    display: inline;
-    white-space: break-spaces;
-    border-radius: 6px;
-    margin: 0 2px 0 2px;
-    padding: .2em .4em .1em .4em;
-    background-color: rgba(175,184,193,0.2);
-}
-/* 设定代码块的样式，包括背景颜色、内、外边距、圆角。 */
-.markdown-body pre code {
-    display: block;
-    overflow: auto;
-    white-space: pre;
-    background-color: rgba(175,184,193,0.2);
-    border-radius: 10px;
-    padding: 1em;
-    margin: 1em 2em 1em 0.5em;
-}
-"""

spaces/Amrrs/DragGan-Inversion/torch_utils/ops/__init__.py

@@ -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

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/alt_diffusion/pipeline_alt_diffusion_img2img.py

@@ -1,747 +0,0 @@
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-import warnings
-from typing import Any, Callable, Dict, List, Optional, Union
-
-import numpy as np
-import PIL
-import torch
-from packaging import version
-from transformers import CLIPImageProcessor, XLMRobertaTokenizer
-
-from diffusers.utils import is_accelerate_available, is_accelerate_version
-
-from ...configuration_utils import FrozenDict
-from ...image_processor import VaeImageProcessor
-from ...loaders import FromSingleFileMixin, LoraLoaderMixin, TextualInversionLoaderMixin
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...schedulers import KarrasDiffusionSchedulers
-from ...utils import PIL_INTERPOLATION, deprecate, logging, randn_tensor, replace_example_docstring
-from ..pipeline_utils import DiffusionPipeline
-from ..stable_diffusion.safety_checker import StableDiffusionSafetyChecker
-from . import AltDiffusionPipelineOutput, RobertaSeriesModelWithTransformation
-
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
-    Examples:
-        ```py
-        >>> import requests
-        >>> import torch
-        >>> from PIL import Image
-        >>> from io import BytesIO
-
-        >>> from diffusers import AltDiffusionImg2ImgPipeline
-
-        >>> device = "cuda"
-        >>> model_id_or_path = "BAAI/AltDiffusion-m9"
-        >>> pipe = AltDiffusionImg2ImgPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
-        >>> pipe = pipe.to(device)
-
-        >>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
-
-        >>> response = requests.get(url)
-        >>> init_image = Image.open(BytesIO(response.content)).convert("RGB")
-        >>> init_image = init_image.resize((768, 512))
-
-        >>> # "A fantasy landscape, trending on artstation"
-        >>> prompt = "幻想风景, artstation"
-
-        >>> images = pipe(prompt=prompt, image=init_image, strength=0.75, guidance_scale=7.5).images
-        >>> images[0].save("幻想风景.png")
-        ```
-"""
-
-
-# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.preprocess
-def preprocess(image):
-    warnings.warn(
-        "The preprocess method is deprecated and will be removed in a future version. Please"
-        " use VaeImageProcessor.preprocess instead",
-        FutureWarning,
-    )
-    if isinstance(image, torch.Tensor):
-        return image
-    elif isinstance(image, PIL.Image.Image):
-        image = [image]
-
-    if isinstance(image[0], PIL.Image.Image):
-        w, h = image[0].size
-        w, h = (x - x % 8 for x in (w, h))  # resize to integer multiple of 8
-
-        image = [np.array(i.resize((w, h), resample=PIL_INTERPOLATION["lanczos"]))[None, :] for i in image]
-        image = np.concatenate(image, axis=0)
-        image = np.array(image).astype(np.float32) / 255.0
-        image = image.transpose(0, 3, 1, 2)
-        image = 2.0 * image - 1.0
-        image = torch.from_numpy(image)
-    elif isinstance(image[0], torch.Tensor):
-        image = torch.cat(image, dim=0)
-    return image
-
-
-# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline with Stable->Alt, CLIPTextModel->RobertaSeriesModelWithTransformation, CLIPTokenizer->XLMRobertaTokenizer, AltDiffusionSafetyChecker->StableDiffusionSafetyChecker
-class AltDiffusionImg2ImgPipeline(
-    DiffusionPipeline, TextualInversionLoaderMixin, LoraLoaderMixin, FromSingleFileMixin
-):
-    r"""
-    Pipeline for text-guided image-to-image generation using Alt Diffusion.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
-    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
-
-    The pipeline also inherits the following loading methods:
-        - [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings
-        - [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights
-        - [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights
-        - [`~loaders.FromSingleFileMixin.from_single_file`] for loading `.ckpt` files
-
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
-        text_encoder ([`~transformers.RobertaSeriesModelWithTransformation`]):
-            Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
-        tokenizer ([`~transformers.XLMRobertaTokenizer`]):
-            A `XLMRobertaTokenizer` to tokenize text.
-        unet ([`UNet2DConditionModel`]):
-            A `UNet2DConditionModel` 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`], or [`PNDMScheduler`].
-        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 more details
-            about a model's potential harms.
-        feature_extractor ([`~transformers.CLIPImageProcessor`]):
-            A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
-    """
-    _optional_components = ["safety_checker", "feature_extractor"]
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: RobertaSeriesModelWithTransformation,
-        tokenizer: XLMRobertaTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: KarrasDiffusionSchedulers,
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPImageProcessor,
-        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 Alt Diffusion license and do not expose unfiltered"
-                " results in services or applications open to the public. Both the 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."
-            )
-
-        is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse(
-            version.parse(unet.config._diffusers_version).base_version
-        ) < version.parse("0.9.0.dev0")
-        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
-        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
-            deprecation_message = (
-                "The configuration file of the unet has set the default `sample_size` to smaller than"
-                " 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
-                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
-                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
-                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
-                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
-                " 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 `unet/config.json` file"
-            )
-            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(unet.config)
-            new_config["sample_size"] = 64
-            unet._internal_dict = FrozenDict(new_config)
-
-        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.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor)
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    def enable_model_cpu_offload(self, gpu_id=0):
-        r"""
-        Offload all models to CPU to reduce memory usage with a low impact on performance. Moves one whole model at a
-        time to the GPU when its `forward` method is called, and the model remains in GPU until the next model runs.
-        Memory savings are lower than using `enable_sequential_cpu_offload`, but performance is much better due to the
-        iterative execution of the `unet`.
-        """
-        if is_accelerate_available() and is_accelerate_version(">=", "0.17.0.dev0"):
-            from accelerate import cpu_offload_with_hook
-        else:
-            raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.")
-
-        device = torch.device(f"cuda:{gpu_id}")
-
-        if self.device.type != "cpu":
-            self.to("cpu", silence_dtype_warnings=True)
-            torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)
-
-        hook = None
-        for cpu_offloaded_model in [self.text_encoder, self.unet, self.vae]:
-            _, hook = cpu_offload_with_hook(cpu_offloaded_model, device, prev_module_hook=hook)
-
-        if self.safety_checker is not None:
-            _, hook = cpu_offload_with_hook(self.safety_checker, device, prev_module_hook=hook)
-
-        # We'll offload the last model manually.
-        self.final_offload_hook = hook
-
-    def _encode_prompt(
-        self,
-        prompt,
-        device,
-        num_images_per_prompt,
-        do_classifier_free_guidance,
-        negative_prompt=None,
-        prompt_embeds: Optional[torch.FloatTensor] = None,
-        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
-        lora_scale: Optional[float] = None,
-    ):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-             prompt (`str` or `List[str]`, *optional*):
-                prompt to be encoded
-            device: (`torch.device`):
-                torch device
-            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]`, *optional*):
-                The prompt or prompts not to guide the image generation. If not defined, one has to pass
-                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
-                less than `1`).
-            prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
-                provided, text embeddings will be generated from `prompt` input argument.
-            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
-                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
-                argument.
-            lora_scale (`float`, *optional*):
-                A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.
-        """
-        # set lora scale so that monkey patched LoRA
-        # function of text encoder can correctly access it
-        if lora_scale is not None and isinstance(self, LoraLoaderMixin):
-            self._lora_scale = lora_scale
-
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        if prompt_embeds is None:
-            # textual inversion: procecss multi-vector tokens if necessary
-            if isinstance(self, TextualInversionLoaderMixin):
-                prompt = self.maybe_convert_prompt(prompt, self.tokenizer)
-
-            text_inputs = self.tokenizer(
-                prompt,
-                padding="max_length",
-                max_length=self.tokenizer.model_max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-            text_input_ids = text_inputs.input_ids
-            untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
-
-            if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
-                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}"
-                )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = text_inputs.attention_mask.to(device)
-            else:
-                attention_mask = None
-
-            prompt_embeds = self.text_encoder(
-                text_input_ids.to(device),
-                attention_mask=attention_mask,
-            )
-            prompt_embeds = prompt_embeds[0]
-
-        prompt_embeds = prompt_embeds.to(dtype=self.text_encoder.dtype, device=device)
-
-        bs_embed, seq_len, _ = prompt_embeds.shape
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
-        prompt_embeds = prompt_embeds.view(bs_embed * num_images_per_prompt, seq_len, -1)
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance and negative_prompt_embeds is None:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif prompt is not None and 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]
-            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
-
-            # textual inversion: procecss multi-vector tokens if necessary
-            if isinstance(self, TextualInversionLoaderMixin):
-                uncond_tokens = self.maybe_convert_prompt(uncond_tokens, self.tokenizer)
-
-            max_length = prompt_embeds.shape[1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = uncond_input.attention_mask.to(device)
-            else:
-                attention_mask = None
-
-            negative_prompt_embeds = self.text_encoder(
-                uncond_input.input_ids.to(device),
-                attention_mask=attention_mask,
-            )
-            negative_prompt_embeds = negative_prompt_embeds[0]
-
-        if do_classifier_free_guidance:
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = negative_prompt_embeds.shape[1]
-
-            negative_prompt_embeds = negative_prompt_embeds.to(dtype=self.text_encoder.dtype, device=device)
-
-            negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1)
-            negative_prompt_embeds = negative_prompt_embeds.view(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
-            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
-
-        return prompt_embeds
-
-    def run_safety_checker(self, image, device, dtype):
-        if self.safety_checker is None:
-            has_nsfw_concept = None
-        else:
-            if torch.is_tensor(image):
-                feature_extractor_input = self.image_processor.postprocess(image, output_type="pil")
-            else:
-                feature_extractor_input = self.image_processor.numpy_to_pil(image)
-            safety_checker_input = self.feature_extractor(feature_extractor_input, return_tensors="pt").to(device)
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
-            )
-        return image, has_nsfw_concept
-
-    def decode_latents(self, latents):
-        warnings.warn(
-            (
-                "The decode_latents method is deprecated and will be removed in a future version. Please"
-                " use VaeImageProcessor instead"
-            ),
-            FutureWarning,
-        )
-        latents = 1 / self.vae.config.scaling_factor * latents
-        image = self.vae.decode(latents, return_dict=False)[0]
-        image = (image / 2 + 0.5).clamp(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
-        image = image.cpu().permute(0, 2, 3, 1).float().numpy()
-        return image
-
-    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
-
-    def check_inputs(
-        self, prompt, strength, callback_steps, negative_prompt=None, prompt_embeds=None, negative_prompt_embeds=None
-    ):
-        if strength < 0 or strength > 1:
-            raise ValueError(f"The value of strength should in [0.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)}."
-            )
-
-        if prompt is not None and prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
-                " only forward one of the two."
-            )
-        elif prompt is None and prompt_embeds is None:
-            raise ValueError(
-                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
-            )
-        elif prompt is not None and (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 negative_prompt is not None and negative_prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
-                f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
-            )
-
-        if prompt_embeds is not None and negative_prompt_embeds is not None:
-            if prompt_embeds.shape != negative_prompt_embeds.shape:
-                raise ValueError(
-                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
-                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
-                    f" {negative_prompt_embeds.shape}."
-                )
-
-    def get_timesteps(self, num_inference_steps, strength, device):
-        # 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 * self.scheduler.order :]
-
-        return timesteps, num_inference_steps - t_start
-
-    def prepare_latents(self, image, timestep, batch_size, num_images_per_prompt, dtype, device, generator=None):
-        if not isinstance(image, (torch.Tensor, PIL.Image.Image, list)):
-            raise ValueError(
-                f"`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(image)}"
-            )
-
-        image = image.to(device=device, dtype=dtype)
-
-        batch_size = batch_size * num_images_per_prompt
-
-        if image.shape[1] == 4:
-            init_latents = image
-
-        else:
-            if isinstance(generator, list) and len(generator) != batch_size:
-                raise ValueError(
-                    f"You have passed a list of generators of length {len(generator)}, but requested an effective"
-                    f" batch size of {batch_size}. Make sure the batch size matches the length of the generators."
-                )
-
-            elif isinstance(generator, list):
-                init_latents = [
-                    self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
-                ]
-                init_latents = torch.cat(init_latents, dim=0)
-            else:
-                init_latents = self.vae.encode(image).latent_dist.sample(generator)
-
-            init_latents = self.vae.config.scaling_factor * init_latents
-
-        if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
-            # expand init_latents for batch_size
-            deprecation_message = (
-                f"You have passed {batch_size} text prompts (`prompt`), but only {init_latents.shape[0]} initial"
-                " images (`image`). Initial images are now duplicating to match the number of text prompts. Note"
-                " that this behavior is deprecated and will be removed in a version 1.0.0. Please make sure to update"
-                " your script to pass as many initial images as text prompts to suppress this warning."
-            )
-            deprecate("len(prompt) != len(image)", "1.0.0", deprecation_message, standard_warn=False)
-            additional_image_per_prompt = batch_size // init_latents.shape[0]
-            init_latents = torch.cat([init_latents] * additional_image_per_prompt, dim=0)
-        elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
-            raise ValueError(
-                f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
-            )
-        else:
-            init_latents = torch.cat([init_latents], dim=0)
-
-        shape = init_latents.shape
-        noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-
-        # get latents
-        init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
-        latents = init_latents
-
-        return latents
-
-    @torch.no_grad()
-    @replace_example_docstring(EXAMPLE_DOC_STRING)
-    def __call__(
-        self,
-        prompt: Union[str, List[str]] = None,
-        image: Union[
-            torch.FloatTensor,
-            PIL.Image.Image,
-            np.ndarray,
-            List[torch.FloatTensor],
-            List[PIL.Image.Image],
-            List[np.ndarray],
-        ] = 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,
-        eta: Optional[float] = 0.0,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        prompt_embeds: Optional[torch.FloatTensor] = None,
-        negative_prompt_embeds: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        cross_attention_kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        r"""
-        The call function to the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`.
-            image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, or `List[np.ndarray]`):
-                `Image` or tensor representing an image batch to be used as the starting point. Can also accept image
-                latents as `image`, but if passing latents directly it is not encoded again.
-            strength (`float`, *optional*, defaults to 0.8):
-                Indicates extent to transform the reference `image`. Must be between 0 and 1. `image` is used as a
-                starting point and more noise is added the higher the `strength`. The number of denoising steps depends
-                on the amount of noise initially added. When `strength` is 1, added noise is maximum and the denoising
-                process runs for the full number of iterations specified in `num_inference_steps`. A value of 1
-                essentially ignores `image`.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference. This parameter is modulated by `strength`.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                A higher guidance scale value encourages the model to generate images closely linked to the text
-                `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide what to not include in image generation. If not defined, you need to
-                pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.0):
-                Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies
-                to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers.
-            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
-                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
-                generation deterministic.
-            prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
-                provided, text embeddings are generated from the `prompt` input argument.
-            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
-                not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.AltDiffusionPipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that calls every `callback_steps` steps during inference. The function is called with the
-                following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function is called. If not specified, the callback is called at
-                every step.
-            cross_attention_kwargs (`dict`, *optional*):
-                A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in
-                [`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/cross_attention.py).
-
-        Examples:
-
-        Returns:
-            [`~pipelines.stable_diffusion.AltDiffusionPipelineOutput`] or `tuple`:
-                If `return_dict` is `True`, [`~pipelines.stable_diffusion.AltDiffusionPipelineOutput`] is returned,
-                otherwise a `tuple` is returned where the first element is a list with the generated images and the
-                second element is a list of `bool`s indicating whether the corresponding generated image contains
-                "not-safe-for-work" (nsfw) content.
-        """
-        # 1. Check inputs. Raise error if not correct
-        self.check_inputs(prompt, strength, callback_steps, negative_prompt, prompt_embeds, negative_prompt_embeds)
-
-        # 2. Define call parameters
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-        device = self._execution_device
-        # 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_encoder_lora_scale = (
-            cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None
-        )
-        prompt_embeds = self._encode_prompt(
-            prompt,
-            device,
-            num_images_per_prompt,
-            do_classifier_free_guidance,
-            negative_prompt,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            lora_scale=text_encoder_lora_scale,
-        )
-
-        # 4. Preprocess image
-        image = self.image_processor.preprocess(image)
-
-        # 5. set timesteps
-        self.scheduler.set_timesteps(num_inference_steps, device=device)
-        timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength, device)
-        latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)
-
-        # 6. Prepare latent variables
-        latents = self.prepare_latents(
-            image, latent_timestep, batch_size, num_images_per_prompt, prompt_embeds.dtype, device, generator
-        )
-
-        # 7. 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)
-
-        # 8. 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 = torch.cat([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=prompt_embeds,
-                    cross_attention_kwargs=cross_attention_kwargs,
-                    return_dict=False,
-                )[0]
-
-                # 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, return_dict=False)[0]
-
-                # 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)
-
-        if not output_type == "latent":
-            image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]
-            image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)
-        else:
-            image = latents
-            has_nsfw_concept = None
-
-        if has_nsfw_concept is None:
-            do_denormalize = [True] * image.shape[0]
-        else:
-            do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]
-
-        image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)
-
-        # Offload last model to CPU
-        if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None:
-            self.final_offload_hook.offload()
-
-        if not return_dict:
-            return (image, has_nsfw_concept)
-
-        return AltDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)

spaces/Andy1621/uniformer_image_detection/configs/res2net/cascade_rcnn_r2_101_fpn_20e_coco.py

@@ -1,4 +0,0 @@
-_base_ = '../cascade_rcnn/cascade_rcnn_r50_fpn_20e_coco.py'
-model = dict(
-    pretrained='open-mmlab://res2net101_v1d_26w_4s',
-    backbone=dict(type='Res2Net', depth=101, scales=4, base_width=26))

spaces/Andy1621/uniformer_image_segmentation/configs/gcnet/gcnet_r50-d8_769x769_40k_cityscapes.py

@@ -1,9 +0,0 @@
-_base_ = [
-    '../_base_/models/gcnet_r50-d8.py',
-    '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
-    decode_head=dict(align_corners=True),
-    auxiliary_head=dict(align_corners=True),
-    test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))

spaces/Andy1621/uniformer_video_demo/app.py

@@ -1,127 +0,0 @@
-import os
-
-import torch
-import numpy as np
-import torch.nn.functional as F
-import torchvision.transforms as T
-from PIL import Image
-from decord import VideoReader
-from decord import cpu
-from uniformer import uniformer_small
-from kinetics_class_index import kinetics_classnames
-from transforms import (
-    GroupNormalize, GroupScale, GroupCenterCrop, 
-    Stack, ToTorchFormatTensor
-)
-
-import gradio as gr
-from huggingface_hub import hf_hub_download
-
-# Device on which to run the model
-# Set to cuda to load on GPU
-device = "cpu"
-# os.system("wget https://cdn-lfs.huggingface.co/Andy1621/uniformer/d5fd7b0c49ee6a5422ef5d0c884d962c742003bfbd900747485eb99fa269d0db")
-model_path = hf_hub_download(repo_id="Andy1621/uniformer", filename="uniformer_small_k400_16x8.pth")
-# Pick a pretrained model 
-model = uniformer_small()
-# state_dict = torch.load('d5fd7b0c49ee6a5422ef5d0c884d962c742003bfbd900747485eb99fa269d0db', map_location='cpu')
-state_dict = torch.load(model_path, map_location='cpu')
-model.load_state_dict(state_dict)
-
-# Set to eval mode and move to desired device
-model = model.to(device)
-model = model.eval()
-
-# Create an id to label name mapping
-kinetics_id_to_classname = {}
-for k, v in kinetics_classnames.items():
-    kinetics_id_to_classname[k] = v
-
-
-def get_index(num_frames, num_segments=16, dense_sample_rate=8):
-    sample_range = num_segments * dense_sample_rate
-    sample_pos = max(1, 1 + num_frames - sample_range)
-    t_stride = dense_sample_rate
-    start_idx = 0 if sample_pos == 1 else sample_pos // 2
-    offsets = np.array([
-        (idx * t_stride + start_idx) %
-        num_frames for idx in range(num_segments)
-    ])
-    return offsets + 1
-
-
-def load_video(video_path):
-    vr = VideoReader(video_path, ctx=cpu(0))
-    num_frames = len(vr)
-    frame_indices = get_index(num_frames, 16, 16)
-
-    # transform
-    crop_size = 224
-    scale_size = 256
-    input_mean = [0.485, 0.456, 0.406]
-    input_std = [0.229, 0.224, 0.225]
-
-    transform = T.Compose([
-        GroupScale(int(scale_size)),
-        GroupCenterCrop(crop_size),
-        Stack(),
-        ToTorchFormatTensor(),
-        GroupNormalize(input_mean, input_std) 
-    ])
-
-    images_group = list()
-    for frame_index in frame_indices:
-        img = Image.fromarray(vr[frame_index].asnumpy())
-        images_group.append(img)
-    torch_imgs = transform(images_group)
-    return torch_imgs
-    
-
-def inference(video):
-    vid = load_video(video)
-    
-    # The model expects inputs of shape: B x C x H x W
-    TC, H, W = vid.shape
-    inputs = vid.reshape(1, TC//3, 3, H, W).permute(0, 2, 1, 3, 4)
-    
-    prediction = model(inputs)
-    prediction = F.softmax(prediction, dim=1).flatten()
-
-    return {kinetics_id_to_classname[str(i)]: float(prediction[i]) for i in range(400)}
-    
-
-def set_example_video(example: list) -> dict:
-    return gr.Video.update(value=example[0])
-
-
-demo = gr.Blocks()
-with demo:
-    gr.Markdown(
-        """
-        # UniFormer-S
-        Gradio demo for <a href='https://github.com/Sense-X/UniFormer' target='_blank'>UniFormer</a>: To use it, simply upload your video, or click one of the examples to load them. Read more at the links below.
-        """
-    )
-
-    with gr.Box():
-        with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        input_video = gr.Video(label='Input Video')
-                    with gr.Row():
-                        submit_button = gr.Button('Submit')
-                with gr.Column():
-                    label = gr.Label(num_top_classes=5)
-        with gr.Row():
-            example_videos = gr.Dataset(components=[input_video], samples=[['hitting_baseball.mp4'], ['hoverboarding.mp4'], ['yoga.mp4']])
-
-    gr.Markdown(
-        """
-        <p style='text-align: center'><a href='https://arxiv.org/abs/2201.04676' target='_blank'>[ICLR2022] UniFormer: Unified Transformer for Efficient Spatiotemporal Representation Learning</a> | <a href='https://github.com/Sense-X/UniFormer' target='_blank'>Github Repo</a></p>
-        """
-    )
-
-    submit_button.click(fn=inference, inputs=input_video, outputs=label)
-    example_videos.click(fn=set_example_video, inputs=example_videos, outputs=example_videos.components)
-
-demo.launch(enable_queue=True)

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/monkey_patch_gptq_lora.py

@@ -1,39 +0,0 @@
-# Copied from https://github.com/johnsmith0031/alpaca_lora_4bit
-
-from pathlib import Path
-
-import alpaca_lora_4bit.autograd_4bit as autograd_4bit
-from alpaca_lora_4bit.amp_wrapper import AMPWrapper
-from alpaca_lora_4bit.autograd_4bit import (
-    Autograd4bitQuantLinear,
-    load_llama_model_4bit_low_ram
-)
-from alpaca_lora_4bit.models import Linear4bitLt
-from alpaca_lora_4bit.monkeypatch.peft_tuners_lora_monkey_patch import (
-    replace_peft_model_with_int4_lora_model
-)
-
-from modules import shared
-from modules.GPTQ_loader import find_quantized_model_file
-
-replace_peft_model_with_int4_lora_model()
-
-
-def load_model_llama(model_name):
-    config_path = str(Path(f'{shared.args.model_dir}/{model_name}'))
-    model_path = str(find_quantized_model_file(model_name))
-    model, tokenizer = load_llama_model_4bit_low_ram(config_path, model_path, groupsize=shared.args.groupsize, is_v1_model=False)
-    for _, m in model.named_modules():
-        if isinstance(m, Autograd4bitQuantLinear) or isinstance(m, Linear4bitLt):
-            if m.is_v1_model:
-                m.zeros = m.zeros.half()
-            m.scales = m.scales.half()
-            m.bias = m.bias.half()
-
-    autograd_4bit.auto_switch = True
-
-    model.half()
-    wrapper = AMPWrapper(model)
-    wrapper.apply_generate()
-
-    return model, tokenizer

spaces/Anonymous-sub/Rerender/ControlNet/annotator/midas/utils.py

@@ -1,189 +0,0 @@
-"""Utils for monoDepth."""
-import sys
-import re
-import numpy as np
-import cv2
-import torch
-
-
-def read_pfm(path):
-    """Read pfm file.
-
-    Args:
-        path (str): path to file
-
-    Returns:
-        tuple: (data, scale)
-    """
-    with open(path, "rb") as file:
-
-        color = None
-        width = None
-        height = None
-        scale = None
-        endian = None
-
-        header = file.readline().rstrip()
-        if header.decode("ascii") == "PF":
-            color = True
-        elif header.decode("ascii") == "Pf":
-            color = False
-        else:
-            raise Exception("Not a PFM file: " + path)
-
-        dim_match = re.match(r"^(\d+)\s(\d+)\s$", file.readline().decode("ascii"))
-        if dim_match:
-            width, height = list(map(int, dim_match.groups()))
-        else:
-            raise Exception("Malformed PFM header.")
-
-        scale = float(file.readline().decode("ascii").rstrip())
-        if scale < 0:
-            # little-endian
-            endian = "<"
-            scale = -scale
-        else:
-            # big-endian
-            endian = ">"
-
-        data = np.fromfile(file, endian + "f")
-        shape = (height, width, 3) if color else (height, width)
-
-        data = np.reshape(data, shape)
-        data = np.flipud(data)
-
-        return data, scale
-
-
-def write_pfm(path, image, scale=1):
-    """Write pfm file.
-
-    Args:
-        path (str): pathto file
-        image (array): data
-        scale (int, optional): Scale. Defaults to 1.
-    """
-
-    with open(path, "wb") as file:
-        color = None
-
-        if image.dtype.name != "float32":
-            raise Exception("Image dtype must be float32.")
-
-        image = np.flipud(image)
-
-        if len(image.shape) == 3 and image.shape[2] == 3:  # color image
-            color = True
-        elif (
-            len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
-        ):  # greyscale
-            color = False
-        else:
-            raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
-
-        file.write("PF\n" if color else "Pf\n".encode())
-        file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
-
-        endian = image.dtype.byteorder
-
-        if endian == "<" or endian == "=" and sys.byteorder == "little":
-            scale = -scale
-
-        file.write("%f\n".encode() % scale)
-
-        image.tofile(file)
-
-
-def read_image(path):
-    """Read image and output RGB image (0-1).
-
-    Args:
-        path (str): path to file
-
-    Returns:
-        array: RGB image (0-1)
-    """
-    img = cv2.imread(path)
-
-    if img.ndim == 2:
-        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
-
-    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255.0
-
-    return img
-
-
-def resize_image(img):
-    """Resize image and make it fit for network.
-
-    Args:
-        img (array): image
-
-    Returns:
-        tensor: data ready for network
-    """
-    height_orig = img.shape[0]
-    width_orig = img.shape[1]
-
-    if width_orig > height_orig:
-        scale = width_orig / 384
-    else:
-        scale = height_orig / 384
-
-    height = (np.ceil(height_orig / scale / 32) * 32).astype(int)
-    width = (np.ceil(width_orig / scale / 32) * 32).astype(int)
-
-    img_resized = cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA)
-
-    img_resized = (
-        torch.from_numpy(np.transpose(img_resized, (2, 0, 1))).contiguous().float()
-    )
-    img_resized = img_resized.unsqueeze(0)
-
-    return img_resized
-
-
-def resize_depth(depth, width, height):
-    """Resize depth map and bring to CPU (numpy).
-
-    Args:
-        depth (tensor): depth
-        width (int): image width
-        height (int): image height
-
-    Returns:
-        array: processed depth
-    """
-    depth = torch.squeeze(depth[0, :, :, :]).to("cpu")
-
-    depth_resized = cv2.resize(
-        depth.numpy(), (width, height), interpolation=cv2.INTER_CUBIC
-    )
-
-    return depth_resized
-
-def write_depth(path, depth, bits=1):
-    """Write depth map to pfm and png file.
-
-    Args:
-        path (str): filepath without extension
-        depth (array): depth
-    """
-    write_pfm(path + ".pfm", depth.astype(np.float32))
-
-    depth_min = depth.min()
-    depth_max = depth.max()
-
-    max_val = (2**(8*bits))-1
-
-    if depth_max - depth_min > np.finfo("float").eps:
-        out = max_val * (depth - depth_min) / (depth_max - depth_min)
-    else:
-        out = np.zeros(depth.shape, dtype=depth.type)
-
-    if bits == 1:
-        cv2.imwrite(path + ".png", out.astype("uint8"))
-    elif bits == 2:
-        cv2.imwrite(path + ".png", out.astype("uint16"))
-
-    return

spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/README.md

@@ -1,174 +0,0 @@
----
-license: mit
-sdk: gradio
-emoji: 😻
-colorTo: green
-pinned: true
----
-<div align="center">
-  <img src="./.asset/grounding_dino_logo.png" width="30%">
-</div>
-
-# :sauropod: Grounding DINO 
-
-[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/grounding-dino-marrying-dino-with-grounded/zero-shot-object-detection-on-mscoco)](https://paperswithcode.com/sota/zero-shot-object-detection-on-mscoco?p=grounding-dino-marrying-dino-with-grounded) [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/grounding-dino-marrying-dino-with-grounded/zero-shot-object-detection-on-odinw)](https://paperswithcode.com/sota/zero-shot-object-detection-on-odinw?p=grounding-dino-marrying-dino-with-grounded) \
-[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/grounding-dino-marrying-dino-with-grounded/object-detection-on-coco-minival)](https://paperswithcode.com/sota/object-detection-on-coco-minival?p=grounding-dino-marrying-dino-with-grounded) [![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/grounding-dino-marrying-dino-with-grounded/object-detection-on-coco)](https://paperswithcode.com/sota/object-detection-on-coco?p=grounding-dino-marrying-dino-with-grounded)
-
-
-**[IDEA-CVR, IDEA-Research](https://github.com/IDEA-Research)** 
-
-[Shilong Liu](http://www.lsl.zone/), [Zhaoyang Zeng](https://scholar.google.com/citations?user=U_cvvUwAAAAJ&hl=zh-CN&oi=ao), [Tianhe Ren](https://rentainhe.github.io/), [Feng Li](https://scholar.google.com/citations?user=ybRe9GcAAAAJ&hl=zh-CN), [Hao Zhang](https://scholar.google.com/citations?user=B8hPxMQAAAAJ&hl=zh-CN), [Jie Yang](https://github.com/yangjie-cv), [Chunyuan Li](https://scholar.google.com/citations?user=Zd7WmXUAAAAJ&hl=zh-CN&oi=ao), [Jianwei Yang](https://jwyang.github.io/), [Hang Su](https://scholar.google.com/citations?hl=en&user=dxN1_X0AAAAJ&view_op=list_works&sortby=pubdate), [Jun Zhu](https://scholar.google.com/citations?hl=en&user=axsP38wAAAAJ), [Lei Zhang](https://www.leizhang.org/)<sup>:email:</sup>.
-
-
-[[`Paper`](https://arxiv.org/abs/2303.05499)] [[`Demo`](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo)] [[`BibTex`](#black_nib-citation)]
-
-
-PyTorch implementation and pretrained models for Grounding DINO. For details, see the paper **[Grounding DINO: Marrying DINO with Grounded Pre-Training for Open-Set Object Detection](https://arxiv.org/abs/2303.05499)**.
-
-## :sun_with_face: Helpful Tutorial
-
-- :grapes: [[Read our arXiv Paper](https://arxiv.org/abs/2303.05499)]
-- :apple:  [[Watch our simple introduction video on YouTube](https://youtu.be/wxWDt5UiwY8)]
-- :blossom:   &nbsp;[[Try the Colab Demo](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-grounding-dino.ipynb)]
-- :sunflower: [[Try our Official Huggingface Demo](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo)]
-- :maple_leaf: [[Watch the Step by Step Tutorial about GroundingDINO by Roboflow AI](https://youtu.be/cMa77r3YrDk)]
-- :mushroom: [[GroundingDINO: Automated Dataset Annotation and Evaluation by Roboflow AI](https://youtu.be/C4NqaRBz_Kw)]
-- :hibiscus: [[Accelerate Image Annotation with SAM and GroundingDINO by Roboflow AI](https://youtu.be/oEQYStnF2l8)]
-- :white_flower: [[Autodistill: Train YOLOv8 with ZERO Annotations based on Grounding-DINO and Grounded-SAM by Roboflow AI](https://github.com/autodistill/autodistill)]
-
-<!-- Grounding DINO Methods | 
-[![arXiv](https://img.shields.io/badge/arXiv-2303.05499-b31b1b.svg)](https://arxiv.org/abs/2303.05499) 
-[![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/wxWDt5UiwY8) -->
-
-<!-- Grounding DINO Demos |
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-grounding-dino.ipynb) -->
-<!-- [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/cMa77r3YrDk)
-[![HuggingFace space](https://img.shields.io/badge/🤗-HuggingFace%20Space-cyan.svg)](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo)
-[![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/oEQYStnF2l8)
-[![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://youtu.be/C4NqaRBz_Kw) -->
-
-## :sparkles: Highlight Projects
-
-- [Semantic-SAM: a universal image segmentation model to enable segment and recognize anything at any desired granularity.](https://github.com/UX-Decoder/Semantic-SAM), 
-- [DetGPT: Detect What You Need via Reasoning](https://github.com/OptimalScale/DetGPT)
-- [Grounded-SAM: Marrying Grounding DINO with Segment Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything)
-- [Grounding DINO with Stable Diffusion](demo/image_editing_with_groundingdino_stablediffusion.ipynb)
-- [Grounding DINO with GLIGEN for Controllable Image Editing](demo/image_editing_with_groundingdino_gligen.ipynb)
-- [OpenSeeD: A Simple and Strong Openset Segmentation Model](https://github.com/IDEA-Research/OpenSeeD)
-- [SEEM: Segment Everything Everywhere All at Once](https://github.com/UX-Decoder/Segment-Everything-Everywhere-All-At-Once)
-- [X-GPT: Conversational Visual Agent supported by X-Decoder](https://github.com/microsoft/X-Decoder/tree/xgpt)
-- [GLIGEN: Open-Set Grounded Text-to-Image Generation](https://github.com/gligen/GLIGEN)
-- [LLaVA: Large Language and Vision Assistant](https://github.com/haotian-liu/LLaVA)
-
-<!-- Extensions | [Grounding DINO with Segment Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything); [Grounding DINO with Stable Diffusion](demo/image_editing_with_groundingdino_stablediffusion.ipynb); [Grounding DINO with GLIGEN](demo/image_editing_with_groundingdino_gligen.ipynb)  -->
-
-
-
-<!-- Official PyTorch implementation of [Grounding DINO](https://arxiv.org/abs/2303.05499), a stronger open-set object detector. Code is available now! -->
-
-
-## :bulb: Highlight
-
-- **Open-Set Detection.** Detect **everything** with language!
-- **High Performancce.** COCO zero-shot **52.5 AP** (training without COCO data!). COCO fine-tune **63.0 AP**.
-- **Flexible.** Collaboration with Stable Diffusion for Image Editting.
-
-
-
-
-## :fire: News
-- **`2023/07/18`**: We release [Semantic-SAM](https://github.com/UX-Decoder/Semantic-SAM), a universal image segmentation model to enable segment and recognize anything at any desired granularity. **Code** and **checkpoint** are available!
-- **`2023/06/17`**: We provide an example to evaluate Grounding DINO on COCO zero-shot performance.
-- **`2023/04/15`**: Refer to [CV in the Wild Readings](https://github.com/Computer-Vision-in-the-Wild/CVinW_Readings) for those who are interested in open-set recognition!
-- **`2023/04/08`**: We release [demos](demo/image_editing_with_groundingdino_gligen.ipynb) to combine [Grounding DINO](https://arxiv.org/abs/2303.05499) with [GLIGEN](https://github.com/gligen/GLIGEN)  for more controllable image editings.
-- **`2023/04/08`**: We release [demos](demo/image_editing_with_groundingdino_stablediffusion.ipynb) to combine [Grounding DINO](https://arxiv.org/abs/2303.05499) with [Stable Diffusion](https://github.com/Stability-AI/StableDiffusion) for image editings.
-- **`2023/04/06`**: We build a new demo by marrying GroundingDINO with [Segment-Anything](https://github.com/facebookresearch/segment-anything) named **[Grounded-Segment-Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything)** aims to support segmentation in GroundingDINO.
-- **`2023/03/28`**: A YouTube [video](https://youtu.be/cMa77r3YrDk) about Grounding DINO and basic object detection prompt engineering. [[SkalskiP](https://github.com/SkalskiP)]
-- **`2023/03/28`**: Add a [demo](https://huggingface.co/spaces/ShilongLiu/Grounding_DINO_demo) on Hugging Face Space!
-- **`2023/03/27`**: Support CPU-only mode. Now the model can run on machines without GPUs.
-- **`2023/03/25`**: A [demo](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-grounding-dino.ipynb) for Grounding DINO is available at Colab. [[SkalskiP](https://github.com/SkalskiP)]
-- **`2023/03/22`**: Code is available Now!
-
-<details open>
-<summary><font size="4">
-Description
-</font></summary>
- <a href="https://arxiv.org/abs/2303.05499">Paper</a> introduction.
-<img src=".asset/hero_figure.png" alt="ODinW" width="100%">
-Marrying <a href="https://github.com/IDEA-Research/GroundingDINO">Grounding DINO</a> and <a href="https://github.com/gligen/GLIGEN">GLIGEN</a>
-<img src="https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/GD_GLIGEN.png" alt="gd_gligen" width="100%">
-</details>
-
-## :star: Explanations/Tips for Grounding DINO Inputs and Outputs
-- Grounding DINO accepts an `(image, text)` pair as inputs.
-- It outputs `900` (by default) object boxes. Each box has similarity scores across all input words. (as shown in Figures below.)
-- We defaultly choose the boxes whose highest similarities are higher than a `box_threshold`.
-- We extract the words whose similarities are higher than the `text_threshold` as predicted labels.
-- If you want to obtain objects of specific phrases, like the `dogs` in the sentence `two dogs with a stick.`, you can select the boxes with highest text similarities with `dogs` as final outputs. 
-- Note that each word can be split to **more than one** tokens with different tokenlizers. The number of words in a sentence may not equal to the number of text tokens.
-- We suggest separating different category names with `.` for Grounding DINO.
-![model_explain1](.asset/model_explan1.PNG)
-![model_explain2](.asset/model_explan2.PNG)
-
-
-## :medal_military: Results
-
-<details open>
-<summary><font size="4">
-COCO Object Detection Results
-</font></summary>
-<img src=".asset/COCO.png" alt="COCO" width="100%">
-</details>
-
-<details open>
-<summary><font size="4">
-ODinW Object Detection Results
-</font></summary>
-<img src=".asset/ODinW.png" alt="ODinW" width="100%">
-</details>
-
-<details open>
-<summary><font size="4">
-Marrying Grounding DINO with <a href="https://github.com/Stability-AI/StableDiffusion">Stable Diffusion</a> for Image Editing
-</font></summary>
-See our example <a href="https://github.com/IDEA-Research/GroundingDINO/blob/main/demo/image_editing_with_groundingdino_stablediffusion.ipynb">notebook</a> for more details.
-<img src=".asset/GD_SD.png" alt="GD_SD" width="100%">
-</details>
-
-
-<details open>
-<summary><font size="4">
-Marrying Grounding DINO with <a href="https://github.com/gligen/GLIGEN">GLIGEN</a> for more Detailed Image Editing.
-</font></summary>
-See our example <a href="https://github.com/IDEA-Research/GroundingDINO/blob/main/demo/image_editing_with_groundingdino_gligen.ipynb">notebook</a> for more details.
-<img src=".asset/GD_GLIGEN.png" alt="GD_GLIGEN" width="100%">
-</details>
-
-## :sauropod: Model: Grounding DINO
-
-Includes: a text backbone, an image backbone, a feature enhancer, a language-guided query selection, and a cross-modality decoder.
-
-![arch](.asset/arch.png)
-
-
-## :hearts: Acknowledgement
-
-Our model is related to [DINO](https://github.com/IDEA-Research/DINO) and [GLIP](https://github.com/microsoft/GLIP). Thanks for their great work!
-
-We also thank great previous work including DETR, Deformable DETR, SMCA, Conditional DETR, Anchor DETR, Dynamic DETR, DAB-DETR, DN-DETR, etc. More related work are available at [Awesome Detection Transformer](https://github.com/IDEACVR/awesome-detection-transformer). A new toolbox [detrex](https://github.com/IDEA-Research/detrex) is available as well.
-
-Thanks [Stable Diffusion](https://github.com/Stability-AI/StableDiffusion) and [GLIGEN](https://github.com/gligen/GLIGEN) for their awesome models.
-
-
-## :black_nib: Citation
-
-If you find our work helpful for your research, please consider citing the following BibTeX entry.   
-
-```bibtex
-@article{liu2023grounding,
-  title={Grounding dino: Marrying dino with grounded pre-training for open-set object detection},
-  author={Liu, Shilong and Zeng, Zhaoyang and Ren, Tianhe and Li, Feng and Zhang, Hao and Yang, Jie and Li, Chunyuan and Yang, Jianwei and Su, Hang and Zhu, Jun and others},
-  journal={arXiv preprint arXiv:2303.05499},
-  year={2023}
-}
-```

spaces/Ash2219/AIchatbot/app.py

@@ -1,164 +0,0 @@
-import os
-import re
-import requests
-import json
-import gradio as gr
-from langchain.chat_models import ChatOpenAI
-from langchain import LLMChain, PromptTemplate
-from langchain.memory import ConversationBufferMemory
-
-OPENAI_API_KEY=os.getenv('OPENAI_API_KEY')
-PLAY_HT_API_KEY=os.getenv('PLAY_HT_API_KEY')
-PLAY_HT_USER_ID=os.getenv('PLAY_HT_USER_ID')
-
-PLAY_HT_VOICE_ID=os.getenv('PLAY_HT_VOICE_ID')
-play_ht_api_get_audio_url = "https://play.ht/api/v2/tts"
-
-
-template = """You are a helpful assistant to answer user queries.
-{chat_history}
-User: {user_message}
-Chatbot:"""
-
-prompt = PromptTemplate(
-    input_variables=["chat_history", "user_message"], template=template
-)
-
-memory = ConversationBufferMemory(memory_key="chat_history")
-
-llm_chain = LLMChain(
-    llm=ChatOpenAI(temperature='0.5', model_name="gpt-3.5-turbo"),
-    prompt=prompt,
-    verbose=True,
-    memory=memory,
-)
-
-headers = {
-      "accept": "text/event-stream",
-      "content-type": "application/json",
-      "AUTHORIZATION": "Bearer "+ PLAY_HT_API_KEY,
-      "X-USER-ID": PLAY_HT_USER_ID
-}
-
-
-def get_payload(text):
-  return {
-    "text": text,
-    "voice": PLAY_HT_VOICE_ID,
-    "quality": "medium",
-    "output_format": "mp3",
-    "speed": 1,
-    "sample_rate": 24000,
-    "seed": None,
-    "temperature": None
-  }
-
-def get_generated_audio(text):
-  payload = get_payload(text)
-  generated_response = {}
-  try:
-      response = requests.post(play_ht_api_get_audio_url, json=payload, headers=headers)
-      response.raise_for_status()
-      generated_response["type"]= 'SUCCESS'
-      generated_response["response"] = response.text
-  except requests.exceptions.RequestException as e:
-      generated_response["type"]= 'ERROR'
-      try:
-        response_text = json.loads(response.text)
-        if response_text['error_message']:
-          generated_response["response"] = response_text['error_message']
-        else:
-          generated_response["response"] = response.text
-      except Exception as e:
-        generated_response["response"] = response.text
-  except Exception as e:
-    generated_response["type"]= 'ERROR'
-    generated_response["response"] = response.text
-  return generated_response
-
-def extract_urls(text):
-    # Define the regex pattern for URLs
-    url_pattern = r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+[/\w\.-]*'
-
-    # Find all occurrences of URLs in the text
-    urls = re.findall(url_pattern, text)
-
-    return urls
-
-def get_audio_reply_for_question(text):
-  generated_audio_event = get_generated_audio(text)
-  #From get_generated_audio, you will get events in a string format, from that we need to extract the url
-  final_response = {
-      "audio_url": '',
-      "message": ''
-  }
-  if generated_audio_event["type"] == 'SUCCESS':
-    audio_urls = extract_urls(generated_audio_event["response"])
-    if len(audio_urls) == 0:
-      final_response['message'] = "No audio file link found in generated event"
-    else:
-      final_response['audio_url'] = audio_urls[-1]
-  else:
-    final_response['message'] = generated_audio_event['response']
-  return final_response
-
-def download_url(url):
-    try:
-        # Send a GET request to the URL to fetch the content
-        final_response = {
-            'content':'',
-            'error':''
-        }
-        response = requests.get(url)
-        # Check if the request was successful (status code 200)
-        if response.status_code == 200:
-            final_response['content'] = response.content
-        else:
-            final_response['error'] = f"Failed to download the URL. Status code: {response.status_code}"
-    except Exception as e:
-        final_response['error'] = f"Failed to download the URL. Error: {e}"
-    return final_response
-
-def get_filename_from_url(url):
-    # Use os.path.basename() to extract the file name from the URL
-    file_name = os.path.basename(url)
-    return file_name
-
-def get_text_response(user_message):
-    response = llm_chain.predict(user_message = user_message)
-    return response
-
-def get_text_response_and_audio_response(user_message):
-    response = get_text_response(user_message) # Getting the reply from Open AI
-    audio_reply_for_question_response = get_audio_reply_for_question(response)
-    final_response = {
-        'output_file_path': '',
-        'message':''
-    }
-    audio_url = audio_reply_for_question_response['audio_url']
-    if audio_url:
-      output_file_path=get_filename_from_url(audio_url)
-      download_url_response = download_url(audio_url)
-      audio_content = download_url_response['content']
-      if audio_content:
-        with open(output_file_path, "wb") as audio_file:
-          audio_file.write(audio_content)
-          final_response['output_file_path'] = output_file_path
-      else:
-          final_response['message'] = download_url_response['error']
-    else:
-      final_response['message'] = audio_reply_for_question_response['message']
-    return final_response
-
-def chat_bot_response(message, history):
-    text_and_audio_response = get_text_response_and_audio_response(message)
-    output_file_path = text_and_audio_response['output_file_path']
-    if output_file_path:
-      return (text_and_audio_response['output_file_path'],)
-    else:
-      return text_and_audio_response['message']
-
-demo = gr.ChatInterface(chat_bot_response,examples=["How are you doing?","What are your interests?","Which places do you like to visit?"])
-
-if __name__ == "__main__":
-    demo.launch() #To create a public link, set `share=True` in `launch()`. To enable errors and logs, set `debug=True` in `launch()`.

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/rich/control.py

@@ -1,225 +0,0 @@
-import sys
-import time
-from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Union
-
-if sys.version_info >= (3, 8):
-    from typing import Final
-else:
-    from pip._vendor.typing_extensions import Final  # pragma: no cover
-
-from .segment import ControlCode, ControlType, Segment
-
-if TYPE_CHECKING:
-    from .console import Console, ConsoleOptions, RenderResult
-
-STRIP_CONTROL_CODES: Final = [
-    7,  # Bell
-    8,  # Backspace
-    11,  # Vertical tab
-    12,  # Form feed
-    13,  # Carriage return
-]
-_CONTROL_STRIP_TRANSLATE: Final = {
-    _codepoint: None for _codepoint in STRIP_CONTROL_CODES
-}
-
-CONTROL_ESCAPE: Final = {
-    7: "\\a",
-    8: "\\b",
-    11: "\\v",
-    12: "\\f",
-    13: "\\r",
-}
-
-CONTROL_CODES_FORMAT: Dict[int, Callable[..., str]] = {
-    ControlType.BELL: lambda: "\x07",
-    ControlType.CARRIAGE_RETURN: lambda: "\r",
-    ControlType.HOME: lambda: "\x1b[H",
-    ControlType.CLEAR: lambda: "\x1b[2J",
-    ControlType.ENABLE_ALT_SCREEN: lambda: "\x1b[?1049h",
-    ControlType.DISABLE_ALT_SCREEN: lambda: "\x1b[?1049l",
-    ControlType.SHOW_CURSOR: lambda: "\x1b[?25h",
-    ControlType.HIDE_CURSOR: lambda: "\x1b[?25l",
-    ControlType.CURSOR_UP: lambda param: f"\x1b[{param}A",
-    ControlType.CURSOR_DOWN: lambda param: f"\x1b[{param}B",
-    ControlType.CURSOR_FORWARD: lambda param: f"\x1b[{param}C",
-    ControlType.CURSOR_BACKWARD: lambda param: f"\x1b[{param}D",
-    ControlType.CURSOR_MOVE_TO_COLUMN: lambda param: f"\x1b[{param+1}G",
-    ControlType.ERASE_IN_LINE: lambda param: f"\x1b[{param}K",
-    ControlType.CURSOR_MOVE_TO: lambda x, y: f"\x1b[{y+1};{x+1}H",
-    ControlType.SET_WINDOW_TITLE: lambda title: f"\x1b]0;{title}\x07",
-}
-
-
-class Control:
-    """A renderable that inserts a control code (non printable but may move cursor).
-
-    Args:
-        *codes (str): Positional arguments are either a :class:`~rich.segment.ControlType` enum or a
-            tuple of ControlType and an integer parameter
-    """
-
-    __slots__ = ["segment"]
-
-    def __init__(self, *codes: Union[ControlType, ControlCode]) -> None:
-        control_codes: List[ControlCode] = [
-            (code,) if isinstance(code, ControlType) else code for code in codes
-        ]
-        _format_map = CONTROL_CODES_FORMAT
-        rendered_codes = "".join(
-            _format_map[code](*parameters) for code, *parameters in control_codes
-        )
-        self.segment = Segment(rendered_codes, None, control_codes)
-
-    @classmethod
-    def bell(cls) -> "Control":
-        """Ring the 'bell'."""
-        return cls(ControlType.BELL)
-
-    @classmethod
-    def home(cls) -> "Control":
-        """Move cursor to 'home' position."""
-        return cls(ControlType.HOME)
-
-    @classmethod
-    def move(cls, x: int = 0, y: int = 0) -> "Control":
-        """Move cursor relative to current position.
-
-        Args:
-            x (int): X offset.
-            y (int): Y offset.
-
-        Returns:
-            ~Control: Control object.
-
-        """
-
-        def get_codes() -> Iterable[ControlCode]:
-            control = ControlType
-            if x:
-                yield (
-                    control.CURSOR_FORWARD if x > 0 else control.CURSOR_BACKWARD,
-                    abs(x),
-                )
-            if y:
-                yield (
-                    control.CURSOR_DOWN if y > 0 else control.CURSOR_UP,
-                    abs(y),
-                )
-
-        control = cls(*get_codes())
-        return control
-
-    @classmethod
-    def move_to_column(cls, x: int, y: int = 0) -> "Control":
-        """Move to the given column, optionally add offset to row.
-
-        Returns:
-            x (int): absolute x (column)
-            y (int): optional y offset (row)
-
-        Returns:
-            ~Control: Control object.
-        """
-
-        return (
-            cls(
-                (ControlType.CURSOR_MOVE_TO_COLUMN, x),
-                (
-                    ControlType.CURSOR_DOWN if y > 0 else ControlType.CURSOR_UP,
-                    abs(y),
-                ),
-            )
-            if y
-            else cls((ControlType.CURSOR_MOVE_TO_COLUMN, x))
-        )
-
-    @classmethod
-    def move_to(cls, x: int, y: int) -> "Control":
-        """Move cursor to absolute position.
-
-        Args:
-            x (int): x offset (column)
-            y (int): y offset (row)
-
-        Returns:
-            ~Control: Control object.
-        """
-        return cls((ControlType.CURSOR_MOVE_TO, x, y))
-
-    @classmethod
-    def clear(cls) -> "Control":
-        """Clear the screen."""
-        return cls(ControlType.CLEAR)
-
-    @classmethod
-    def show_cursor(cls, show: bool) -> "Control":
-        """Show or hide the cursor."""
-        return cls(ControlType.SHOW_CURSOR if show else ControlType.HIDE_CURSOR)
-
-    @classmethod
-    def alt_screen(cls, enable: bool) -> "Control":
-        """Enable or disable alt screen."""
-        if enable:
-            return cls(ControlType.ENABLE_ALT_SCREEN, ControlType.HOME)
-        else:
-            return cls(ControlType.DISABLE_ALT_SCREEN)
-
-    @classmethod
-    def title(cls, title: str) -> "Control":
-        """Set the terminal window title
-
-        Args:
-            title (str): The new terminal window title
-        """
-        return cls((ControlType.SET_WINDOW_TITLE, title))
-
-    def __str__(self) -> str:
-        return self.segment.text
-
-    def __rich_console__(
-        self, console: "Console", options: "ConsoleOptions"
-    ) -> "RenderResult":
-        if self.segment.text:
-            yield self.segment
-
-
-def strip_control_codes(
-    text: str, _translate_table: Dict[int, None] = _CONTROL_STRIP_TRANSLATE
-) -> str:
-    """Remove control codes from text.
-
-    Args:
-        text (str): A string possibly contain control codes.
-
-    Returns:
-        str: String with control codes removed.
-    """
-    return text.translate(_translate_table)
-
-
-def escape_control_codes(
-    text: str,
-    _translate_table: Dict[int, str] = CONTROL_ESCAPE,
-) -> str:
-    """Replace control codes with their "escaped" equivalent in the given text.
-    (e.g. "\b" becomes "\\b")
-
-    Args:
-        text (str): A string possibly containing control codes.
-
-    Returns:
-        str: String with control codes replaced with their escaped version.
-    """
-    return text.translate(_translate_table)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from pip._vendor.rich.console import Console
-
-    console = Console()
-    console.print("Look at the title of your terminal window ^")
-    # console.print(Control((ControlType.SET_WINDOW_TITLE, "Hello, world!")))
-    for i in range(10):
-        console.set_window_title("🚀 Loading" + "." * i)
-        time.sleep(0.5)

spaces/Bart92/RVC_HF/Dockerfile

@@ -1,29 +0,0 @@
-# syntax=docker/dockerfile:1
-
-FROM python:3.10-bullseye
-
-EXPOSE 7865
-
-WORKDIR /app
-
-COPY . .
-
-RUN apt update && apt install -y -qq ffmpeg aria2 && apt clean
-
-RUN pip3 install --no-cache-dir -r requirements.txt
-
-RUN aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/D40k.pth -d assets/pretrained_v2/ -o D40k.pth
-RUN aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/G40k.pth -d assets/pretrained_v2/ -o G40k.pth
-RUN aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0D40k.pth -d assets/pretrained_v2/ -o f0D40k.pth
-RUN aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/pretrained_v2/f0G40k.pth -d assets/pretrained_v2/ -o f0G40k.pth
-
-RUN aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/uvr5_weights/HP2-人声vocals+非人声instrumentals.pth -d assets/uvr5_weights/ -o HP2-人声vocals+非人声instrumentals.pth
-RUN aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/uvr5_weights/HP5-主旋律人声vocals+其他instrumentals.pth -d assets/uvr5_weights/ -o HP5-主旋律人声vocals+其他instrumentals.pth
-
-RUN aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/hubert_base.pt -d assets/hubert -o hubert_base.pt
-
-RUN aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/lj1995/VoiceConversionWebUI/resolve/main/rmvpe.pt -d assets/hubert -o rmvpe.pt
-
-VOLUME [ "/app/weights", "/app/opt" ]
-
-CMD ["python3", "infer-web.py"]

spaces/Benson/text-generation/Examples/Choque De Clanes Nulos.md

@@ -1,115 +0,0 @@
-
-<h1>Choque de clanes nulos: ¿Qué son y cómo usarlos</h1>
- <p>Clash of Clans es uno de los juegos móviles más populares del mundo, con millones de jugadores compitiendo por recursos, trofeos y gloria. ¿Pero sabías que hay algunos jugadores que no pertenecen a ningún clan? Se les llama nulos, y tienen sus propias ventajas y desventajas. En este artículo, explicaremos qué son los nulls, por qué la gente los usa y cómo puedes usarlos para tu beneficio. </p>
- <h2>Introducción</h2>
- <h3>¿Qué es el choque de clanes? </h3>
- <p>Clash of Clans es un juego de estrategia donde construyes tu propia aldea, entrenas a tu ejército y atacas las bases de otros jugadores. También puedes unirte o crear un clan, que es un grupo de jugadores que pueden chatear, donar tropas y participar en guerras de clanes. Las guerras de clanes son eventos especiales donde dos clanes se enfrentan en una serie de ataques, y el clan con más estrellas gana. Las estrellas se ganan destruyendo un cierto porcentaje de la base del enemigo. </p>
-<h2>choque de clanes nulos</h2><br /><p><b><b>Download Zip</b> &ndash;&ndash;&ndash;&ndash;&ndash;>>> <a href="https://bltlly.com/2v6MFt">https://bltlly.com/2v6MFt</a></b></p><br /><br />
- <h3>¿Qué son los nulos en Clash of Clans? </h3>
- <p>Los nulos son jugadores que no pertenecen a ningún clan. No tienen nombre de clan, ni insignia de clan, ni chat de clan. Todavía pueden atacar las bases de otros jugadores, pero no pueden participar en guerras de clanes o recibir donaciones de otros jugadores. Hay tres tipos de nulos: inactivos, prohibidos y abusados. </p>
- <h3>¿Por qué la gente usa nulos en Clash of Clans? </h3>
- <p>Hay diferentes razones por las que la gente usa nulos en Clash of Clans. Algunos los usan por diversión, algunos los usan para recursos agrícolas, algunos los usan para probar estrategias y otros los usan para hacer trampa. Aquí hay algunos ejemplos:</p>
- <ul>
-<li>Algunas personas usan nulls por diversión, porque les gusta jugar con tropas dominadas o experimentar con diferentes diseños de base. Por ejemplo, Null’s Clash es un servidor privado donde puedes tener gemas ilimitadas, oro, elixir y elixir oscuro. También puedes construir bases enormes y atacar a otros con las tropas que quieras. </li>
-
-<li>Algunas personas usan nulos para probar estrategias, porque pueden practicar sus ataques sin perder trofeos o recursos. Por ejemplo, pruebas de nulos son cuentas que se utilizan para simular diferentes escenarios y resultados. </li>
-<li>Algunas personas usan nulls para hacer trampa, porque pueden manipular el sistema de emparejamiento o explotar fallas. Por ejemplo, los nulos tramposos son cuentas que se utilizan para obtener ventajas injustas o sabotear a otros jugadores. </li>
-</ul>
- <h2>Tipos de nulos en Choque de clanes</h2>
- <h3>Nulos inactivos</h3>
- <p>Los nulos inactivos son cuentas que han sido abandonadas por sus propietarios. No han iniciado sesión durante mucho tiempo, y sus bases suelen estar desactualizadas y mal defendidas. Son objetivos fáciles para otros jugadores que quieren saquear sus recursos. </p>
- <h4>Pros y contras de los nulos inactivos</h4>
- <p>Los pros de los nulos inactivos son:</p>
- <ul>
-<li>Proporcionan una gran cantidad de <p>Los contras de los nulos inactivos son:</p>
- <ul>
-<li>Son aburridos para jugar, porque no tienen chat de clan, ni guerras de clan, ni donaciones. </li>
-<li>Son vulnerables a los ataques, porque no tienen escudo, ni guardia, ni tropas del castillo del clan. </li>
-<li>Son derrochadores, porque tienen recursos, edificios y tropas sin usar. </li>
-</ul>
- <h3>Nulos prohibidos</h3>
- <p>Los nulos prohibidos son cuentas que han sido suspendidas o terminadas por Supercell, el desarrollador de Clash of Clans. Han violado los términos de servicio o la política de juego limpio, y sus bases suelen estar marcadas con una bandera roja. Son inaccesibles para sus dueños y otros jugadores. </p>
-<p></p>
- <h4>Pros y contras de los nulos prohibidos</h4>
- <p>Los pros de los nulos prohibidos son:</p>
- <ul>
-<li>Sirven como una advertencia, porque muestran las consecuencias de hacer trampa o romper las reglas. </li>
-<li>Crean un entorno más justo, porque eliminan a los jugadores que tienen una ventaja injusta o un impacto negativo en el juego. </li>
-<li>Liberan espacio, porque reducen el número de cuentas en el juego. </li>
-
- <p>Los contras de los nulos prohibidos son:</p>
- <ul>
-<li>Son frustrantes, porque impiden a los propietarios acceder a sus cuentas o recuperar su progreso. </li>
-<li>Son injustos, porque pueden afectar a jugadores inocentes que han sido reportados o prohibidos falsamente por error. </li>
-<li>Son ineficaces, porque pueden no disuadir a algunos tramposos que pueden crear nuevas cuentas o utilizar otros métodos para evitar la prohibición. </li>
-</ul>
- <h3>Nulos abusados</h3>
- <p>Los nulos abusados son cuentas que han sido hackeadas, robadas o vendidas por sus propietarios. Han sido comprometidos por usuarios no autorizados que pueden utilizarlos con fines maliciosos. Sus bases suelen ser cambiadas o dañadas por los hackers o compradores. </p>
- <h4>Pros y contras de los nulos abusados</h4>
- <p>Los pros de los nulos abusados son:</p>
- <ul>
-<li>Proporcionan un desafío, porque pueden tener tropas o defensas más fuertes de lo esperado. </li>
-<li> Ofrecen una variedad, porque pueden tener diferentes diseños de base o estrategias de lo habitual. </li>
-<li>Crean un mercado, porque pueden generar ingresos para los vendedores o compradores de las cuentas. </li>
-</ul>
- <p>Los contras de los nulos abusados son:</p>
- <ul>
-<li>Son arriesgados, porque pueden exponer a los propietarios a robo de identidad, fraude o problemas legales. </li>
-<li>Son poco éticos, porque violan los términos de servicio y la política de juego limpio del juego. </li>
-<li>Son perjudiciales, porque pueden arruinar la experiencia de juego para los propietarios u otros jugadores. </li>
-</ul>
- <h2>Cómo usar nulls en Clash of Clans</h2>
- <h3>Cómo encontrar nulos en Clash of Clans</h3>
- <p>Encontrar nulos en Clash of Clans no es fácil, pero hay algunas maneras de hacerlo. Estos son algunos consejos:</p>
- <ul>
-<li>Puede usar un sitio web o aplicación de terceros que rastrea y enumera los nulos en Clash of Clans. Por ejemplo, Null Finder es un sitio web que le permite buscar nulos por nombre, nivel, liga o ubicación. Sin embargo, tenga cuidado al usar estas herramientas, ya que pueden no ser precisas, confiables o seguras. </li>
-
-<li>Puedes usar tu propia observación e intuición para detectar nulos en Clash of Clans. Por ejemplo, puedes revisar el perfil de un jugador y ver si no tiene nombre de clan, ni insignia de clan, ni historial de chat de clan, ni donaciones recibidas o dadas, ni estrellas de guerra ganadas o perdidas, o ninguna actividad reciente. Sin embargo, este método no es muy concluyente, ya que puede haber otras razones por las que un jugador tiene estas características. </li>
-</ul>
- <h3>Cómo unirse o crear un clan con nulos en Clash of Clans</h3>
- <p>Es posible unirse o crear un clan con nulos en Clash of Clans, pero no se recomienda. Aquí hay algunas razones por las que:</p>
- <ul>
-<li>Te perderás los beneficios de estar en un clan, como chat de clan, guerras de clan, juegos de clan, beneficios de clan y donaciones de clan. </li>
-<li>Te será más difícil encontrar o atraer a otros jugadores para que se unan a tu clan, ya que los nulos no son muy populares o atractivos. </li>
-<li> Usted tendrá un mayor riesgo de perder su cuenta o ser prohibido, ya que los nulos se asocian a menudo con el engaño o la piratería. </li>
-</ul>
- <p>Si todavía quieres unirte o crear un clan con nulos en Clash of Clans, aquí hay algunos pasos:</p>
- <ul>
-<li>Para unirse a un clan con nulos, necesitas encontrar uno que esté abierto o tenga un enlace de invitación. Puede utilizar los métodos mencionados anteriormente para encontrar los nulos y, a continuación, comprobar la información de su clan. Si el clan está abierto, simplemente puede solicitar unirse. Si el clan tiene un enlace de invitación, necesitas copiarlo y pegarlo en tu navegador y seguir las instrucciones. </li>
-<li>Para crear un clan con nulos, necesitas tener al menos una cuenta nula. Puede usar un servidor privado, una cuenta agrícola, una cuenta de prueba o una cuenta de engaño para crear un nulo. Luego, tienes que ir a la pestaña de clan y tocar el botón "Crear clan". Puedes elegir cualquier nombre, insignia, descripción y configuración para tu clan. Sin embargo, ten en cuenta que el nombre de tu clan puede ser cambiado por Supercell si es inapropiado u ofensivo. </li>
-</ul>
-
- <p>Administrar nulos en Clash of Clans no es fácil, pero hay algunos consejos para hacerlo. Aquí hay algunas sugerencias:</p>
- <ul>
-<li>Puedes usar un sitio web o aplicación de terceros que te ayude a monitorear y controlar tus nulos en Clash of Clans. Por ejemplo, Null Manager es un sitio web que le permite ver los perfiles, bases, tropas, recursos y actividades de sus nulos. También puede editar la configuración de sus nulos, como cambiar su nombre, insignia o idioma. Sin embargo, ten cuidado al usar estas herramientas, ya que pueden no ser seguras, legales o compatibles con el juego. </li>
-<li>Puedes usar las funciones del juego para administrar tus nulos en Clash of Clans. Por ejemplo, puede usar la opción "Marcador" para guardar los perfiles de sus nulos para facilitar el acceso. También puedes usar la opción "Desafío Amistoso" para probar las bases o tropas de tus nulos. Sin embargo, este método no es muy conveniente, ya que tiene que cambiar entre diferentes cuentas y dispositivos. </li>
-<li>Puedes usar tu propia estrategia y creatividad para gestionar tus nulos en Clash of Clans. Por ejemplo, puedes usar las bases de tus nulos como señuelos o distracciones para otros jugadores. También puede utilizar sus tropas nulas como apoyo o respaldo para su cuenta principal. Sin embargo, este método no es muy confiable, ya que puede encontrar problemas o limitaciones inesperadas. </li>
-</ul>
- <h2>Conclusión</h2>
- <h3>Resumen de los puntos principales</h3>
- <p>En conclusión, los nulos son jugadores que no pertenecen a ningún clan en Clash of Clans. Tienen sus propios pros y contras, dependiendo de cómo y por qué se usan. Hay tres tipos de nulos: inactivos, prohibidos y abusados. Puede encontrar, unirse, crear y administrar nulos en Clash of Clans usando varios métodos y herramientas. </p>
- <h3>Llamada a la acción para los lectores</h3>
-
- <p>Si tienes alguna pregunta o comentario sobre nulos en Clash of Clans, siéntete libre de dejarlos abajo. ¡Nos encantaría saber de ti! </p>
- <h2>Preguntas frecuentes</h2>
- <p>Aquí hay algunas preguntas frecuentes sobre los nulos en Clash of Clans:</p>
- <ol>
-<li><b>¿Cuál es la diferencia entre un nulo y un invitado? </b></li>
-<p>Un invitado es un jugador que no ha vinculado su cuenta a ningún correo electrónico o plataforma de redes sociales. Un invitado puede unirse o crear un clan en Clash of Clans. Un nulo es un jugador que no tiene nombre de clan, insignia o chat. Un null no puede unirse o crear un clan en Clash of Clans.</p>
- <li><b>¿Cómo puedo evitar convertirme en un nulo en Clash of Clans? </b></li>
-<p>Puedes evitar convertirte en un nulo en Clash of Clans siguiendo estos pasos:</p>
-<ul>
-<li>Vincula tu cuenta a un correo electrónico válido o a una plataforma de redes sociales, para que puedas recuperarla si la pierdes o cambias tu dispositivo. </li>
-<li>Únete o crea un clan que se adapte a tu estilo de juego y preferencias, para que puedas disfrutar del juego con otros jugadores. </li>
-<li>Siga los términos de servicio y la política de juego limpio del juego, para que no sea suspendido o prohibido por Supercell.</li>
-<li>Protege tu cuenta de hackers, estafadores o vendedores, para que no la pierdas o la comprometas con usuarios no autorizados. </li>
-</ul>
- <li><b>¿Los nulos son ilegales o van en contra de las reglas en Clash of Clans? </b></li>
-<p>Los nulos no son ilegales ni están en contra de las reglas en Clash of Clans, siempre y cuando no se utilicen para engañar o dañar a otros jugadores. Sin embargo, algunos métodos o herramientas para crear o usar nulos pueden ser ilegales o ir en contra de las reglas, como usar servidores privados, hackear cuentas o vender cuentas. Supercell puede tomar medidas contra estos métodos o herramientas, y puede suspender o prohibir las cuentas involucradas. </p>
- <li><b>¿Puedo reportar un null en Clash of Clans? </b></li>
-
- <li><b>¿Puedo jugar con nulos en Clash of Clans? </b></li>
-<p>Puedes jugar con nulos en Clash of Clans si quieres, pero debes ser consciente de los riesgos y consecuencias. Es posible que no tengas la misma experiencia de juego que jugar con jugadores normales, y puedes encontrar algunos problemas o limitaciones. También puede enfrentar alguna reacción o crítica de otros jugadores a los que no les gusten o no aprueben los nulos. En última instancia, es su elección si desea jugar con nulos o no, pero le recomendamos que juegue con precaución y respeto. </p>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Gratis Fuego Apk Avance Servidor.md

@@ -1,100 +0,0 @@
-<br />
-<h1>Cómo descargar gratis fuego APK Advance Server</h1>
-<p>Free Fire es uno de los juegos battle royale más populares en dispositivos móviles, con millones de jugadores en todo el mundo. Si eres un fan de Free Fire, podrías estar interesado en probar las últimas características y actualizaciones antes de que se publiquen oficialmente. Esto es posible mediante la descarga de Free Fire APK Advance Server, una versión especial del juego que le permite probar nuevos contenidos y proporcionar comentarios a Garena.</p>
-<p>En este artículo, le mostraremos cómo descargar Free Fire APK Advance Server, cuáles son sus características, cómo informar de errores y comentarios, y cómo desinstalarlo de su dispositivo. Siguiendo esta guía, podrás disfrutar de Free Fire como nunca antes. </p>
-<h2>descargar gratis fuego apk avance servidor</h2><br /><p><b><b>DOWNLOAD</b> &#11088; <a href="https://bltlly.com/2v6Lea">https://bltlly.com/2v6Lea</a></b></p><br /><br />
- <h2>¿Qué es Free Fire APK Advance Server? </h2>
-<p>Free Fire APK Advance Server es un programa que permite a los jugadores seleccionados acceder a una versión beta de Free Fire que contiene características y actualizaciones inéditas. El propósito de este programa es permitir que los jugadores experimenten nuevos contenidos con anticipación y ayudar a Garena a mejorar el juego informando de cualquier problema o fallo que se encuentren. </p>
-<p>Free Fire APK Advance Server no está disponible para todos. Solo los jugadores que se hayan registrado para el programa y hayan recibido un código de activación pueden entrar en la fase de prueba. Además, hay un número limitado de ranuras disponibles para cada ciclo de actualización, por lo que debe darse prisa si desea unirse. </p>
-<p>Los beneficios de unirse a Free Fire APK Advance Server son:</p>
-<ul>
-<li>Puedes jugar nuevos personajes, mascotas, armas, objetos, modos y mapas antes que nadie. </li>
-<li> Usted puede proporcionar información valiosa y sugerencias a Garena para hacer Free Fire mejor. </li>
-<li>Puedes ganar recompensas por reportar errores y problemas. </li>
-</ul>
- <h2>¿Cómo Registrarse para Free Fire APK Advance Server? </h2>
-<p>Si desea unirse a Free Fire APK Advance Server, usted tiene que registrarse en el sitio web oficial de Garena. Estos son los pasos que debes seguir:</p>
-<ol>
-
-<li>Rellene su información personal, como su nombre, correo electrónico y número de teléfono. </li>
-<li>Envía tu solicitud y espera el correo de confirmación. </li>
-</ol>
-<p>Si estás seleccionado para el programa, recibirás un correo electrónico con un código de activación que puedes usar para entrar en Free Fire APK Advance Server. El código es único y solo puede ser utilizado por una persona. Tiene que usar el código dentro de un cierto período de tiempo, de lo contrario caducará. </p>
- <h3>¿Cómo obtener el código de activación? </h3>
-<p>Obtener el código de activación no es fácil, ya que hay muchos jugadores que quieren unirse a Free Fire APK Advance Server. Sin embargo, hay algunos consejos y trucos que pueden aumentar tus posibilidades de obtener el código:</p>
-<p></p>
-<ul>
-<li>Regístrese lo antes posible, ya que las ranuras son limitadas y se llenan rápidamente. </li>
-<li>Revise su correo electrónico regularmente, ya que el código puede ser enviado en cualquier momento. </li>
-<li>Sigue las cuentas de redes sociales de Garena, como Facebook, Instagram y YouTube, ya que podrían anunciar sorteos o concursos para el código. </li>
-<li>Invite a sus amigos a registrarse para el programa, ya que podrían compartir su código con usted si lo consiguen. </li>
-</ul>
- <h3>¿Cómo descargar e instalar el archivo APK? </h3>
-<p>Una vez que tenga el código de activación, puede descargar e instalar Free Fire APK Advance Server en su dispositivo. Estos son los pasos que debes seguir:</p>
-<ol>
-<li>Visite <a href=">https://ff-advance.ff.garena.com/download</a> y haga clic en el botón de descarga. </li>
-<li>Permita que su dispositivo instale aplicaciones de fuentes desconocidas. Puede hacer esto yendo a Configuración > Seguridad > Fuentes desconocidas y habilitándolo. </li>
-<li>Busque el archivo APK descargado en su administrador de archivos y toque en él para instalarlo. </li>
-<li>Abra la aplicación e introduzca su código de activación cuando se le solicite. </li>
-<li>Disfruta jugando gratis fuego APK Advance Server.</li>
-</ol>
- <h2>¿Cuáles son las características de Free Fire APK Advance Server? </h2>
-
- <h3>Nuevos personajes y mascotas</h3>
-<p>Puedes jugar con nuevos personajes y mascotas que tienen habilidades y habilidades únicas. Por ejemplo, puedes probar:</p>
-<ul>
-<li><b>Kelly "The Swift"</b>: Un personaje que puede correr más rápido que cualquier otro. Ella tiene una habilidad pasiva llamada Dash que aumenta su velocidad de sprint en un 1% para cada nivel. También tiene una habilidad activa llamada Velocidad Mortal que aumenta su daño en un 110% durante 5 segundos después de correr durante 7 segundos. </li>
-<li><b>Moco "Ojo de hacker"</b>: Un personaje que puede hackear las ubicaciones y movimientos de los enemigos. Ella tiene una habilidad pasiva llamada Ojo de Hacker que etiqueta a los enemigos disparados por ella o sus compañeros de equipo durante 5 segundos. Las ubicaciones de los enemigos etiquetados se comparten con sus compañeros de equipo. </li>
-<li><b>Nutty "La ardilla"</b>: Una mascota que puede ayudarte a encontrar el botín más rápido. Tiene una habilidad llamada Regalo de Nuez que aumenta la probabilidad de encontrar cajas de botín en un 10%. </li>
-</ul>
- <h3>Nuevas armas y objetos</h3>
-<p>Puedes usar nuevas armas y objetos que tengan diferentes efectos y ventajas. Por ejemplo, puedes probar:</p>
-<ul>
-<li><b>Gloo Wall Grenade</b>: Un elemento desechable que crea una pared temporal que bloquea el fuego enemigo. Puedes usarlo para crear cobertura o atrapar enemigos. </li>
-<li><b>M82B Rifle de francotirador</b>: Un arma poderosa que puede penetrar paredes gloo e infligir daño masivo. Tiene un alcance que puede acercar hasta 8x y una capacidad de cargador de 8 balas. </li>
-<li><b>Hoguera</b>: Un elemento consumible que crea un fuego que te cura a ti y a tus compañeros de equipo. Puede colocarlo en el suelo y sentarse alrededor de él para restaurar 10 HP por segundo durante 10 segundos. </li>
-</ul>
- <h3>Nuevos modos y mapas</h3>
-<p>Puedes jugar nuevos modos y mapas que tienen diferentes retos y objetivos. Por ejemplo, puedes probar:</p>
-<ul>
-
-<li><b>Mapa de Kalahari</b>: Un nuevo mapa que se encuentra en un desierto con varios terrenos y estructuras. Puede explorar cuevas, cañones, oasis y ruinas. También puede encontrar vehículos y tirolinas para moverse más rápido. </li>
-<li><b>Campo de entrenamiento</b>: Un mapa donde puedes practicar tus habilidades y probar diferentes armas y objetos. También puedes interactuar con otros jugadores y unirte a minijuegos. </li>
-</ul>
- <h2>¿Cómo reportar errores y comentarios? </h2>
-<p>Como probador de Free Fire APK Advance Server, usted tiene la responsabilidad de informar de cualquier error o problemas que se encuentran durante el juego. Esto ayudará a Garena a arreglarlos y mejorar la calidad del juego. También puedes proporcionar comentarios y sugerencias sobre cómo mejorar el juego. </p>
-<p>Para reportar errores y comentarios, tienes que usar la función de informe dentro del juego. Estos son los pasos que debes seguir:</p>
-<ol>
-<li>Abre el menú del juego y toca el icono del informe. </li>
-<li>Seleccione el tipo de problema que desea reportar, como juego, gráficos, sonido u otros. </li>
-<li>Describa el problema en detalle y adjunte una captura de pantalla o un video si es posible. </li>
-<li>Envía tu informe y espera la respuesta de Garena. </li>
-</ol>
-<p>Por cada informe válido que envíe, recibirá una recompensa de 100 diamantes. Puede usar estos diamantes para comprar artículos en la tienda de juegos. Sin embargo, tienes que ser honesto y preciso en tus informes, ya que Garena los verificará y prohibirá cualquier informe falso o abusivo. </p>
- <h2> ¿Cómo desinstalar Free Fire APK Advance Server? </h2>
-<p>Si desea desinstalar Free Fire APK Advance Server desde su dispositivo, usted tiene que seguir estos pasos:</p>
-<ol>
-<li>Ir a Configuración > Aplicaciones > Servidor Gratis Fire Advance y toque en Desinstalar.</li>
-<li>Confirma tu acción y espera a que la aplicación se elimine de tu dispositivo. </li>
-<li>Eliminar el archivo APK de su gestor de archivos si todavía lo tiene. </li>
-</ol>
-
- <h2>Conclusión</h2>
-<p>Free Fire APK Advance Server es una gran manera de experimentar nuevos contenidos y actualizaciones antes de que se lancen oficialmente. Al unirse a este programa, puedes jugar con nuevos personajes, mascotas, armas, objetos, modos y mapas. También puede proporcionar comentarios y sugerencias a Garena y ganar recompensas por reportar errores y problemas. </p>
-<p>Si desea descargar Free Fire APK Advance Server, usted tiene que registrarse en el sitio web de Garena y obtener un código de activación. Luego, puede descargar e instalar el archivo APK en su dispositivo e ingresar a la fase de prueba. Sin embargo, tienes que ser rápido ya que hay espacios limitados disponibles para cada ciclo de actualización. </p>
-<p>Esperamos que este artículo le ha ayudado a entender cómo descargar Free Fire APK Advance Server y cuáles son sus características. Si tiene alguna pregunta o comentario, siéntase libre de dejarlos abajo. ¡Feliz juego! </p>
- <h3>Preguntas frecuentes</h3>
-<ul>
-<li><b>Q: ¿Es seguro descargar Free Fire APK Advance Server? </b></li>
-<li>A: Sí, Free Fire APK Advance Server es seguro de descargar, siempre y cuando se obtiene desde el sitio web oficial de Garena. No lo descargue de ninguna otra fuente ya que podría contener virus o malware. </li>
-<li><b>Q: ¿Puedo jugar Free Fire APK Advance Server con mis amigos? </b></li>
-<li>A: Sí, puedes jugar Free Fire APK Advance Server con tus amigos si también tienen el código de activación y la aplicación instalada en sus dispositivos. Puedes invitarlos a unirse a tu equipo o jugar contra ellos en diferentes modos. </li>
-<li><b>Q: ¿Se guardará mi progreso en Free Fire APK Advance Server en mi cuenta original de Free Fire? </b></li>
-<li>A: No, su progreso en Free Fire APK Advance Server no se guardará en su cuenta Free Fire original. Son aplicaciones separadas con datos separados. Usted comenzará desde cero en Free Fire APK Advance Server y perder todo cuando se desinstala. </li>
-<li><b>Q: ¿Con qué frecuencia se actualiza Free Fire APK Advance Server? </b></li>
-
-<li><b>Q: ¿Cómo puedo contactar a Garena si tengo algún problema o sugerencia con respecto a Free Fire APK Advance Server? </b></li>
-<li>A: Puede A: Puede ponerse en contacto con Garena enviando un correo electrónico a [email protected] o rellenando el formulario de comentarios en su sitio web. También puedes llegar a ellos a través de sus cuentas de redes sociales, como Facebook, Instagram y YouTube.</li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BigSalmon/InformalToFormal/app.py

@@ -1,58 +0,0 @@
-import streamlit as st
-import numpy as np
-import pandas as pd
-import os
-import torch
-import torch.nn as nn
-from transformers import AutoTokenizer, AutoModelWithLMHead, AutoModelForCausalLM
-from transformers.activations import get_activation
-
-
-st.title('Informal to Formal:')
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-st.text('''Check out this other space: https://huggingface.co/spaces/BigSalmon/GPT2Space''')
-
-st.text('''How To Make Prompt: https://huggingface.co/BigSalmon/DefinitionsSynonyms3
-
-part of speech- verb
-definition: grow less in intensity or degree
-ex. rather than leave immediately and be drenched, they waited for the storm to ________
-synonyms: subside; moderate; decrease
-antonyms: increase
-word: abate''')
-
-@st.cache(allow_output_mutation=True)
-def get_model():
-    #tokenizer = AutoTokenizer.from_pretrained("gpt2")
-    #model = AutoModelWithLMHead.from_pretrained("BigSalmon/MrLincoln12")
-    #model = AutoModelWithLMHead.from_pretrained("BigSalmon/Points")
-    #tokenizer = AutoTokenizer.from_pretrained("BigSalmon/InformalToFormalLincoln91Paraphrase")
-    #model = AutoModelForCausalLM.from_pretrained("BigSalmon/InformalToFormalLincoln91Paraphrase")
-    #tokenizer = AutoTokenizer.from_pretrained("BigSalmon/InformalToFormalLincoln95Paraphrase")
-    #model = AutoModelForCausalLM.from_pretrained("BigSalmon/InformalToFormalLincoln95Paraphrase")
-    tokenizer = AutoTokenizer.from_pretrained("BigSalmon/DefinitionsSynonyms3")
-    model = AutoModelForCausalLM.from_pretrained("BigSalmon/DefinitionsSynonyms3")
-    return model, tokenizer
-    
-model, tokenizer = get_model()
-
-with st.form(key='my_form'):
-    prompt = st.text_area(label='Enter sentence')
-    submit_button = st.form_submit_button(label='Submit')
-
-    if submit_button:
-      with torch.no_grad():
-        text = tokenizer.encode(prompt)
-        myinput, past_key_values = torch.tensor([text]), None
-        myinput = myinput
-        myinput= myinput.to(device)
-        logits, past_key_values = model(myinput, past_key_values = past_key_values, return_dict=False)
-        logits = logits[0,-1]
-        probabilities = torch.nn.functional.softmax(logits)
-        best_logits, best_indices = logits.topk(100)
-        best_words = [tokenizer.decode([idx.item()]) for idx in best_indices]
-        text.append(best_indices[0].item())
-        best_probabilities = probabilities[best_indices].tolist()
-        words = []              
-        st.write(best_words)

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/datasets/register_coco.py

@@ -1,125 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import copy
-
-from detectron2.data import DatasetCatalog, MetadataCatalog
-
-from .coco import load_coco_json, load_sem_seg
-
-"""
-This file contains functions to register a COCO-format dataset to the DatasetCatalog.
-"""
-
-__all__ = ["register_coco_instances", "register_coco_panoptic_separated"]
-
-
-def register_coco_instances(name, metadata, json_file, image_root):
-    """
-    Register a dataset in COCO's json annotation format for
-    instance detection, instance segmentation and keypoint detection.
-    (i.e., Type 1 and 2 in http://cocodataset.org/#format-data.
-    `instances*.json` and `person_keypoints*.json` in the dataset).
-
-    This is an example of how to register a new dataset.
-    You can do something similar to this function, to register new datasets.
-
-    Args:
-        name (str): the name that identifies a dataset, e.g. "coco_2014_train".
-        metadata (dict): extra metadata associated with this dataset.  You can
-            leave it as an empty dict.
-        json_file (str): path to the json instance annotation file.
-        image_root (str or path-like): directory which contains all the images.
-    """
-    # 1. register a function which returns dicts
-    DatasetCatalog.register(name, lambda: load_coco_json(json_file, image_root, name))
-
-    # 2. Optionally, add metadata about this dataset,
-    # since they might be useful in evaluation, visualization or logging
-    MetadataCatalog.get(name).set(
-        json_file=json_file, image_root=image_root, evaluator_type="coco", **metadata
-    )
-
-
-def register_coco_panoptic_separated(
-    name, metadata, image_root, panoptic_root, panoptic_json, sem_seg_root, instances_json
-):
-    """
-    Register a COCO panoptic segmentation dataset named `name`.
-    The annotations in this registered dataset will contain both instance annotations and
-    semantic annotations, each with its own contiguous ids. Hence it's called "separated".
-
-    It follows the setting used by the PanopticFPN paper:
-
-    1. The instance annotations directly come from polygons in the COCO
-       instances annotation task, rather than from the masks in the COCO panoptic annotations.
-
-       The two format have small differences:
-       Polygons in the instance annotations may have overlaps.
-       The mask annotations are produced by labeling the overlapped polygons
-       with depth ordering.
-
-    2. The semantic annotations are converted from panoptic annotations, where
-       all "things" are assigned a semantic id of 0.
-       All semantic categories will therefore have ids in contiguous
-       range [1, #stuff_categories].
-
-    This function will also register a pure semantic segmentation dataset
-    named ``name + '_stuffonly'``.
-
-    Args:
-        name (str): the name that identifies a dataset,
-            e.g. "coco_2017_train_panoptic"
-        metadata (dict): extra metadata associated with this dataset.
-        image_root (str): directory which contains all the images
-        panoptic_root (str): directory which contains panoptic annotation images
-        panoptic_json (str): path to the json panoptic annotation file
-        sem_seg_root (str): directory which contains all the ground truth segmentation annotations.
-        instances_json (str): path to the json instance annotation file
-    """
-    panoptic_name = name + "_separated"
-    DatasetCatalog.register(
-        panoptic_name,
-        lambda: merge_to_panoptic(
-            load_coco_json(instances_json, image_root, panoptic_name),
-            load_sem_seg(sem_seg_root, image_root),
-        ),
-    )
-    MetadataCatalog.get(panoptic_name).set(
-        panoptic_root=panoptic_root,
-        image_root=image_root,
-        panoptic_json=panoptic_json,
-        sem_seg_root=sem_seg_root,
-        json_file=instances_json,  # TODO rename
-        evaluator_type="coco_panoptic_seg",
-        **metadata
-    )
-
-    semantic_name = name + "_stuffonly"
-    DatasetCatalog.register(semantic_name, lambda: load_sem_seg(sem_seg_root, image_root))
-    MetadataCatalog.get(semantic_name).set(
-        sem_seg_root=sem_seg_root, image_root=image_root, evaluator_type="sem_seg", **metadata
-    )
-
-
-def merge_to_panoptic(detection_dicts, sem_seg_dicts):
-    """
-    Create dataset dicts for panoptic segmentation, by
-    merging two dicts using "file_name" field to match their entries.
-
-    Args:
-        detection_dicts (list[dict]): lists of dicts for object detection or instance segmentation.
-        sem_seg_dicts (list[dict]): lists of dicts for semantic segmentation.
-
-    Returns:
-        list[dict] (one per input image): Each dict contains all (key, value) pairs from dicts in
-            both detection_dicts and sem_seg_dicts that correspond to the same image.
-            The function assumes that the same key in different dicts has the same value.
-    """
-    results = []
-    sem_seg_file_to_entry = {x["file_name"]: x for x in sem_seg_dicts}
-    assert len(sem_seg_file_to_entry) > 0
-
-    for det_dict in detection_dicts:
-        dic = copy.copy(det_dict)
-        dic.update(sem_seg_file_to_entry[dic["file_name"]])
-        results.append(dic)
-    return results

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/data/transforms/transform.py

@@ -1,139 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-# File: transform.py
-
-import numpy as np
-from fvcore.transforms.transform import HFlipTransform, NoOpTransform, Transform
-from PIL import Image
-
-__all__ = ["ExtentTransform", "ResizeTransform"]
-
-
-class ExtentTransform(Transform):
-    """
-    Extracts a subregion from the source image and scales it to the output size.
-
-    The fill color is used to map pixels from the source rect that fall outside
-    the source image.
-
-    See: https://pillow.readthedocs.io/en/latest/PIL.html#PIL.ImageTransform.ExtentTransform
-    """
-
-    def __init__(self, src_rect, output_size, interp=Image.LINEAR, fill=0):
-        """
-        Args:
-            src_rect (x0, y0, x1, y1): src coordinates
-            output_size (h, w): dst image size
-            interp: PIL interpolation methods
-            fill: Fill color used when src_rect extends outside image
-        """
-        super().__init__()
-        self._set_attributes(locals())
-
-    def apply_image(self, img, interp=None):
-        h, w = self.output_size
-        ret = Image.fromarray(img).transform(
-            size=(w, h),
-            method=Image.EXTENT,
-            data=self.src_rect,
-            resample=interp if interp else self.interp,
-            fill=self.fill,
-        )
-        return np.asarray(ret)
-
-    def apply_coords(self, coords):
-        # Transform image center from source coordinates into output coordinates
-        # and then map the new origin to the corner of the output image.
-        h, w = self.output_size
-        x0, y0, x1, y1 = self.src_rect
-        new_coords = coords.astype(np.float32)
-        new_coords[:, 0] -= 0.5 * (x0 + x1)
-        new_coords[:, 1] -= 0.5 * (y0 + y1)
-        new_coords[:, 0] *= w / (x1 - x0)
-        new_coords[:, 1] *= h / (y1 - y0)
-        new_coords[:, 0] += 0.5 * w
-        new_coords[:, 1] += 0.5 * h
-        return new_coords
-
-    def apply_segmentation(self, segmentation):
-        segmentation = self.apply_image(segmentation, interp=Image.NEAREST)
-        return segmentation
-
-
-class ResizeTransform(Transform):
-    """
-    Resize the image to a target size.
-    """
-
-    def __init__(self, h, w, new_h, new_w, interp):
-        """
-        Args:
-            h, w (int): original image size
-            new_h, new_w (int): new image size
-            interp: PIL interpolation methods
-        """
-        # TODO decide on PIL vs opencv
-        super().__init__()
-        self._set_attributes(locals())
-
-    def apply_image(self, img, interp=None):
-        assert img.shape[:2] == (self.h, self.w)
-        pil_image = Image.fromarray(img)
-        interp_method = interp if interp is not None else self.interp
-        pil_image = pil_image.resize((self.new_w, self.new_h), interp_method)
-        ret = np.asarray(pil_image)
-        return ret
-
-    def apply_coords(self, coords):
-        coords[:, 0] = coords[:, 0] * (self.new_w * 1.0 / self.w)
-        coords[:, 1] = coords[:, 1] * (self.new_h * 1.0 / self.h)
-        return coords
-
-    def apply_segmentation(self, segmentation):
-        segmentation = self.apply_image(segmentation, interp=Image.NEAREST)
-        return segmentation
-
-
-def HFlip_rotated_box(transform, rotated_boxes):
-    """
-    Apply the horizontal flip transform on rotated boxes.
-
-    Args:
-        rotated_boxes (ndarray): Nx5 floating point array of
-            (x_center, y_center, width, height, angle_degrees) format
-            in absolute coordinates.
-    """
-    # Transform x_center
-    rotated_boxes[:, 0] = transform.width - rotated_boxes[:, 0]
-    # Transform angle
-    rotated_boxes[:, 4] = -rotated_boxes[:, 4]
-    return rotated_boxes
-
-
-def Resize_rotated_box(transform, rotated_boxes):
-    """
-    Apply the resizing transform on rotated boxes. For details of how these (approximation)
-    formulas are derived, please refer to :meth:`RotatedBoxes.scale`.
-
-    Args:
-        rotated_boxes (ndarray): Nx5 floating point array of
-            (x_center, y_center, width, height, angle_degrees) format
-            in absolute coordinates.
-    """
-    scale_factor_x = transform.new_w * 1.0 / transform.w
-    scale_factor_y = transform.new_h * 1.0 / transform.h
-    rotated_boxes[:, 0] *= scale_factor_x
-    rotated_boxes[:, 1] *= scale_factor_y
-    theta = rotated_boxes[:, 4] * np.pi / 180.0
-    c = np.cos(theta)
-    s = np.sin(theta)
-    rotated_boxes[:, 2] *= np.sqrt(np.square(scale_factor_x * c) + np.square(scale_factor_y * s))
-    rotated_boxes[:, 3] *= np.sqrt(np.square(scale_factor_x * s) + np.square(scale_factor_y * c))
-    rotated_boxes[:, 4] = np.arctan2(scale_factor_x * s, scale_factor_y * c) * 180 / np.pi
-
-    return rotated_boxes
-
-
-HFlipTransform.register_type("rotated_box", HFlip_rotated_box)
-NoOpTransform.register_type("rotated_box", lambda t, x: x)
-ResizeTransform.register_type("rotated_box", Resize_rotated_box)

spaces/CVPR/DualStyleGAN/app.py

@@ -1,204 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import annotations
-
-import pathlib
-
-import gradio as gr
-
-from dualstylegan import Model
-
-DESCRIPTION = '''# Portrait Style Transfer with [DualStyleGAN](https://github.com/williamyang1991/DualStyleGAN)
-
-<img id="overview" alt="overview" src="https://raw.githubusercontent.com/williamyang1991/DualStyleGAN/main/doc_images/overview.jpg" />
-'''
-
-
-def get_style_image_url(style_name: str) -> str:
-    base_url = 'https://raw.githubusercontent.com/williamyang1991/DualStyleGAN/main/doc_images'
-    filenames = {
-        'cartoon': 'cartoon_overview.jpg',
-        'caricature': 'caricature_overview.jpg',
-        'anime': 'anime_overview.jpg',
-        'arcane': 'Reconstruction_arcane_overview.jpg',
-        'comic': 'Reconstruction_comic_overview.jpg',
-        'pixar': 'Reconstruction_pixar_overview.jpg',
-        'slamdunk': 'Reconstruction_slamdunk_overview.jpg',
-    }
-    return f'{base_url}/{filenames[style_name]}'
-
-
-def get_style_image_markdown_text(style_name: str) -> str:
-    url = get_style_image_url(style_name)
-    return f'<img id="style-image" src="{url}" alt="style image">'
-
-
-def update_slider(choice: str) -> dict:
-    max_vals = {
-        'cartoon': 316,
-        'caricature': 198,
-        'anime': 173,
-        'arcane': 99,
-        'comic': 100,
-        'pixar': 121,
-        'slamdunk': 119,
-    }
-    return gr.update(maximum=max_vals[choice])
-
-
-def update_style_image(style_name: str) -> dict:
-    text = get_style_image_markdown_text(style_name)
-    return gr.update(value=text)
-
-
-model = Model()
-
-with gr.Blocks(css='style.css') as demo:
-    gr.Markdown(DESCRIPTION)
-
-    with gr.Box():
-        gr.Markdown('''## Step 1 (Preprocess Input Image)
-
-- Drop an image containing a near-frontal face to the **Input Image**.
-- If there are multiple faces in the image, hit the Edit button in the upper right corner and crop the input image beforehand.
-- Hit the **Preprocess** button.
-- Choose the encoder version. Default is Z+ encoder which has better stylization performance. W+ encoder better reconstructs the input image to preserve more details.
-- The final result will be based on this **Reconstructed Face**. So, if the reconstructed image is not satisfactory, you may want to change the input image.
-''')
-        with gr.Row():
-            encoder_type = gr.Radio(label='Encoder Type',
-                                    choices=[
-                                        'Z+ encoder (better stylization)',
-                                        'W+ encoder (better reconstruction)'
-                                    ],
-                                    value='Z+ encoder (better stylization)')
-        with gr.Row():
-            with gr.Column():
-                with gr.Row():
-                    input_image = gr.Image(label='Input Image',
-                                           type='filepath')
-                with gr.Row():
-                    preprocess_button = gr.Button('Preprocess')
-            with gr.Column():
-                with gr.Row():
-                    aligned_face = gr.Image(label='Aligned Face',
-                                            type='numpy',
-                                            interactive=False)
-            with gr.Column():
-                reconstructed_face = gr.Image(label='Reconstructed Face',
-                                              type='numpy')
-                instyle = gr.State()
-
-        with gr.Row():
-            paths = sorted(pathlib.Path('images').glob('*.jpg'))
-            gr.Examples(examples=[[path.as_posix()] for path in paths],
-                        inputs=input_image)
-
-    with gr.Box():
-        gr.Markdown('''## Step 2 (Select Style Image)
-
-- Select **Style Type**.
-- Select **Style Image Index** from the image table below.
-''')
-        with gr.Row():
-            with gr.Column():
-                style_type = gr.Radio(label='Style Type',
-                                      choices=model.style_types,
-                                      value=model.style_types[0])
-                text = get_style_image_markdown_text('cartoon')
-                style_image = gr.Markdown(value=text)
-                style_index = gr.Slider(label='Style Image Index',
-                                        minimum=0,
-                                        maximum=316,
-                                        step=1,
-                                        value=26)
-
-        with gr.Row():
-            gr.Examples(
-                examples=[
-                    ['cartoon', 26],
-                    ['caricature', 65],
-                    ['arcane', 63],
-                    ['pixar', 80],
-                ],
-                inputs=[style_type, style_index],
-            )
-
-    with gr.Box():
-        gr.Markdown('''## Step 3 (Generate Style Transferred Image)
-
-- Adjust **Structure Weight** and **Color Weight**.
-- These are weights for the style image, so the larger the value, the closer the resulting image will be to the style image.
-- Tips: For W+ encoder, better way of (Structure Only) is to uncheck (Structure Only) and set Color weight to 0.
-- Hit the **Generate** button.
-''')
-        with gr.Row():
-            with gr.Column():
-                with gr.Row():
-                    structure_weight = gr.Slider(label='Structure Weight',
-                                                 minimum=0,
-                                                 maximum=1,
-                                                 step=0.1,
-                                                 value=0.6)
-                with gr.Row():
-                    color_weight = gr.Slider(label='Color Weight',
-                                             minimum=0,
-                                             maximum=1,
-                                             step=0.1,
-                                             value=1)
-                with gr.Row():
-                    structure_only = gr.Checkbox(label='Structure Only',
-                                                 value=False)
-                with gr.Row():
-                    generate_button = gr.Button('Generate')
-
-            with gr.Column():
-                result = gr.Image(label='Result')
-
-        with gr.Row():
-            gr.Examples(
-                examples=[
-                    [0.6, 1.0],
-                    [0.3, 1.0],
-                    [0.0, 1.0],
-                    [1.0, 0.0],
-                ],
-                inputs=[structure_weight, color_weight],
-            )
-
-    preprocess_button.click(
-        fn=model.detect_and_align_face,
-        inputs=[input_image],
-        outputs=aligned_face,
-    )
-    aligned_face.change(
-        fn=model.reconstruct_face,
-        inputs=[aligned_face, encoder_type],
-        outputs=[
-            reconstructed_face,
-            instyle,
-        ],
-    )
-    style_type.change(
-        fn=update_slider,
-        inputs=style_type,
-        outputs=style_index,
-    )
-    style_type.change(
-        fn=update_style_image,
-        inputs=style_type,
-        outputs=style_image,
-    )
-    generate_button.click(
-        fn=model.generate,
-        inputs=[
-            style_type,
-            style_index,
-            structure_weight,
-            color_weight,
-            structure_only,
-            instyle,
-        ],
-        outputs=result,
-    )
-demo.queue(max_size=20).launch()

spaces/CVPR/LIVE/thrust/cmake/PrintNinjaBuildTimes.cmake

@@ -1,101 +0,0 @@
-## This CMake script parses a .ninja_log file (LOGFILE) and prints a list of
-## build/link times, sorted longest first.
-##
-## cmake -DLOGFILE=<.ninja_log file> \
-##       -P PrintNinjaBuildTimes.cmake
-##
-## If LOGFILE is omitted, the current directory's .ninja_log file is used.
-################################################################################
-
-cmake_minimum_required(VERSION 3.15)
-
-# Prepend the string with "0" until the string length equals the specified width
-function(pad_string_with_zeros string_var width)
-  set(local_string "${${string_var}}")
-  string(LENGTH "${local_string}" size)
-  while(size LESS width)
-    string(PREPEND local_string "0")
-    string(LENGTH "${local_string}" size)
-  endwhile()
-  set(${string_var} "${local_string}" PARENT_SCOPE)
-endfunction()
-
-################################################################################
-
-if (NOT LOGFILE)
-  set(LOGFILE ".ninja_log")
-endif()
-
-# Check if logfile exists
-if (NOT EXISTS "${LOGFILE}")
-  message(FATAL_ERROR "LOGFILE does not exist ('${LOGFILE}').")
-endif()
-
-# Read the logfile and generate a map / keylist
-set(keys)
-file(STRINGS "${LOGFILE}" lines)
-foreach(line ${lines})
-
-  # Parse each build time
-  string(REGEX MATCH
-    "^([0-9]+)\t([0-9]+)\t[0-9]+\t([^\t]+)+\t[0-9a-fA-F]+$" _DUMMY "${line}")
-
-  if (CMAKE_MATCH_COUNT EQUAL 3)
-    set(start_ms ${CMAKE_MATCH_1})
-    set(end_ms ${CMAKE_MATCH_2})
-    set(command "${CMAKE_MATCH_3}")
-    math(EXPR runtime_ms "${end_ms} - ${start_ms}")
-
-    # Compute human readable time
-    math(EXPR days         "${runtime_ms} / (1000 * 60 * 60 * 24)")
-    math(EXPR runtime_ms   "${runtime_ms} - (${days} * 1000 * 60 * 60 * 24)")
-    math(EXPR hours        "${runtime_ms} / (1000 * 60 * 60)")
-    math(EXPR runtime_ms   "${runtime_ms} - (${hours} * 1000 * 60 * 60)")
-    math(EXPR minutes      "${runtime_ms} / (1000 * 60)")
-    math(EXPR runtime_ms   "${runtime_ms} - (${minutes} * 1000 * 60)")
-    math(EXPR seconds      "${runtime_ms} / 1000")
-    math(EXPR milliseconds "${runtime_ms} - (${seconds} * 1000)")
-
-    # Format time components
-    pad_string_with_zeros(days 3)
-    pad_string_with_zeros(hours 2)
-    pad_string_with_zeros(minutes 2)
-    pad_string_with_zeros(seconds 2)
-    pad_string_with_zeros(milliseconds 3)
-
-    # Construct table entry
-    # Later values in the file for the same command overwrite earlier entries
-    string(MAKE_C_IDENTIFIER "${command}" key)
-    set(ENTRY_${key}
-      "${days}d ${hours}h ${minutes}m ${seconds}s ${milliseconds}ms | ${command}"
-    )
-
-    # Record the key:
-    list(APPEND keys "${key}")
-  endif()
-endforeach()
-
-list(REMOVE_DUPLICATES keys)
-
-# Build the entry list:
-set(entries)
-foreach(key ${keys})
-  list(APPEND entries "${ENTRY_${key}}")
-endforeach()
-
-if (NOT entries)
-  message(FATAL_ERROR "LOGFILE contained no build entries ('${LOGFILE}').")
-endif()
-
-# Sort in descending order:
-list(SORT entries)
-list(REVERSE entries)
-
-# Dump table:
-message(STATUS "-----------------------+----------------------------")
-message(STATUS "Time                   | Command                    ")
-message(STATUS "-----------------------+----------------------------")
-
-foreach(entry ${entries})
-  message(STATUS ${entry})
-endforeach()

spaces/CVPR/LIVE/thrust/thrust/system/cpp/detail/get_value.h

@@ -1,23 +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.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-// this system inherits get_value
-#include <thrust/system/detail/sequential/get_value.h>
-

spaces/CikeyQI/meme-api/meme_generator/memes/marriage/__init__.py

@@ -1,27 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from pil_utils import BuildImage
-
-from meme_generator import add_meme
-
-img_dir = Path(__file__).parent / "images"
-
-
-def marriage(images: List[BuildImage], texts, args):
-    img = images[0].convert("RGBA").resize_height(1080)
-    img_w, img_h = img.size
-    if img_w > 1500:
-        img_w = 1500
-    elif img_w < 800:
-        img_h = int(img_h * img_w / 800)
-    frame = img.resize_canvas((img_w, img_h)).resize_height(1080)
-    left = BuildImage.open(img_dir / "0.png")
-    right = BuildImage.open(img_dir / "1.png")
-    frame.paste(left, alpha=True).paste(
-        right, (frame.width - right.width, 0), alpha=True
-    )
-    return frame.save_jpg()
-
-
-add_meme("marriage", marriage, min_images=1, max_images=1, keywords=["结婚申请", "结婚登记"])

spaces/CodingBillionaire/bark-voice-cloning/hubert/pre_kmeans_hubert.py

@@ -1,85 +0,0 @@
-from pathlib import Path
-
-import torch
-from torch import nn
-from einops import pack, unpack
-
-import fairseq
-
-from torchaudio.functional import resample
-
-import logging
-logging.root.setLevel(logging.ERROR)
-
-
-def exists(val):
-    return val is not None
-
-
-def default(val, d):
-    return val if exists(val) else d
-
-
-class CustomHubert(nn.Module):
-    """
-    checkpoint and kmeans can be downloaded at https://github.com/facebookresearch/fairseq/tree/main/examples/hubert
-    or you can train your own
-    """
-
-    def __init__(
-        self,
-        checkpoint_path,
-        target_sample_hz=16000,
-        seq_len_multiple_of=None,
-        output_layer=9
-    ):
-        super().__init__()
-        self.target_sample_hz = target_sample_hz
-        self.seq_len_multiple_of = seq_len_multiple_of
-        self.output_layer = output_layer
-
-        model_path = Path(checkpoint_path)
-
-        assert model_path.exists(), f'path {checkpoint_path} does not exist'
-
-        checkpoint = torch.load(checkpoint_path)
-        load_model_input = {checkpoint_path: checkpoint}
-        model, *_ = fairseq.checkpoint_utils.load_model_ensemble_and_task(load_model_input)
-
-        self.model = model[0]
-        self.model.eval()
-
-    @property
-    def groups(self):
-        return 1
-
-    @torch.no_grad()
-    def forward(
-        self,
-        wav_input,
-        flatten=True,
-        input_sample_hz=None
-    ):
-        device = wav_input.device
-
-        if exists(input_sample_hz):
-            wav_input = resample(wav_input, input_sample_hz, self.target_sample_hz)
-
-        embed = self.model(
-            wav_input,
-            features_only=True,
-            mask=False,  # thanks to @maitycyrus for noticing that mask is defaulted to True in the fairseq code
-            output_layer=self.output_layer
-        )
-
-        embed, packed_shape = pack([embed['x']], '* d')
-
-        # codebook_indices = self.kmeans.predict(embed.cpu().detach().numpy())
-
-        codebook_indices = torch.from_numpy(embed.cpu().detach().numpy()).to(device)  # .long()
-
-        if flatten:
-            return codebook_indices
-
-        codebook_indices, = unpack(codebook_indices, packed_shape, '*')
-        return codebook_indices

spaces/CofAI/tv/public/index.html

@@ -1,325 +0,0 @@
-<html>
-  <head>
-    <title>☕ CofTV</title>
-    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/full.css" rel="stylesheet" type="text/css" />
-    <!--<link href="https://vjs.zencdn.net/8.3.0/video-js.css" rel="stylesheet" />-->
-    <script src="/mpegts.js"></script>
-  </head>
-  <body
-    x-data="app()" x-init="init()"
-    class="fixed inset-0 bg-[rgb(0,0,0)] flex flex-col w-full items-center justify-start">
-    <div x-show="!enabled">Loading CofTV...</div>
-      
-    <div
-      x-show="enabled && showToolbar"
-      x-transition:enter="transition ease-out duration-100"
-      x-transition:enter-start="opacity-0 -translate-y-8"
-      x-transition:enter-end="opacity-100"
-      x-transition:leave="transition ease-in duration-200"
-      x-transition:leave-start="opacity-100"
-      x-transition:leave-end="opacity-0 -translate-y-8"
-      class="fixed w-full z-20 py-4 px-6 top-0 font-mono text-white flex flex-col lg:flex-row items-center justify-between space-x-1 bg-black bg-opacity-60"
-      style="text-shadow: 0px 0px 3px #000000">
-      
-      <div class="flex text-xl space-x-2">
-        <div class="text-xl">☕ CofTV </div>
-        <div class="text-md">👉 Текущий канал:</div>
-        <template x-for="chan in channels">
-          <div
-            class="text-xl mr-2"
-            :class="chan.id === channel.id
-            ? 'font-bold'
-            : 'hover:underline opacity-60 hover:opacity-80 cursor-pointer'"
-            x-on:click="window.location = `${window.location.origin}/?channel=${chan.id}`"
-            x-text="chan.label">
-            <div class="animate-ping absolute inline-flex h-4 w-4 rounded-full bg-red-400 opacity-75"></div>
-          </div>
-        </template>
-      </div>
-
-      <div class="flex justify-between space-x-6 items-center">
-      
-        <div class="flex items-center justify-center text-white opacity-100 space-x-2">
-          <div>
-            <svg xmlns="http://www.w3.org/2000/svg" width="24px" height="24px" viewBox="0 0 640 512"><path fill="currentColor" d="M96 128a128 128 0 1 1 256 0A128 128 0 1 1 96 128zM0 482.3C0 383.8 79.8 304 178.3 304h91.4C368.2 304 448 383.8 448 482.3c0 16.4-13.3 29.7-29.7 29.7H29.7C13.3 512 0 498.7 0 482.3zM609.3 512H471.4c5.4-9.4 8.6-20.3 8.6-32v-8c0-60.7-27.1-115.2-69.8-151.8c2.4-.1 4.7-.2 7.1-.2h61.4C567.8 320 640 392.2 640 481.3c0 17-13.8 30.7-30.7 30.7zM432 256c-31 0-59-12.6-79.3-32.9C372.4 196.5 384 163.6 384 128c0-26.8-6.6-52.1-18.3-74.3C384.3 40.1 407.2 32 432 32c61.9 0 112 50.1 112 112s-50.1 112-112 112z"/></svg>
-          </div>
-          <div x-text="channel.audience"></div>
-          <div x-text="channel.audience > 1 ? 'viewers' : '🟢 Онлайн'"></div>
-        </div>
-
-        <div class="text-sm">(<a
-          class="hover:underline"
-          href="https://huggingface.co/facebook/musicgen-melody"
-          target="_blank">musicgen-melody</a> + <a
-          class="hover:underline"
-          :href="channel.modelUrl"
-          x-text="channel.model"
-          target="_blank"></a>)</div>
-      
-        <div
-          x-on:click="toggleAudio()"
-          class="flex items-center justify-center text-white opacity-80 hover:opacity-100 cursor-pointer">
-          <div x-show="muted">
-            <svg aria-hidden="true" role="img" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="32px" height="32px"><path fill="currentColor" d="M215.03 71.05L126.06 160H24c-13.26 0-24 10.74-24 24v144c0 13.25 10.74 24 24 24h102.06l88.97 88.95c15.03 15.03 40.97 4.47 40.97-16.97V88.02c0-21.46-25.96-31.98-40.97-16.97zM461.64 256l45.64-45.64c6.3-6.3 6.3-16.52 0-22.82l-22.82-22.82c-6.3-6.3-16.52-6.3-22.82 0L416 210.36l-45.64-45.64c-6.3-6.3-16.52-6.3-22.82 0l-22.82 22.82c-6.3 6.3-6.3 16.52 0 22.82L370.36 256l-45.63 45.63c-6.3 6.3-6.3 16.52 0 22.82l22.82 22.82c6.3 6.3 16.52 6.3 22.82 0L416 301.64l45.64 45.64c6.3 6.3 16.52 6.3 22.82 0l22.82-22.82c6.3-6.3 6.3-16.52 0-22.82L461.64 256z" class=""></path></svg>
-          </div>
-          <div x-show="!muted">
-            <svg aria-hidden="true" role="img" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 480 512" width="32px" height="32px"><path fill="currentColor" d="M215.03 71.05L126.06 160H24c-13.26 0-24 10.74-24 24v144c0 13.25 10.74 24 24 24h102.06l88.97 88.95c15.03 15.03 40.97 4.47 40.97-16.97V88.02c0-21.46-25.96-31.98-40.97-16.97zM480 256c0-63.53-32.06-121.94-85.77-156.24-11.19-7.14-26.03-3.82-33.12 7.46s-3.78 26.21 7.41 33.36C408.27 165.97 432 209.11 432 256s-23.73 90.03-63.48 115.42c-11.19 7.14-14.5 22.07-7.41 33.36 6.51 10.36 21.12 15.14 33.12 7.46C447.94 377.94 480 319.53 480 256zm-141.77-76.87c-11.58-6.33-26.19-2.16-32.61 9.45-6.39 11.61-2.16 26.2 9.45 32.61C327.98 228.28 336 241.63 336 256c0 14.38-8.02 27.72-20.92 34.81-11.61 6.41-15.84 21-9.45 32.61 6.43 11.66 21.05 15.8 32.61 9.45 28.23-15.55 45.77-45 45.77-76.88s-17.54-61.32-45.78-76.86z" class=""></path></svg>
-          </div>
-        </div>
-        <div
-          x-on:click="fullscreen()"
-          class="text-white hover:text-white opacity-80 hover:opacity-100 cursor-pointer">
-          <?xml version="1.0" ?><svg version="1.1" viewBox="0 0 14 14" width="24px" height="24px" xmlns="http://www.w3.org/2000/svg" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns" xmlns:xlink="http://www.w3.org/1999/xlink"><title/><desc/><defs/><g fill="none" fill-rule="evenodd" id="Page-1" stroke="none" stroke-width="1"><g fill="currentColor" id="Core" transform="translate(-215.000000, -257.000000)"><g id="fullscreen" transform="translate(215.000000, 257.000000)"><path d="M2,9 L0,9 L0,14 L5,14 L5,12 L2,12 L2,9 L2,9 Z M0,5 L2,5 L2,2 L5,2 L5,0 L0,0 L0,5 L0,5 Z M12,12 L9,12 L9,14 L14,14 L14,9 L12,9 L12,12 L12,12 Z M9,0 L9,2 L12,2 L12,5 L14,5 L14,0 L9,0 L9,0 Z" id="Shape"/></g></g></g></svg>
-        </div>
-      </div>
-    </div>
-    <div class="flex w-full">
-      <video id="videoElement" muted autoplay class="aspect-video w-full"></video>
-      <!--
-        We probably want to display a nice logo or decoration somewhere
-        <img src="/hf-logo.png" class="absolute mt-2 w-[16%]" />
-      -->
-    </div>
-    <script>
-      // disable analytics (we don't use VideoJS yet anyway)
-      window.HELP_IMPROVE_VIDEOJS = false
-    </script>
-    <script defer src="https://cdn.jsdelivr.net/npm/[email protected]/dist/cdn.min.js"></script>
-    <script src="https://cdn.tailwindcss.com?plugins=forms,typography,aspect-ratio"></script>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/iframe-resizer/4.3.2/iframeResizer.contentWindow.min.js"></script>
-    <!--<script src="https://vjs.zencdn.net/8.3.0/video.min.js"></script>-->
-    <script>
-
-function app() {
-  return {
-    enabled: false,
-    channels: {
-      /*
-      legacy: {
-        id: 'legacy',
-        label: '#older',
-        audience: 0,
-        online: false,
-        visible: false,
-        url: 'https://jbilcke-hf-media-server.hf.space/live/legacy.flv',
-        resolution: '576x320',
-        model: 'zeroscope_v2_576w',
-        modelUrl: 'https://huggingface.co/cerspense/zeroscope_v2_576w',
-      },
-      */
-     /*
-      hdtv: {
-        id: 'hdtv',
-        label: '#old',
-        audience: 0,
-        online: false,
-        visible: true,
-        url: 'https://jbilcke-hf-media-server.hf.space/live/hdtv.flv',
-        resolution: '1024x576_8FPS',
-        model: 'zeroscope_v2_XL',
-        modelUrl: 'https://huggingface.co/cerspense/zeroscope_v2_XL',
-      },
-      */
-      random: {
-        id: 'random',
-        label: 'Главный',
-        audience: 0,
-        online: false,
-        visible: true,
-        url: 'https://jbilcke-hf-media-server.hf.space/live/random.flv',
-        resolution: '1024x576_24FPS',
-        model: 'zeroscope_v2_XL',
-        modelUrl: 'https://huggingface.co/cerspense/zeroscope_v2_XL',
-      },
-      comedy: {
-        id: 'comedy',
-        label: 'Интересный',
-        audience: 0,
-        online: false,
-        visible: true,
-        url: 'https://jbilcke-hf-media-server.hf.space/live/comedy.flv',
-        resolution: '1024x576_24FPS',
-        model: 'zeroscope_v2_XL',
-        modelUrl: 'https://huggingface.co/cerspense/zeroscope_v2_XL',
-      },
-      documentary: {
-        id: 'documentary',
-        label: 'Документальный',
-        audience: 0,
-        online: false,
-        visible: true,
-        url: 'https://jbilcke-hf-media-server.hf.space/live/documentary.flv',
-        resolution: '1024x576_24FPS',
-        model: 'zeroscope_v2_XL',
-        modelUrl: 'https://huggingface.co/cerspense/zeroscope_v2_XL',
-      },
-    },
-    showToolbar: true,
-    muted: true,
-    initialized: false,
-    activityTimeout: null,
-    defaultChannelId: 'random',
-    video: null,
-    channel: {
-    },
-    wakeUp() {
-      this.showToolbar = true
-      clearTimeout(this.activityTimeout)
-      this.activityTimeout = setTimeout(() => {
-        this.showToolbar = false
-      }, 1500);
-    },
-    toggleAudio() {
-      if (this.video.muted) {    
-        this.video.muted = false
-       this.muted = false
-      } else {
-        this.video.muted = true
-        this.muted = true
-      }
-    },
-    async checkAudience() {
-      let audience = {}
-      try {
-        const res = await fetch('/stats')
-        audience = await res.json()
-      } catch (err) {
-        console.log('failed to check the audience, something is wrong')
-      }
-
-      window.DEBUGME = Object.entries(this.channels)
-      this.channels = Object.entries(this.channels).reduce((acc, [channel, data]) => ((console.log('debug:', {
-          ...data,
-          audience: audience[channel] || 0
-        } ), {
-        ...acc,
-        [channel]: {
-          ...data,
-          audience: audience[channel] || 0
-        } 
-      })), {})
-      this.channel = this.channels[this.channel.id]
-    },
-    fullscreen() {
-      if (this.video.requestFullscreen) {
-        this.video.requestFullscreen();
-      } else if (this.video.mozRequestFullScreen) {
-        this.video.mozRequestFullScreen();
-      } else if (this.video.webkitRequestFullscreen) {
-        this.video.webkitRequestFullscreen();
-      } else if (this.video.msRequestFullscreen) {
-        this.video.msRequestFullscreen();
-      }
-    },
-    init() {
-      if (this.initialized) {
-        console.log("already initialized")
-        return
-      }
-      this.initialized = true
-      console.log('Иницилизация CofTV')
-
-      const urlParams = new URLSearchParams(window.location.search)
-
-      const requestedChannelId = `${urlParams.get('channel') || 'random'}`
-
-      this.enabled = true
-      // this.enabled = `${urlParams.get('beta') || 'false'}` === 'true'
-
-      if (!this.enabled) {
-        return
-      }
-
-      this.video = document.getElementById('videoElement')
-
-      const defaultChannel = this.channels[this.defaultChannelId]
-      
-      this.channel = this.channels[requestedChannelId] || defaultChannel
-
-      console.log(`Selected channel: ${this.channel.label}`)
-      console.log(`Stream URL: ${this.channel.url}`)
-
-      
-      const handleActivity = () => {
-        this.wakeUp()
-      }
-      handleActivity()
-
-      document.addEventListener("touchstart", handleActivity)
-      document.addEventListener("touchmove", handleActivity)
-      document.addEventListener("click", handleActivity)
-      document.addEventListener("mousemove", handleActivity)
-
-      this.checkAudience()
-      setInterval(() => {
-        this.checkAudience()
-      }, 1000)
-
-      // detect mute/unmute events
-      this.video.addEventListener("mute", () => {
-        this.muted = true
-      }) 
-      this.video.addEventListener("unmute", () => {
-        this.muted = false
-      }) 
-      
-      // when we move outside the video, we always hide the toolbar
-      document.addEventListener("mouseleave", () => {
-        clearTimeout(this.activityTimeout)
-        this.showToolbar = false
-      })
-
-      // as a bonus, we also allow fullscreen on double click
-      this.video.addEventListener('dblclick', () => {
-        this.fullscreen()
-      })
-
-      // some devices such as the iPhone don't support MSE Live Playback
-      if (mpegts.getFeatureList().mseLivePlayback) {
-        var player = mpegts.createPlayer({
-          type: 'flv',  // could also be mpegts, m2ts, flv
-            isLive: true,
-            url: this.channel.url,
-        })
-        player.attachMediaElement(this.video)
-
-        player.on(mpegts.Events.ERROR, function (err) {
-          console.log('got an error:', err)
-          if (err.type === mpegts.ErrorTypes.NETWORK_ERROR) {
-            console.log('Network error')
-          }
-        });
-
-        player.load()
-
-        // due to an issue with our stream when the FFMPEG playlist ends,
-        // the stream gets interrupted for ~1sec, which causes the frontend to hangs up
-        // the following code tries to restart the page when that happens, but in the long term
-        // we should fix the issue on the server side (fix our FFMPEG bash script)
-        this.video.addEventListener('ended', function() {
-          console.log('Stream ended, trying to reload...')
-          setTimeout(() => {
-            console.log('Reloading the page..')
-            // Unloading and loading the source again isn't enough it seems
-            // player.unload()
-            // player.load()
-            window.location.reload()
-          }, 1200)
-        }, false)
-
-        // Handle autoplay restrictions.
-        let promise = this.video.play()
-        if (promise !== undefined) {
-          this.video.addEventListener('click', function() {
-            this.video.play()
-          })
-        }
-
-        player.play()
-      }
-    }
-  }
-}
-    </script>
-  </body>
-</html>

spaces/CrucibleAI/ControlNetMediaPipeFaceSD21/ldm/modules/image_degradation/bsrgan_light.py

@@ -1,651 +0,0 @@
-# -*- coding: utf-8 -*-
-import numpy as np
-import cv2
-import torch
-
-from functools import partial
-import random
-from scipy import ndimage
-import scipy
-import scipy.stats as ss
-from scipy.interpolate import interp2d
-from scipy.linalg import orth
-import albumentations
-
-import ldm.modules.image_degradation.utils_image as util
-
-"""
-# --------------------------------------------
-# Super-Resolution
-# --------------------------------------------
-#
-# Kai Zhang ([email protected])
-# https://github.com/cszn
-# From 2019/03--2021/08
-# --------------------------------------------
-"""
-
-def modcrop_np(img, sf):
-    '''
-    Args:
-        img: numpy image, WxH or WxHxC
-        sf: scale factor
-    Return:
-        cropped image
-    '''
-    w, h = img.shape[:2]
-    im = np.copy(img)
-    return im[:w - w % sf, :h - h % sf, ...]
-
-
-"""
-# --------------------------------------------
-# anisotropic Gaussian kernels
-# --------------------------------------------
-"""
-
-
-def analytic_kernel(k):
-    """Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)"""
-    k_size = k.shape[0]
-    # Calculate the big kernels size
-    big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2))
-    # Loop over the small kernel to fill the big one
-    for r in range(k_size):
-        for c in range(k_size):
-            big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k
-    # Crop the edges of the big kernel to ignore very small values and increase run time of SR
-    crop = k_size // 2
-    cropped_big_k = big_k[crop:-crop, crop:-crop]
-    # Normalize to 1
-    return cropped_big_k / cropped_big_k.sum()
-
-
-def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6):
-    """ generate an anisotropic Gaussian kernel
-    Args:
-        ksize : e.g., 15, kernel size
-        theta : [0,  pi], rotation angle range
-        l1    : [0.1,50], scaling of eigenvalues
-        l2    : [0.1,l1], scaling of eigenvalues
-        If l1 = l2, will get an isotropic Gaussian kernel.
-    Returns:
-        k     : kernel
-    """
-
-    v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.]))
-    V = np.array([[v[0], v[1]], [v[1], -v[0]]])
-    D = np.array([[l1, 0], [0, l2]])
-    Sigma = np.dot(np.dot(V, D), np.linalg.inv(V))
-    k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize)
-
-    return k
-
-
-def gm_blur_kernel(mean, cov, size=15):
-    center = size / 2.0 + 0.5
-    k = np.zeros([size, size])
-    for y in range(size):
-        for x in range(size):
-            cy = y - center + 1
-            cx = x - center + 1
-            k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov)
-
-    k = k / np.sum(k)
-    return k
-
-
-def shift_pixel(x, sf, upper_left=True):
-    """shift pixel for super-resolution with different scale factors
-    Args:
-        x: WxHxC or WxH
-        sf: scale factor
-        upper_left: shift direction
-    """
-    h, w = x.shape[:2]
-    shift = (sf - 1) * 0.5
-    xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0)
-    if upper_left:
-        x1 = xv + shift
-        y1 = yv + shift
-    else:
-        x1 = xv - shift
-        y1 = yv - shift
-
-    x1 = np.clip(x1, 0, w - 1)
-    y1 = np.clip(y1, 0, h - 1)
-
-    if x.ndim == 2:
-        x = interp2d(xv, yv, x)(x1, y1)
-    if x.ndim == 3:
-        for i in range(x.shape[-1]):
-            x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1)
-
-    return x
-
-
-def blur(x, k):
-    '''
-    x: image, NxcxHxW
-    k: kernel, Nx1xhxw
-    '''
-    n, c = x.shape[:2]
-    p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2
-    x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate')
-    k = k.repeat(1, c, 1, 1)
-    k = k.view(-1, 1, k.shape[2], k.shape[3])
-    x = x.view(1, -1, x.shape[2], x.shape[3])
-    x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c)
-    x = x.view(n, c, x.shape[2], x.shape[3])
-
-    return x
-
-
-def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0):
-    """"
-    # modified version of https://github.com/assafshocher/BlindSR_dataset_generator
-    # Kai Zhang
-    # min_var = 0.175 * sf  # variance of the gaussian kernel will be sampled between min_var and max_var
-    # max_var = 2.5 * sf
-    """
-    # Set random eigen-vals (lambdas) and angle (theta) for COV matrix
-    lambda_1 = min_var + np.random.rand() * (max_var - min_var)
-    lambda_2 = min_var + np.random.rand() * (max_var - min_var)
-    theta = np.random.rand() * np.pi  # random theta
-    noise = -noise_level + np.random.rand(*k_size) * noise_level * 2
-
-    # Set COV matrix using Lambdas and Theta
-    LAMBDA = np.diag([lambda_1, lambda_2])
-    Q = np.array([[np.cos(theta), -np.sin(theta)],
-                  [np.sin(theta), np.cos(theta)]])
-    SIGMA = Q @ LAMBDA @ Q.T
-    INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :]
-
-    # Set expectation position (shifting kernel for aligned image)
-    MU = k_size // 2 - 0.5 * (scale_factor - 1)  # - 0.5 * (scale_factor - k_size % 2)
-    MU = MU[None, None, :, None]
-
-    # Create meshgrid for Gaussian
-    [X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1]))
-    Z = np.stack([X, Y], 2)[:, :, :, None]
-
-    # Calcualte Gaussian for every pixel of the kernel
-    ZZ = Z - MU
-    ZZ_t = ZZ.transpose(0, 1, 3, 2)
-    raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise)
-
-    # shift the kernel so it will be centered
-    # raw_kernel_centered = kernel_shift(raw_kernel, scale_factor)
-
-    # Normalize the kernel and return
-    # kernel = raw_kernel_centered / np.sum(raw_kernel_centered)
-    kernel = raw_kernel / np.sum(raw_kernel)
-    return kernel
-
-
-def fspecial_gaussian(hsize, sigma):
-    hsize = [hsize, hsize]
-    siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0]
-    std = sigma
-    [x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1))
-    arg = -(x * x + y * y) / (2 * std * std)
-    h = np.exp(arg)
-    h[h < scipy.finfo(float).eps * h.max()] = 0
-    sumh = h.sum()
-    if sumh != 0:
-        h = h / sumh
-    return h
-
-
-def fspecial_laplacian(alpha):
-    alpha = max([0, min([alpha, 1])])
-    h1 = alpha / (alpha + 1)
-    h2 = (1 - alpha) / (alpha + 1)
-    h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]]
-    h = np.array(h)
-    return h
-
-
-def fspecial(filter_type, *args, **kwargs):
-    '''
-    python code from:
-    https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py
-    '''
-    if filter_type == 'gaussian':
-        return fspecial_gaussian(*args, **kwargs)
-    if filter_type == 'laplacian':
-        return fspecial_laplacian(*args, **kwargs)
-
-
-"""
-# --------------------------------------------
-# degradation models
-# --------------------------------------------
-"""
-
-
-def bicubic_degradation(x, sf=3):
-    '''
-    Args:
-        x: HxWxC image, [0, 1]
-        sf: down-scale factor
-    Return:
-        bicubicly downsampled LR image
-    '''
-    x = util.imresize_np(x, scale=1 / sf)
-    return x
-
-
-def srmd_degradation(x, k, sf=3):
-    ''' blur + bicubic downsampling
-    Args:
-        x: HxWxC image, [0, 1]
-        k: hxw, double
-        sf: down-scale factor
-    Return:
-        downsampled LR image
-    Reference:
-        @inproceedings{zhang2018learning,
-          title={Learning a single convolutional super-resolution network for multiple degradations},
-          author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
-          booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
-          pages={3262--3271},
-          year={2018}
-        }
-    '''
-    x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap')  # 'nearest' | 'mirror'
-    x = bicubic_degradation(x, sf=sf)
-    return x
-
-
-def dpsr_degradation(x, k, sf=3):
-    ''' bicubic downsampling + blur
-    Args:
-        x: HxWxC image, [0, 1]
-        k: hxw, double
-        sf: down-scale factor
-    Return:
-        downsampled LR image
-    Reference:
-        @inproceedings{zhang2019deep,
-          title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels},
-          author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
-          booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
-          pages={1671--1681},
-          year={2019}
-        }
-    '''
-    x = bicubic_degradation(x, sf=sf)
-    x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
-    return x
-
-
-def classical_degradation(x, k, sf=3):
-    ''' blur + downsampling
-    Args:
-        x: HxWxC image, [0, 1]/[0, 255]
-        k: hxw, double
-        sf: down-scale factor
-    Return:
-        downsampled LR image
-    '''
-    x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
-    # x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2))
-    st = 0
-    return x[st::sf, st::sf, ...]
-
-
-def add_sharpening(img, weight=0.5, radius=50, threshold=10):
-    """USM sharpening. borrowed from real-ESRGAN
-    Input image: I; Blurry image: B.
-    1. K = I + weight * (I - B)
-    2. Mask = 1 if abs(I - B) > threshold, else: 0
-    3. Blur mask:
-    4. Out = Mask * K + (1 - Mask) * I
-    Args:
-        img (Numpy array): Input image, HWC, BGR; float32, [0, 1].
-        weight (float): Sharp weight. Default: 1.
-        radius (float): Kernel size of Gaussian blur. Default: 50.
-        threshold (int):
-    """
-    if radius % 2 == 0:
-        radius += 1
-    blur = cv2.GaussianBlur(img, (radius, radius), 0)
-    residual = img - blur
-    mask = np.abs(residual) * 255 > threshold
-    mask = mask.astype('float32')
-    soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0)
-
-    K = img + weight * residual
-    K = np.clip(K, 0, 1)
-    return soft_mask * K + (1 - soft_mask) * img
-
-
-def add_blur(img, sf=4):
-    wd2 = 4.0 + sf
-    wd = 2.0 + 0.2 * sf
-
-    wd2 = wd2/4
-    wd = wd/4
-
-    if random.random() < 0.5:
-        l1 = wd2 * random.random()
-        l2 = wd2 * random.random()
-        k = anisotropic_Gaussian(ksize=random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2)
-    else:
-        k = fspecial('gaussian', random.randint(2, 4) + 3, wd * random.random())
-    img = ndimage.convolve(img, np.expand_dims(k, axis=2), mode='mirror')
-
-    return img
-
-
-def add_resize(img, sf=4):
-    rnum = np.random.rand()
-    if rnum > 0.8:  # up
-        sf1 = random.uniform(1, 2)
-    elif rnum < 0.7:  # down
-        sf1 = random.uniform(0.5 / sf, 1)
-    else:
-        sf1 = 1.0
-    img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3]))
-    img = np.clip(img, 0.0, 1.0)
-
-    return img
-
-
-# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
-#     noise_level = random.randint(noise_level1, noise_level2)
-#     rnum = np.random.rand()
-#     if rnum > 0.6:  # add color Gaussian noise
-#         img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
-#     elif rnum < 0.4:  # add grayscale Gaussian noise
-#         img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
-#     else:  # add  noise
-#         L = noise_level2 / 255.
-#         D = np.diag(np.random.rand(3))
-#         U = orth(np.random.rand(3, 3))
-#         conv = np.dot(np.dot(np.transpose(U), D), U)
-#         img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
-#     img = np.clip(img, 0.0, 1.0)
-#     return img
-
-def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
-    noise_level = random.randint(noise_level1, noise_level2)
-    rnum = np.random.rand()
-    if rnum > 0.6:  # add color Gaussian noise
-        img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
-    elif rnum < 0.4:  # add grayscale Gaussian noise
-        img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
-    else:  # add  noise
-        L = noise_level2 / 255.
-        D = np.diag(np.random.rand(3))
-        U = orth(np.random.rand(3, 3))
-        conv = np.dot(np.dot(np.transpose(U), D), U)
-        img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
-    img = np.clip(img, 0.0, 1.0)
-    return img
-
-
-def add_speckle_noise(img, noise_level1=2, noise_level2=25):
-    noise_level = random.randint(noise_level1, noise_level2)
-    img = np.clip(img, 0.0, 1.0)
-    rnum = random.random()
-    if rnum > 0.6:
-        img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
-    elif rnum < 0.4:
-        img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
-    else:
-        L = noise_level2 / 255.
-        D = np.diag(np.random.rand(3))
-        U = orth(np.random.rand(3, 3))
-        conv = np.dot(np.dot(np.transpose(U), D), U)
-        img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
-    img = np.clip(img, 0.0, 1.0)
-    return img
-
-
-def add_Poisson_noise(img):
-    img = np.clip((img * 255.0).round(), 0, 255) / 255.
-    vals = 10 ** (2 * random.random() + 2.0)  # [2, 4]
-    if random.random() < 0.5:
-        img = np.random.poisson(img * vals).astype(np.float32) / vals
-    else:
-        img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114])
-        img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255.
-        noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray
-        img += noise_gray[:, :, np.newaxis]
-    img = np.clip(img, 0.0, 1.0)
-    return img
-
-
-def add_JPEG_noise(img):
-    quality_factor = random.randint(80, 95)
-    img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR)
-    result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor])
-    img = cv2.imdecode(encimg, 1)
-    img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB)
-    return img
-
-
-def random_crop(lq, hq, sf=4, lq_patchsize=64):
-    h, w = lq.shape[:2]
-    rnd_h = random.randint(0, h - lq_patchsize)
-    rnd_w = random.randint(0, w - lq_patchsize)
-    lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :]
-
-    rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf)
-    hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :]
-    return lq, hq
-
-
-def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None):
-    """
-    This is the degradation model of BSRGAN from the paper
-    "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
-    ----------
-    img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf)
-    sf: scale factor
-    isp_model: camera ISP model
-    Returns
-    -------
-    img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
-    hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
-    """
-    isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
-    sf_ori = sf
-
-    h1, w1 = img.shape[:2]
-    img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...]  # mod crop
-    h, w = img.shape[:2]
-
-    if h < lq_patchsize * sf or w < lq_patchsize * sf:
-        raise ValueError(f'img size ({h1}X{w1}) is too small!')
-
-    hq = img.copy()
-
-    if sf == 4 and random.random() < scale2_prob:  # downsample1
-        if np.random.rand() < 0.5:
-            img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])),
-                             interpolation=random.choice([1, 2, 3]))
-        else:
-            img = util.imresize_np(img, 1 / 2, True)
-        img = np.clip(img, 0.0, 1.0)
-        sf = 2
-
-    shuffle_order = random.sample(range(7), 7)
-    idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
-    if idx1 > idx2:  # keep downsample3 last
-        shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
-
-    for i in shuffle_order:
-
-        if i == 0:
-            img = add_blur(img, sf=sf)
-
-        elif i == 1:
-            img = add_blur(img, sf=sf)
-
-        elif i == 2:
-            a, b = img.shape[1], img.shape[0]
-            # downsample2
-            if random.random() < 0.75:
-                sf1 = random.uniform(1, 2 * sf)
-                img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])),
-                                 interpolation=random.choice([1, 2, 3]))
-            else:
-                k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
-                k_shifted = shift_pixel(k, sf)
-                k_shifted = k_shifted / k_shifted.sum()  # blur with shifted kernel
-                img = ndimage.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror')
-                img = img[0::sf, 0::sf, ...]  # nearest downsampling
-            img = np.clip(img, 0.0, 1.0)
-
-        elif i == 3:
-            # downsample3
-            img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
-            img = np.clip(img, 0.0, 1.0)
-
-        elif i == 4:
-            # add Gaussian noise
-            img = add_Gaussian_noise(img, noise_level1=2, noise_level2=8)
-
-        elif i == 5:
-            # add JPEG noise
-            if random.random() < jpeg_prob:
-                img = add_JPEG_noise(img)
-
-        elif i == 6:
-            # add processed camera sensor noise
-            if random.random() < isp_prob and isp_model is not None:
-                with torch.no_grad():
-                    img, hq = isp_model.forward(img.copy(), hq)
-
-    # add final JPEG compression noise
-    img = add_JPEG_noise(img)
-
-    # random crop
-    img, hq = random_crop(img, hq, sf_ori, lq_patchsize)
-
-    return img, hq
-
-
-# todo no isp_model?
-def degradation_bsrgan_variant(image, sf=4, isp_model=None, up=False):
-    """
-    This is the degradation model of BSRGAN from the paper
-    "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
-    ----------
-    sf: scale factor
-    isp_model: camera ISP model
-    Returns
-    -------
-    img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
-    hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
-    """
-    image = util.uint2single(image)
-    isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
-    sf_ori = sf
-
-    h1, w1 = image.shape[:2]
-    image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...]  # mod crop
-    h, w = image.shape[:2]
-
-    hq = image.copy()
-
-    if sf == 4 and random.random() < scale2_prob:  # downsample1
-        if np.random.rand() < 0.5:
-            image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])),
-                               interpolation=random.choice([1, 2, 3]))
-        else:
-            image = util.imresize_np(image, 1 / 2, True)
-        image = np.clip(image, 0.0, 1.0)
-        sf = 2
-
-    shuffle_order = random.sample(range(7), 7)
-    idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
-    if idx1 > idx2:  # keep downsample3 last
-        shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
-
-    for i in shuffle_order:
-
-        if i == 0:
-            image = add_blur(image, sf=sf)
-
-        # elif i == 1:
-        #     image = add_blur(image, sf=sf)
-
-        if i == 0:
-            pass
-
-        elif i == 2:
-            a, b = image.shape[1], image.shape[0]
-            # downsample2
-            if random.random() < 0.8:
-                sf1 = random.uniform(1, 2 * sf)
-                image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])),
-                                   interpolation=random.choice([1, 2, 3]))
-            else:
-                k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
-                k_shifted = shift_pixel(k, sf)
-                k_shifted = k_shifted / k_shifted.sum()  # blur with shifted kernel
-                image = ndimage.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror')
-                image = image[0::sf, 0::sf, ...]  # nearest downsampling
-
-            image = np.clip(image, 0.0, 1.0)
-
-        elif i == 3:
-            # downsample3
-            image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
-            image = np.clip(image, 0.0, 1.0)
-
-        elif i == 4:
-            # add Gaussian noise
-            image = add_Gaussian_noise(image, noise_level1=1, noise_level2=2)
-
-        elif i == 5:
-            # add JPEG noise
-            if random.random() < jpeg_prob:
-                image = add_JPEG_noise(image)
-        #
-        # elif i == 6:
-        #     # add processed camera sensor noise
-        #     if random.random() < isp_prob and isp_model is not None:
-        #         with torch.no_grad():
-        #             img, hq = isp_model.forward(img.copy(), hq)
-
-    # add final JPEG compression noise
-    image = add_JPEG_noise(image)
-    image = util.single2uint(image)
-    if up:
-        image = cv2.resize(image, (w1, h1), interpolation=cv2.INTER_CUBIC)  # todo: random, as above? want to condition on it then
-    example = {"image": image}
-    return example
-
-
-
-
-if __name__ == '__main__':
-    print("hey")
-    img = util.imread_uint('utils/test.png', 3)
-    img = img[:448, :448]
-    h = img.shape[0] // 4
-    print("resizing to", h)
-    sf = 4
-    deg_fn = partial(degradation_bsrgan_variant, sf=sf)
-    for i in range(20):
-        print(i)
-        img_hq = img
-        img_lq = deg_fn(img)["image"]
-        img_hq, img_lq = util.uint2single(img_hq), util.uint2single(img_lq)
-        print(img_lq)
-        img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img_hq)["image"]
-        print(img_lq.shape)
-        print("bicubic", img_lq_bicubic.shape)
-        print(img_hq.shape)
-        lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
-                                interpolation=0)
-        lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic),
-                                        (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
-                                        interpolation=0)
-        img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1)
-        util.imsave(img_concat, str(i) + '.png')

spaces/DEBO-PROJECT/DEBO-V1/modules/whisper_modules.py

@@ -1,75 +0,0 @@
-import openai
-import os
-import random
-
-from langchain.prompts import PromptTemplate
-from modules.gpt_modules import gpt_call
-# from dotenv import dotenv_values
-
-# config = dotenv_values(".env")
-
-# if config:
-#     openai.organization = config.get('OPENAI_ORGANIZATION')
-#     openai.api_key = config.get('OPENAI_API_KEY')
-# else:
-#     openai.organization = st.secrets['OPENAI_ORGANIZATION'] #config.get('OPENAI_ORGANIZATION')
-#     openai.api_key = st.secrets['OPENAI_API_KEY'] #config.get('OPENAI_API_KEY')
-
-
-def debate_in_sound(api_key, audio):
-    os.rename(audio, audio + '.wav')
-    file = open(audio + '.wav', "rb")
-
-    openai.api_key = api_key
-
-    # user_words
-    user_prompt = openai.Audio.transcribe("whisper-1", file).text
-
-    print("**************************************")
-    print("user_audio transcription", user_prompt)
-    print("**************************************")
-
-    # Testing Prompt
-    debate_subject = "In 2050, AI robots are able to replicate the appearance, conversation, and reaction to emotions of human beings. However, their intelligence still does not allow them to sense emotions and feelings such as pain, happiness, joy, and etc."
-
-    debate_role = [
-            "pro side", 
-            "con side",
-        ]
-    user_debate_role = random.choice(debate_role)
-    bot_debate_role = "".join([role for role in debate_role if role != user_debate_role])
-
-    debate_preset = "\n".join([
-            "Debate Rules: ",
-            "1) This debate will be divided into pro and con",
-            "2) You must counter user's arguments",
-            "3) Answer logically with an introduction, body, and conclusion.\n", #add this one.
-            "User debate role: " + user_debate_role,
-            "Bot debate roles: " + bot_debate_role + "\n",
-            "Debate subject: " + debate_subject
-        ])
-    
-    prompt_template = PromptTemplate(
-                input_variables=["prompt"],
-                template="\n".join([
-                    debate_preset, #persona
-                    "User: {prompt}",
-                    "Bot: "
-                    ])
-            )
-    bot_prompt = prompt_template.format(
-                prompt=user_prompt
-            )
-    response = gpt_call(api_key, bot_prompt)
-
-    return response
-
-
-def whisper_transcribe(api_key, audio_file):
-    openai.api_key = api_key
-
-    audio_file= open("audio/audio.wav", "rb")
-    result = openai.Audio.transcribe("whisper-1", audio_file).text
-    audio_file.close()
-
-    return result

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/helpers.py

@@ -1,959 +0,0 @@
-"""
-Defines helper methods useful for loading and caching Interface examples.
-"""
-from __future__ import annotations
-
-import ast
-import csv
-import inspect
-import os
-import shutil
-import subprocess
-import tempfile
-import threading
-import warnings
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal
-
-import matplotlib.pyplot as plt
-import numpy as np
-import PIL
-import PIL.Image
-from gradio_client import utils as client_utils
-from gradio_client.documentation import document, set_documentation_group
-
-from gradio import components, processing_utils, routes, utils
-from gradio.context import Context
-from gradio.flagging import CSVLogger
-
-if TYPE_CHECKING:  # Only import for type checking (to avoid circular imports).
-    from gradio.blocks import Block
-    from gradio.components import IOComponent
-
-CACHED_FOLDER = "gradio_cached_examples"
-LOG_FILE = "log.csv"
-
-set_documentation_group("helpers")
-
-
-def create_examples(
-    examples: list[Any] | list[list[Any]] | str,
-    inputs: IOComponent | list[IOComponent],
-    outputs: IOComponent | list[IOComponent] | None = None,
-    fn: Callable | None = None,
-    cache_examples: bool = False,
-    examples_per_page: int = 10,
-    _api_mode: bool = False,
-    label: str | None = None,
-    elem_id: str | None = None,
-    run_on_click: bool = False,
-    preprocess: bool = True,
-    postprocess: bool = True,
-    api_name: str | None | Literal[False] = False,
-    batch: bool = False,
-):
-    """Top-level synchronous function that creates Examples. Provided for backwards compatibility, i.e. so that gr.Examples(...) can be used to create the Examples component."""
-    examples_obj = Examples(
-        examples=examples,
-        inputs=inputs,
-        outputs=outputs,
-        fn=fn,
-        cache_examples=cache_examples,
-        examples_per_page=examples_per_page,
-        _api_mode=_api_mode,
-        label=label,
-        elem_id=elem_id,
-        run_on_click=run_on_click,
-        preprocess=preprocess,
-        postprocess=postprocess,
-        api_name=api_name,
-        batch=batch,
-        _initiated_directly=False,
-    )
-    client_utils.synchronize_async(examples_obj.create)
-    return examples_obj
-
-
-@document()
-class Examples:
-    """
-    This class is a wrapper over the Dataset component and can be used to create Examples
-    for Blocks / Interfaces. Populates the Dataset component with examples and
-    assigns event listener so that clicking on an example populates the input/output
-    components. Optionally handles example caching for fast inference.
-
-    Demos: blocks_inputs, fake_gan
-    Guides: more-on-examples-and-flagging, using-hugging-face-integrations, image-classification-in-pytorch, image-classification-in-tensorflow, image-classification-with-vision-transformers, create-your-own-friends-with-a-gan
-    """
-
-    def __init__(
-        self,
-        examples: list[Any] | list[list[Any]] | str,
-        inputs: IOComponent | list[IOComponent],
-        outputs: IOComponent | list[IOComponent] | None = None,
-        fn: Callable | None = None,
-        cache_examples: bool = False,
-        examples_per_page: int = 10,
-        _api_mode: bool = False,
-        label: str | None = "Examples",
-        elem_id: str | None = None,
-        run_on_click: bool = False,
-        preprocess: bool = True,
-        postprocess: bool = True,
-        api_name: str | None | Literal[False] = False,
-        batch: bool = False,
-        _initiated_directly: bool = True,
-    ):
-        """
-        Parameters:
-            examples: example inputs that can be clicked to populate specific components. Should be nested list, in which the outer list consists of samples and each inner list consists of an input corresponding to each input component. A string path to a directory of examples can also be provided but it should be within the directory with the python file running the gradio app. If there are multiple input components and a directory is provided, a log.csv file must be present in the directory to link corresponding inputs.
-            inputs: the component or list of components corresponding to the examples
-            outputs: optionally, provide the component or list of components corresponding to the output of the examples. Required if `cache` is True.
-            fn: optionally, provide the function to run to generate the outputs corresponding to the examples. Required if `cache` is True.
-            cache_examples: if True, caches examples for fast runtime. If True, then `fn` and `outputs` must be provided. If `fn` is a generator function, then the last yielded value will be used as the output.
-            examples_per_page: how many examples to show per page.
-            label: the label to use for the examples component (by default, "Examples")
-            elem_id: an optional string that is assigned as the id of this component in the HTML DOM.
-            run_on_click: if cache_examples is False, clicking on an example does not run the function when an example is clicked. Set this to True to run the function when an example is clicked. Has no effect if cache_examples is True.
-            preprocess: if True, preprocesses the example input before running the prediction function and caching the output. Only applies if cache_examples is True.
-            postprocess: if True, postprocesses the example output after running the prediction function and before caching. Only applies if cache_examples is True.
-            api_name: Defines how the event associated with clicking on the examples appears in the API docs. Can be a string, None, or False. If False (default), the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
-            batch: If True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. Used only if cache_examples is True.
-        """
-        if _initiated_directly:
-            warnings.warn(
-                "Please use gr.Examples(...) instead of gr.examples.Examples(...) to create the Examples.",
-            )
-
-        if cache_examples and (fn is None or outputs is None):
-            raise ValueError("If caching examples, `fn` and `outputs` must be provided")
-
-        if not isinstance(inputs, list):
-            inputs = [inputs]
-        if outputs and not isinstance(outputs, list):
-            outputs = [outputs]
-
-        working_directory = Path().absolute()
-
-        if examples is None:
-            raise ValueError("The parameter `examples` cannot be None")
-        elif isinstance(examples, list) and (
-            len(examples) == 0 or isinstance(examples[0], list)
-        ):
-            pass
-        elif (
-            isinstance(examples, list) and len(inputs) == 1
-        ):  # If there is only one input component, examples can be provided as a regular list instead of a list of lists
-            examples = [[e] for e in examples]
-        elif isinstance(examples, str):
-            if not Path(examples).exists():
-                raise FileNotFoundError(
-                    f"Could not find examples directory: {examples}"
-                )
-            working_directory = examples
-            if not (Path(examples) / LOG_FILE).exists():
-                if len(inputs) == 1:
-                    examples = [[e] for e in os.listdir(examples)]
-                else:
-                    raise FileNotFoundError(
-                        "Could not find log file (required for multiple inputs): "
-                        + LOG_FILE
-                    )
-            else:
-                with open(Path(examples) / LOG_FILE) as logs:
-                    examples = list(csv.reader(logs))
-                    examples = [
-                        examples[i][: len(inputs)] for i in range(1, len(examples))
-                    ]  # remove header and unnecessary columns
-
-        else:
-            raise ValueError(
-                "The parameter `examples` must either be a string directory or a list"
-                "(if there is only 1 input component) or (more generally), a nested "
-                "list, where each sublist represents a set of inputs."
-            )
-
-        input_has_examples = [False] * len(inputs)
-        for example in examples:
-            for idx, example_for_input in enumerate(example):
-                if example_for_input is not None:
-                    try:
-                        input_has_examples[idx] = True
-                    except IndexError:
-                        pass  # If there are more example components than inputs, ignore. This can sometimes be intentional (e.g. loading from a log file where outputs and timestamps are also logged)
-
-        inputs_with_examples = [
-            inp for (inp, keep) in zip(inputs, input_has_examples) if keep
-        ]
-        non_none_examples = [
-            [ex for (ex, keep) in zip(example, input_has_examples) if keep]
-            for example in examples
-        ]
-
-        self.examples = examples
-        self.non_none_examples = non_none_examples
-        self.inputs = inputs
-        self.inputs_with_examples = inputs_with_examples
-        self.outputs = outputs
-        self.fn = fn
-        self.cache_examples = cache_examples
-        self._api_mode = _api_mode
-        self.preprocess = preprocess
-        self.postprocess = postprocess
-        self.api_name = api_name
-        self.batch = batch
-
-        with utils.set_directory(working_directory):
-            self.processed_examples = [
-                [
-                    component.postprocess(sample)
-                    for component, sample in zip(inputs, example)
-                ]
-                for example in examples
-            ]
-        self.non_none_processed_examples = [
-            [ex for (ex, keep) in zip(example, input_has_examples) if keep]
-            for example in self.processed_examples
-        ]
-        if cache_examples:
-            for example in self.examples:
-                if len([ex for ex in example if ex is not None]) != len(self.inputs):
-                    warnings.warn(
-                        "Examples are being cached but not all input components have "
-                        "example values. This may result in an exception being thrown by "
-                        "your function. If you do get an error while caching examples, make "
-                        "sure all of your inputs have example values for all of your examples "
-                        "or you provide default values for those particular parameters in your function."
-                    )
-                    break
-
-        from gradio import components
-
-        with utils.set_directory(working_directory):
-            self.dataset = components.Dataset(
-                components=inputs_with_examples,
-                samples=non_none_examples,
-                type="index",
-                label=label,
-                samples_per_page=examples_per_page,
-                elem_id=elem_id,
-            )
-
-        self.cached_folder = Path(CACHED_FOLDER) / str(self.dataset._id)
-        self.cached_file = Path(self.cached_folder) / "log.csv"
-        self.cache_examples = cache_examples
-        self.run_on_click = run_on_click
-
-    async def create(self) -> None:
-        """Caches the examples if self.cache_examples is True and creates the Dataset
-        component to hold the examples"""
-
-        async def load_example(example_id):
-            if self.cache_examples:
-                processed_example = self.non_none_processed_examples[
-                    example_id
-                ] + await self.load_from_cache(example_id)
-            else:
-                processed_example = self.non_none_processed_examples[example_id]
-            return utils.resolve_singleton(processed_example)
-
-        if Context.root_block:
-            if self.cache_examples and self.outputs:
-                targets = self.inputs_with_examples + self.outputs
-            else:
-                targets = self.inputs_with_examples
-            load_input_event = self.dataset.click(
-                load_example,
-                inputs=[self.dataset],
-                outputs=targets,  # type: ignore
-                show_progress="hidden",
-                postprocess=False,
-                queue=False,
-                api_name=self.api_name,  # type: ignore
-            )
-            if self.run_on_click and not self.cache_examples:
-                if self.fn is None:
-                    raise ValueError("Cannot run_on_click if no function is provided")
-                load_input_event.then(
-                    self.fn,
-                    inputs=self.inputs,  # type: ignore
-                    outputs=self.outputs,  # type: ignore
-                )
-
-        if self.cache_examples:
-            await self.cache()
-
-    async def cache(self) -> None:
-        """
-        Caches all of the examples so that their predictions can be shown immediately.
-        """
-        if Path(self.cached_file).exists():
-            print(
-                f"Using cache from '{utils.abspath(self.cached_folder)}' directory. If method or examples have changed since last caching, delete this folder to clear cache.\n"
-            )
-        else:
-            if Context.root_block is None:
-                raise ValueError("Cannot cache examples if not in a Blocks context")
-
-            print(f"Caching examples at: '{utils.abspath(self.cached_folder)}'")
-            cache_logger = CSVLogger()
-
-            if inspect.isgeneratorfunction(self.fn):
-
-                def get_final_item(args):  # type: ignore
-                    x = None
-                    for x in self.fn(args):  # noqa: B007  # type: ignore
-                        pass
-                    return x
-
-                fn = get_final_item
-            elif inspect.isasyncgenfunction(self.fn):
-
-                async def get_final_item(args):
-                    x = None
-                    async for x in self.fn(args):  # noqa: B007  # type: ignore
-                        pass
-                    return x
-
-                fn = get_final_item
-            else:
-                fn = self.fn
-
-            # create a fake dependency to process the examples and get the predictions
-            dependency, fn_index = Context.root_block.set_event_trigger(
-                event_name="fake_event",
-                fn=fn,
-                inputs=self.inputs_with_examples,  # type: ignore
-                outputs=self.outputs,  # type: ignore
-                preprocess=self.preprocess and not self._api_mode,
-                postprocess=self.postprocess and not self._api_mode,
-                batch=self.batch,
-            )
-
-            assert self.outputs is not None
-            cache_logger.setup(self.outputs, self.cached_folder)
-            for example_id, _ in enumerate(self.examples):
-                print(f"Caching example {example_id + 1}/{len(self.examples)}")
-                processed_input = self.processed_examples[example_id]
-                if self.batch:
-                    processed_input = [[value] for value in processed_input]
-                with utils.MatplotlibBackendMananger():
-                    prediction = await Context.root_block.process_api(
-                        fn_index=fn_index,
-                        inputs=processed_input,
-                        request=None,
-                        state={},
-                    )
-                output = prediction["data"]
-                if self.batch:
-                    output = [value[0] for value in output]
-                cache_logger.flag(output)
-            # Remove the "fake_event" to prevent bugs in loading interfaces from spaces
-            Context.root_block.dependencies.remove(dependency)
-            Context.root_block.fns.pop(fn_index)
-            print("Caching complete\n")
-
-    async def load_from_cache(self, example_id: int) -> list[Any]:
-        """Loads a particular cached example for the interface.
-        Parameters:
-            example_id: The id of the example to process (zero-indexed).
-        """
-        with open(self.cached_file, encoding="utf-8") as cache:
-            examples = list(csv.reader(cache))
-        example = examples[example_id + 1]  # +1 to adjust for header
-        output = []
-        assert self.outputs is not None
-        for component, value in zip(self.outputs, example):
-            value_to_use = value
-            try:
-                value_as_dict = ast.literal_eval(value)
-                # File components that output multiple files get saved as a python list
-                # need to pass the parsed list to serialize
-                # TODO: Better file serialization in 4.0
-                if isinstance(value_as_dict, list) and isinstance(
-                    component, components.File
-                ):
-                    value_to_use = value_as_dict
-                assert utils.is_update(value_as_dict)
-                output.append(value_as_dict)
-            except (ValueError, TypeError, SyntaxError, AssertionError):
-                output.append(
-                    component.serialize(
-                        value_to_use,
-                        self.cached_folder,
-                    )
-                )
-        return output
-
-
-class TrackedIterable:
-    def __init__(
-        self,
-        iterable: Iterable | None,
-        index: int | None,
-        length: int | None,
-        desc: str | None,
-        unit: str | None,
-        _tqdm=None,
-        progress: float | None = None,
-    ) -> None:
-        self.iterable = iterable
-        self.index = index
-        self.length = length
-        self.desc = desc
-        self.unit = unit
-        self._tqdm = _tqdm
-        self.progress = progress
-
-
-@document("__call__", "tqdm")
-class Progress(Iterable):
-    """
-    The Progress class provides a custom progress tracker that is used in a function signature.
-    To attach a Progress tracker to a function, simply add a parameter right after the input parameters that has a default value set to a `gradio.Progress()` instance.
-    The Progress tracker can then be updated in the function by calling the Progress object or using the `tqdm` method on an Iterable.
-    The Progress tracker is currently only available with `queue()`.
-    Example:
-        import gradio as gr
-        import time
-        def my_function(x, progress=gr.Progress()):
-            progress(0, desc="Starting...")
-            time.sleep(1)
-            for i in progress.tqdm(range(100)):
-                time.sleep(0.1)
-            return x
-        gr.Interface(my_function, gr.Textbox(), gr.Textbox()).queue().launch()
-    Demos: progress
-    """
-
-    def __init__(
-        self,
-        track_tqdm: bool = False,
-        _callback: Callable | None = None,  # for internal use only
-        _event_id: str | None = None,
-    ):
-        """
-        Parameters:
-            track_tqdm: If True, the Progress object will track any tqdm.tqdm iterations with the tqdm library in the function.
-        """
-        self.track_tqdm = track_tqdm
-        self._callback = _callback
-        self._event_id = _event_id
-        self.iterables: list[TrackedIterable] = []
-
-    def __len__(self):
-        return self.iterables[-1].length
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        """
-        Updates progress tracker with next item in iterable.
-        """
-        if self._callback:
-            current_iterable = self.iterables[-1]
-            while (
-                not hasattr(current_iterable.iterable, "__next__")
-                and len(self.iterables) > 0
-            ):
-                current_iterable = self.iterables.pop()
-            self._callback(
-                event_id=self._event_id,
-                iterables=self.iterables,
-            )
-            assert current_iterable.index is not None, "Index not set."
-            current_iterable.index += 1
-            try:
-                return next(current_iterable.iterable)  # type: ignore
-            except StopIteration:
-                self.iterables.pop()
-                raise
-        else:
-            return self
-
-    def __call__(
-        self,
-        progress: float | tuple[int, int | None] | None,
-        desc: str | None = None,
-        total: int | None = None,
-        unit: str = "steps",
-        _tqdm=None,
-    ):
-        """
-        Updates progress tracker with progress and message text.
-        Parameters:
-            progress: If float, should be between 0 and 1 representing completion. If Tuple, first number represents steps completed, and second value represents total steps or None if unknown. If None, hides progress bar.
-            desc: description to display.
-            total: estimated total number of steps.
-            unit: unit of iterations.
-        """
-        if self._callback:
-            if isinstance(progress, tuple):
-                index, total = progress
-                progress = None
-            else:
-                index = None
-            self._callback(
-                event_id=self._event_id,
-                iterables=self.iterables
-                + [TrackedIterable(None, index, total, desc, unit, _tqdm, progress)],
-            )
-        else:
-            return progress
-
-    def tqdm(
-        self,
-        iterable: Iterable | None,
-        desc: str | None = None,
-        total: int | None = None,
-        unit: str = "steps",
-        _tqdm=None,
-    ):
-        """
-        Attaches progress tracker to iterable, like tqdm.
-        Parameters:
-            iterable: iterable to attach progress tracker to.
-            desc: description to display.
-            total: estimated total number of steps.
-            unit: unit of iterations.
-        """
-        if self._callback:
-            if iterable is None:
-                new_iterable = TrackedIterable(None, 0, total, desc, unit, _tqdm)
-                self.iterables.append(new_iterable)
-                self._callback(event_id=self._event_id, iterables=self.iterables)
-                return self
-            length = len(iterable) if hasattr(iterable, "__len__") else None  # type: ignore
-            self.iterables.append(
-                TrackedIterable(iter(iterable), 0, length, desc, unit, _tqdm)
-            )
-        return self
-
-    def update(self, n=1):
-        """
-        Increases latest iterable with specified number of steps.
-        Parameters:
-            n: number of steps completed.
-        """
-        if self._callback and len(self.iterables) > 0:
-            current_iterable = self.iterables[-1]
-            assert current_iterable.index is not None, "Index not set."
-            current_iterable.index += n
-            self._callback(
-                event_id=self._event_id,
-                iterables=self.iterables,
-            )
-        else:
-            return
-
-    def close(self, _tqdm):
-        """
-        Removes iterable with given _tqdm.
-        """
-        if self._callback:
-            for i in range(len(self.iterables)):
-                if id(self.iterables[i]._tqdm) == id(_tqdm):
-                    self.iterables.pop(i)
-                    break
-            self._callback(
-                event_id=self._event_id,
-                iterables=self.iterables,
-            )
-        else:
-            return
-
-
-def create_tracker(root_blocks, event_id, fn, track_tqdm):
-    progress = Progress(_callback=root_blocks._queue.set_progress, _event_id=event_id)
-    if not track_tqdm:
-        return progress, fn
-
-    try:
-        _tqdm = __import__("tqdm")
-    except ModuleNotFoundError:
-        return progress, fn
-    if not hasattr(root_blocks, "_progress_tracker_per_thread"):
-        root_blocks._progress_tracker_per_thread = {}
-
-    def init_tqdm(
-        self, iterable=None, desc=None, total=None, unit="steps", *args, **kwargs
-    ):
-        self._progress = root_blocks._progress_tracker_per_thread.get(
-            threading.get_ident()
-        )
-        if self._progress is not None:
-            self._progress.event_id = event_id
-            self._progress.tqdm(iterable, desc, total, unit, _tqdm=self)
-            kwargs["file"] = open(os.devnull, "w")  # noqa: SIM115
-        self.__init__orig__(iterable, desc, total, *args, unit=unit, **kwargs)
-
-    def iter_tqdm(self):
-        if self._progress is not None:
-            return self._progress
-        else:
-            return self.__iter__orig__()
-
-    def update_tqdm(self, n=1):
-        if self._progress is not None:
-            self._progress.update(n)
-        return self.__update__orig__(n)
-
-    def close_tqdm(self):
-        if self._progress is not None:
-            self._progress.close(self)
-        return self.__close__orig__()
-
-    def exit_tqdm(self, exc_type, exc_value, traceback):
-        if self._progress is not None:
-            self._progress.close(self)
-        return self.__exit__orig__(exc_type, exc_value, traceback)
-
-    if not hasattr(_tqdm.tqdm, "__init__orig__"):
-        _tqdm.tqdm.__init__orig__ = _tqdm.tqdm.__init__
-    _tqdm.tqdm.__init__ = init_tqdm
-    if not hasattr(_tqdm.tqdm, "__update__orig__"):
-        _tqdm.tqdm.__update__orig__ = _tqdm.tqdm.update
-    _tqdm.tqdm.update = update_tqdm
-    if not hasattr(_tqdm.tqdm, "__close__orig__"):
-        _tqdm.tqdm.__close__orig__ = _tqdm.tqdm.close
-    _tqdm.tqdm.close = close_tqdm
-    if not hasattr(_tqdm.tqdm, "__exit__orig__"):
-        _tqdm.tqdm.__exit__orig__ = _tqdm.tqdm.__exit__
-    _tqdm.tqdm.__exit__ = exit_tqdm
-    if not hasattr(_tqdm.tqdm, "__iter__orig__"):
-        _tqdm.tqdm.__iter__orig__ = _tqdm.tqdm.__iter__
-    _tqdm.tqdm.__iter__ = iter_tqdm
-    if hasattr(_tqdm, "auto") and hasattr(_tqdm.auto, "tqdm"):
-        _tqdm.auto.tqdm = _tqdm.tqdm
-
-    def before_fn():
-        thread_id = threading.get_ident()
-        root_blocks._progress_tracker_per_thread[thread_id] = progress
-
-    def after_fn():
-        thread_id = threading.get_ident()
-        del root_blocks._progress_tracker_per_thread[thread_id]
-
-    tracked_fn = utils.function_wrapper(fn, before_fn=before_fn, after_fn=after_fn)
-
-    return progress, tracked_fn
-
-
-def special_args(
-    fn: Callable,
-    inputs: list[Any] | None = None,
-    request: routes.Request | None = None,
-    event_data: EventData | None = None,
-):
-    """
-    Checks if function has special arguments Request or EventData (via annotation) or Progress (via default value).
-    If inputs is provided, these values will be loaded into the inputs array.
-    Parameters:
-        fn: function to check.
-        inputs: array to load special arguments into.
-        request: request to load into inputs.
-        event_data: event-related data to load into inputs.
-    Returns:
-        updated inputs, progress index, event data index.
-    """
-    signature = inspect.signature(fn)
-    type_hints = utils.get_type_hints(fn)
-    positional_args = []
-    for param in signature.parameters.values():
-        if param.kind not in (param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD):
-            break
-        positional_args.append(param)
-    progress_index = None
-    event_data_index = None
-    for i, param in enumerate(positional_args):
-        type_hint = type_hints.get(param.name)
-        if isinstance(param.default, Progress):
-            progress_index = i
-            if inputs is not None:
-                inputs.insert(i, param.default)
-        elif type_hint == routes.Request:
-            if inputs is not None:
-                inputs.insert(i, request)
-        elif (
-            type_hint
-            and inspect.isclass(type_hint)
-            and issubclass(type_hint, EventData)
-        ):
-            event_data_index = i
-            if inputs is not None and event_data is not None:
-                inputs.insert(i, type_hint(event_data.target, event_data._data))
-        elif (
-            param.default is not param.empty and inputs is not None and len(inputs) <= i
-        ):
-            inputs.insert(i, param.default)
-    if inputs is not None:
-        while len(inputs) < len(positional_args):
-            i = len(inputs)
-            param = positional_args[i]
-            if param.default == param.empty:
-                warnings.warn("Unexpected argument. Filling with None.")
-                inputs.append(None)
-            else:
-                inputs.append(param.default)
-    return inputs or [], progress_index, event_data_index
-
-
-@document()
-def update(**kwargs) -> dict:
-    """
-    Updates component properties. When a function passed into a Gradio Interface or a Blocks events returns a typical value, it updates the value of the output component. But it is also possible to update the properties of an output component (such as the number of lines of a `Textbox` or the visibility of an `Image`) by returning the component's `update()` function, which takes as parameters any of the constructor parameters for that component.
-    This is a shorthand for using the update method on a component.
-    For example, rather than using gr.Number.update(...) you can just use gr.update(...).
-    Note that your editor's autocompletion will suggest proper parameters
-    if you use the update method on the component.
-    Demos: blocks_essay, blocks_update, blocks_essay_update
-
-    Parameters:
-        kwargs: Key-word arguments used to update the component's properties.
-    Example:
-        # Blocks Example
-        import gradio as gr
-        with gr.Blocks() as demo:
-            radio = gr.Radio([1, 2, 4], label="Set the value of the number")
-            number = gr.Number(value=2, interactive=True)
-            radio.change(fn=lambda value: gr.update(value=value), inputs=radio, outputs=number)
-        demo.launch()
-
-        # Interface example
-        import gradio as gr
-        def change_textbox(choice):
-          if choice == "short":
-              return gr.Textbox.update(lines=2, visible=True)
-          elif choice == "long":
-              return gr.Textbox.update(lines=8, visible=True)
-          else:
-              return gr.Textbox.update(visible=False)
-        gr.Interface(
-          change_textbox,
-          gr.Radio(
-              ["short", "long", "none"], label="What kind of essay would you like to write?"
-          ),
-          gr.Textbox(lines=2),
-          live=True,
-        ).launch()
-    """
-    kwargs["__type__"] = "generic_update"
-    return kwargs
-
-
-def skip() -> dict:
-    return update()
-
-
-@document()
-def make_waveform(
-    audio: str | tuple[int, np.ndarray],
-    *,
-    bg_color: str = "#f3f4f6",
-    bg_image: str | None = None,
-    fg_alpha: float = 0.75,
-    bars_color: str | tuple[str, str] = ("#fbbf24", "#ea580c"),
-    bar_count: int = 50,
-    bar_width: float = 0.6,
-) -> str:
-    """
-    Generates a waveform video from an audio file. Useful for creating an easy to share audio visualization. The output should be passed into a `gr.Video` component.
-    Parameters:
-        audio: Audio file path or tuple of (sample_rate, audio_data)
-        bg_color: Background color of waveform (ignored if bg_image is provided)
-        bg_image: Background image of waveform
-        fg_alpha: Opacity of foreground waveform
-        bars_color: Color of waveform bars. Can be a single color or a tuple of (start_color, end_color) of gradient
-        bar_count: Number of bars in waveform
-        bar_width: Width of bars in waveform. 1 represents full width, 0.5 represents half width, etc.
-    Returns:
-        A filepath to the output video in mp4 format.
-    """
-    if isinstance(audio, str):
-        audio_file = audio
-        audio = processing_utils.audio_from_file(audio)
-    else:
-        tmp_wav = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
-        processing_utils.audio_to_file(audio[0], audio[1], tmp_wav.name, format="wav")
-        audio_file = tmp_wav.name
-
-    if not os.path.isfile(audio_file):
-        raise ValueError("Audio file not found.")
-
-    ffmpeg = shutil.which("ffmpeg")
-    if not ffmpeg:
-        raise RuntimeError("ffmpeg not found.")
-
-    duration = round(len(audio[1]) / audio[0], 4)
-
-    # Helper methods to create waveform
-    def hex_to_rgb(hex_str):
-        return [int(hex_str[i : i + 2], 16) for i in range(1, 6, 2)]
-
-    def get_color_gradient(c1, c2, n):
-        assert n > 1
-        c1_rgb = np.array(hex_to_rgb(c1)) / 255
-        c2_rgb = np.array(hex_to_rgb(c2)) / 255
-        mix_pcts = [x / (n - 1) for x in range(n)]
-        rgb_colors = [((1 - mix) * c1_rgb + (mix * c2_rgb)) for mix in mix_pcts]
-        return [
-            "#" + "".join(f"{int(round(val * 255)):02x}" for val in item)
-            for item in rgb_colors
-        ]
-
-    # Reshape audio to have a fixed number of bars
-    samples = audio[1]
-    if len(samples.shape) > 1:
-        samples = np.mean(samples, 1)
-    bins_to_pad = bar_count - (len(samples) % bar_count)
-    samples = np.pad(samples, [(0, bins_to_pad)])
-    samples = np.reshape(samples, (bar_count, -1))
-    samples = np.abs(samples)
-    samples = np.max(samples, 1)
-
-    with utils.MatplotlibBackendMananger():
-        plt.clf()
-        # Plot waveform
-        color = (
-            bars_color
-            if isinstance(bars_color, str)
-            else get_color_gradient(bars_color[0], bars_color[1], bar_count)
-        )
-        plt.bar(
-            np.arange(0, bar_count),
-            samples * 2,
-            bottom=(-1 * samples),
-            width=bar_width,
-            color=color,
-        )
-        plt.axis("off")
-        plt.margins(x=0)
-        tmp_img = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
-        savefig_kwargs: dict[str, Any] = {"bbox_inches": "tight"}
-        if bg_image is not None:
-            savefig_kwargs["transparent"] = True
-        else:
-            savefig_kwargs["facecolor"] = bg_color
-        plt.savefig(tmp_img.name, **savefig_kwargs)
-        waveform_img = PIL.Image.open(tmp_img.name)
-        waveform_img = waveform_img.resize((1000, 200))
-
-        # Composite waveform with background image
-        if bg_image is not None:
-            waveform_array = np.array(waveform_img)
-            waveform_array[:, :, 3] = waveform_array[:, :, 3] * fg_alpha
-            waveform_img = PIL.Image.fromarray(waveform_array)
-
-            bg_img = PIL.Image.open(bg_image)
-            waveform_width, waveform_height = waveform_img.size
-            bg_width, bg_height = bg_img.size
-            if waveform_width != bg_width:
-                bg_img = bg_img.resize(
-                    (waveform_width, 2 * int(bg_height * waveform_width / bg_width / 2))
-                )
-                bg_width, bg_height = bg_img.size
-            composite_height = max(bg_height, waveform_height)
-            composite = PIL.Image.new(
-                "RGBA", (waveform_width, composite_height), "#FFFFFF"
-            )
-            composite.paste(bg_img, (0, composite_height - bg_height))
-            composite.paste(
-                waveform_img, (0, composite_height - waveform_height), waveform_img
-            )
-            composite.save(tmp_img.name)
-            img_width, img_height = composite.size
-        else:
-            img_width, img_height = waveform_img.size
-            waveform_img.save(tmp_img.name)
-
-    # Convert waveform to video with ffmpeg
-    output_mp4 = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-
-    ffmpeg_cmd = [
-        ffmpeg,
-        "-loop",
-        "1",
-        "-i",
-        tmp_img.name,
-        "-i",
-        audio_file,
-        "-vf",
-        f"color=c=#FFFFFF77:s={img_width}x{img_height}[bar];[0][bar]overlay=-w+(w/{duration})*t:H-h:shortest=1",
-        "-t",
-        str(duration),
-        "-y",
-        output_mp4.name,
-    ]
-
-    subprocess.check_call(ffmpeg_cmd)
-    return output_mp4.name
-
-
-@document()
-class EventData:
-    """
-    When a subclass of EventData is added as a type hint to an argument of an event listener method, this object will be passed as that argument.
-    It contains information about the event that triggered the listener, such the target object, and other data related to the specific event that are attributes of the subclass.
-
-    Example:
-        table = gr.Dataframe([[1, 2, 3], [4, 5, 6]])
-        gallery = gr.Gallery([("cat.jpg", "Cat"), ("dog.jpg", "Dog")])
-        textbox = gr.Textbox("Hello World!")
-
-        statement = gr.Textbox()
-
-        def on_select(evt: gr.SelectData):  # SelectData is a subclass of EventData
-            return f"You selected {evt.value} at {evt.index} from {evt.target}"
-
-        table.select(on_select, None, statement)
-        gallery.select(on_select, None, statement)
-        textbox.select(on_select, None, statement)
-    Demos: gallery_selections, tictactoe
-    """
-
-    def __init__(self, target: Block | None, _data: Any):
-        """
-        Parameters:
-            target: The target object that triggered the event. Can be used to distinguish if multiple components are bound to the same listener.
-        """
-        self.target = target
-        self._data = _data
-
-
-def log_message(message: str, level: Literal["info", "warning"] = "info"):
-    from gradio import context
-
-    if not hasattr(context.thread_data, "blocks"):  # Function called outside of Gradio
-        if level == "info":
-            print(message)
-        elif level == "warning":
-            warnings.warn(message)
-        return
-    if not context.thread_data.blocks.enable_queue:
-        warnings.warn(
-            f"Queueing must be enabled to issue {level.capitalize()}: '{message}'."
-        )
-        return
-    context.thread_data.blocks._queue.log_message(
-        event_id=context.thread_data.event_id, log=message, level=level
-    )
-
-
-@document()
-def Warning(message: str = "Warning issued."):  # noqa: N802
-    """
-    This function allows you to pass custom warning messages to the user. You can do so simply with `gr.Warning('message here')`, and when that line is executed the custom message will appear in a modal on the demo.
-    Parameters:
-        message: The warning message to be displayed to the user.
-    """
-    log_message(message, level="warning")
-
-
-@document()
-def Info(message: str = "Info issued."):  # noqa: N802
-    """
-    Parameters:
-        message: The info message to be displayed to the user.
-    """
-    log_message(message, level="info")

spaces/DragGan/DragGan-Inversion/stylegan_human/edit.py

@@ -1,207 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-from edit.edit_helper import conv_warper, decoder, encoder_ifg, encoder_ss, encoder_sefa
-import legacy
-import subprocess
-from typing import List, Optional
-import cv2
-import click
-from torch_utils.models import Generator
-import os
-import sys
-import torch
-import numpy as np
-sys.path.append(".")
-
-
-"""
-Edit generated images with different SOTA methods. 
- Notes:
- 1. We provide some latent directions in the folder, you can play around with them.
- 2. ''upper_length'' and ''bottom_length'' of ''attr_name'' are available for demo.
- 3. Layers to control and editing strength are set in edit/edit_config.py.
- 
-Examples:
-
-\b
-# Editing with InterfaceGAN, StyleSpace, and Sefa
-python edit.py --network pretrained_models/stylegan_human_v2_1024.pkl --attr_name upper_length \\
-    --seeds 61531,61570,61571,61610 --outdir outputs/edit_results
-
-
-# Editing using inverted latent code
-python edit.py ---network outputs/pti/checkpoints/model_test.pkl --attr_name upper_length  \\
-    --outdir outputs/edit_results --real True --real_w_path outputs/pti/embeddings/test/PTI/test/0.pt --real_img_path aligned_image/test.png
-
-"""
-
-
-@click.command()
-@click.pass_context
-@click.option('--network', 'ckpt_path', help='Network pickle filename', required=True)
-@click.option('--attr_name', help='choose one of the attr: upper_length or bottom_length', type=str, required=True)
-@click.option('--trunc', 'truncation', type=float, help='Truncation psi', default=0.8, show_default=True)
-@click.option('--gen_video', type=bool, default=True, help='If want to generate video')
-@click.option('--combine', type=bool, default=True,  help='If want to combine different editing results in the same frame')
-@click.option('--seeds', type=legacy.num_range, help='List of random seeds')
-@click.option('--outdir', help='Where to save the output images', type=str, required=True, default='outputs/editing', metavar='DIR')
-@click.option('--real', type=bool, help='True for editing real image', default=False)
-@click.option('--real_w_path',  help='Path of latent code for real image')
-@click.option('--real_img_path',  help='Path of real image, this just concat real image with inverted and edited results together')
-def main(
-    ctx: click.Context,
-    ckpt_path: str,
-    attr_name: str,
-    truncation: float,
-    gen_video: bool,
-    combine: bool,
-    seeds: Optional[List[int]],
-    outdir: str,
-    real: str,
-    real_w_path: str,
-    real_img_path: str
-):
-    # convert pkl to pth
-    # if not os.path.exists(ckpt_path.replace('.pkl','.pth')):
-    legacy.convert(ckpt_path, ckpt_path.replace('.pkl', '.pth'), G_only=real)
-    ckpt_path = ckpt_path.replace('.pkl', '.pth')
-    print("start...", flush=True)
-    config = {"latent": 512, "n_mlp": 8, "channel_multiplier": 2}
-    generator = Generator(
-        size=1024,
-        style_dim=config["latent"],
-        n_mlp=config["n_mlp"],
-        channel_multiplier=config["channel_multiplier"]
-    )
-
-    generator.load_state_dict(torch.load(ckpt_path)['g_ema'])
-    generator.eval().cuda()
-
-    with torch.no_grad():
-        mean_path = os.path.join('edit', 'mean_latent.pkl')
-        if not os.path.exists(mean_path):
-            mean_n = 3000
-            mean_latent = generator.mean_latent(mean_n).detach()
-            legacy.save_obj(mean_latent, mean_path)
-        else:
-            mean_latent = legacy.load_pkl(mean_path).cuda()
-        finals = []
-
-        ## -- selected sample seeds -- ##
-        # seeds = [60948,60965,61174,61210,61511,61598,61610] #bottom -> long
-        #         [60941,61064,61103,61313,61531,61570,61571] # bottom -> short
-        #         [60941,60965,61064,61103,6117461210,61531,61570,61571,61610] # upper --> long
-        #         [60948,61313,61511,61598] # upper --> short
-        if real:
-            seeds = [0]
-
-        for t in seeds:
-            if real:  # now assume process single real image only
-                if real_img_path:
-                    real_image = cv2.imread(real_img_path)
-                    real_image = cv2.cvtColor(real_image, cv2.COLOR_BGR2RGB)
-                    import torchvision.transforms as transforms
-                    transform = transforms.Compose(  # normalize to (-1, 1)
-                        [transforms.ToTensor(),
-                         transforms.Normalize(mean=(.5, .5, .5), std=(.5, .5, .5))]
-                    )
-                    real_image = transform(real_image).unsqueeze(0).cuda()
-
-                test_input = torch.load(real_w_path)
-                output, _ = generator(
-                    test_input, False, truncation=1, input_is_latent=True, real=True)
-
-            else:  # generate image from random seeds
-                test_input = torch.from_numpy(np.random.RandomState(
-                    t).randn(1, 512)).float().cuda()  # torch.Size([1, 512])
-                output, _ = generator(
-                    [test_input], False, truncation=truncation, truncation_latent=mean_latent, real=real)
-
-            # interfacegan
-            style_space, latent, noise = encoder_ifg(
-                generator, test_input, attr_name, truncation, mean_latent, real=real)
-            image1 = decoder(generator, style_space, latent, noise)
-            # stylespace
-            style_space, latent, noise = encoder_ss(
-                generator, test_input, attr_name, truncation, mean_latent, real=real)
-            image2 = decoder(generator, style_space, latent, noise)
-            # sefa
-            latent, noise = encoder_sefa(
-                generator, test_input, attr_name, truncation, mean_latent, real=real)
-            image3, _ = generator([latent], noise=noise, input_is_latent=True)
-            if real_img_path:
-                final = torch.cat(
-                    (real_image, output, image1, image2, image3), 3)
-            else:
-                final = torch.cat((output, image1, image2, image3), 3)
-
-            # legacy.visual(output, f'{outdir}/{attr_name}_{t:05d}_raw.jpg')
-            # legacy.visual(image1, f'{outdir}/{attr_name}_{t:05d}_ifg.jpg')
-            # legacy.visual(image2, f'{outdir}/{attr_name}_{t:05d}_ss.jpg')
-            # legacy.visual(image3, f'{outdir}/{attr_name}_{t:05d}_sefa.jpg')
-
-            if gen_video:
-                total_step = 90
-                if real:
-                    video_ifg_path = f"{outdir}/video/ifg_{attr_name}_{real_w_path.split('/')[-2]}/"
-                    video_ss_path = f"{outdir}/video/ss_{attr_name}_{real_w_path.split('/')[-2]}/"
-                    video_sefa_path = f"{outdir}/video/ss_{attr_name}_{real_w_path.split('/')[-2]}/"
-                else:
-                    video_ifg_path = f"{outdir}/video/ifg_{attr_name}_{t:05d}/"
-                    video_ss_path = f"{outdir}/video/ss_{attr_name}_{t:05d}/"
-                    video_sefa_path = f"{outdir}/video/ss_{attr_name}_{t:05d}/"
-                video_comb_path = f"{outdir}/video/tmp"
-
-                if combine:
-                    if not os.path.exists(video_comb_path):
-                        os.makedirs(video_comb_path)
-                else:
-                    if not os.path.exists(video_ifg_path):
-                        os.makedirs(video_ifg_path)
-                    if not os.path.exists(video_ss_path):
-                        os.makedirs(video_ss_path)
-                    if not os.path.exists(video_sefa_path):
-                        os.makedirs(video_sefa_path)
-                for i in range(total_step):
-                    style_space, latent, noise = encoder_ifg(
-                        generator, test_input, attr_name, truncation, mean_latent, step=i, total=total_step, real=real)
-                    image1 = decoder(generator, style_space, latent, noise)
-                    style_space, latent, noise = encoder_ss(
-                        generator, test_input, attr_name, truncation, mean_latent, step=i, total=total_step, real=real)
-                    image2 = decoder(generator, style_space, latent, noise)
-                    latent, noise = encoder_sefa(
-                        generator, test_input, attr_name, truncation, mean_latent, step=i, total=total_step, real=real)
-                    image3, _ = generator(
-                        [latent], noise=noise, input_is_latent=True)
-                    if combine:
-                        if real_img_path:
-                            comb_img = torch.cat(
-                                (real_image, output, image1, image2, image3), 3)
-                        else:
-                            comb_img = torch.cat(
-                                (output, image1, image2, image3), 3)
-                        legacy.visual(comb_img, os.path.join(
-                            video_comb_path, f'{i:05d}.jpg'))
-                    else:
-                        legacy.visual(image1, os.path.join(
-                            video_ifg_path, f'{i:05d}.jpg'))
-                        legacy.visual(image2, os.path.join(
-                            video_ss_path, f'{i:05d}.jpg'))
-                if combine:
-                    cmd = f"ffmpeg -hide_banner -loglevel error -y -r 30 -i {video_comb_path}/%05d.jpg -vcodec libx264 -pix_fmt yuv420p {video_ifg_path.replace('ifg_', '')[:-1] + '.mp4'}"
-                    subprocess.call(cmd, shell=True)
-                else:
-                    cmd = f"ffmpeg -hide_banner -loglevel error -y -r 30 -i {video_ifg_path}/%05d.jpg -vcodec libx264 -pix_fmt yuv420p {video_ifg_path[:-1] + '.mp4'}"
-                    subprocess.call(cmd, shell=True)
-                    cmd = f"ffmpeg -hide_banner -loglevel error -y -r 30 -i {video_ss_path}/%05d.jpg -vcodec libx264 -pix_fmt yuv420p {video_ss_path[:-1] + '.mp4'}"
-                    subprocess.call(cmd, shell=True)
-
-        # interfacegan, stylespace, sefa
-        finals.append(final)
-
-        final = torch.cat(finals, 2)
-        legacy.visual(final, os.path.join(outdir, 'final.jpg'))
-
-
-if __name__ == "__main__":
-    main()

spaces/Dragonnext/Unicorn-proxy/README.md

@@ -1,10 +0,0 @@
----
-title: Unicorn OAI Proxy
-emoji: 🦄
-sdk: docker
-colorFrom: gray
-colorTo: gray
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Eddycrack864/Applio-Inference/demucs/test.py

@@ -1,109 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import gzip
-import sys
-from concurrent import futures
-
-import musdb
-import museval
-import torch as th
-import tqdm
-from scipy.io import wavfile
-from torch import distributed
-
-from .audio import convert_audio
-from .utils import apply_model
-
-
-def evaluate(model,
-             musdb_path,
-             eval_folder,
-             workers=2,
-             device="cpu",
-             rank=0,
-             save=False,
-             shifts=0,
-             split=False,
-             overlap=0.25,
-             is_wav=False,
-             world_size=1):
-    """
-    Evaluate model using museval. Run the model
-    on a single GPU, the bottleneck being the call to museval.
-    """
-
-    output_dir = eval_folder / "results"
-    output_dir.mkdir(exist_ok=True, parents=True)
-    json_folder = eval_folder / "results/test"
-    json_folder.mkdir(exist_ok=True, parents=True)
-
-    # we load tracks from the original musdb set
-    test_set = musdb.DB(musdb_path, subsets=["test"], is_wav=is_wav)
-    src_rate = 44100  # hardcoded for now...
-
-    for p in model.parameters():
-        p.requires_grad = False
-        p.grad = None
-
-    pendings = []
-    with futures.ProcessPoolExecutor(workers or 1) as pool:
-        for index in tqdm.tqdm(range(rank, len(test_set), world_size), file=sys.stdout):
-            track = test_set.tracks[index]
-
-            out = json_folder / f"{track.name}.json.gz"
-            if out.exists():
-                continue
-
-            mix = th.from_numpy(track.audio).t().float()
-            ref = mix.mean(dim=0)  # mono mixture
-            mix = (mix - ref.mean()) / ref.std()
-            mix = convert_audio(mix, src_rate, model.samplerate, model.audio_channels)
-            estimates = apply_model(model, mix.to(device),
-                                    shifts=shifts, split=split, overlap=overlap)
-            estimates = estimates * ref.std() + ref.mean()
-
-            estimates = estimates.transpose(1, 2)
-            references = th.stack(
-                [th.from_numpy(track.targets[name].audio).t() for name in model.sources])
-            references = convert_audio(references, src_rate,
-                                       model.samplerate, model.audio_channels)
-            references = references.transpose(1, 2).numpy()
-            estimates = estimates.cpu().numpy()
-            win = int(1. * model.samplerate)
-            hop = int(1. * model.samplerate)
-            if save:
-                folder = eval_folder / "wav/test" / track.name
-                folder.mkdir(exist_ok=True, parents=True)
-                for name, estimate in zip(model.sources, estimates):
-                    wavfile.write(str(folder / (name + ".wav")), 44100, estimate)
-
-            if workers:
-                pendings.append((track.name, pool.submit(
-                    museval.evaluate, references, estimates, win=win, hop=hop)))
-            else:
-                pendings.append((track.name, museval.evaluate(
-                    references, estimates, win=win, hop=hop)))
-            del references, mix, estimates, track
-
-        for track_name, pending in tqdm.tqdm(pendings, file=sys.stdout):
-            if workers:
-                pending = pending.result()
-            sdr, isr, sir, sar = pending
-            track_store = museval.TrackStore(win=44100, hop=44100, track_name=track_name)
-            for idx, target in enumerate(model.sources):
-                values = {
-                    "SDR": sdr[idx].tolist(),
-                    "SIR": sir[idx].tolist(),
-                    "ISR": isr[idx].tolist(),
-                    "SAR": sar[idx].tolist()
-                }
-
-                track_store.add_target(target_name=target, values=values)
-                json_path = json_folder / f"{track_name}.json.gz"
-                gzip.open(json_path, "w").write(track_store.json.encode('utf-8'))
-    if world_size > 1:
-        distributed.barrier()

spaces/EronSamez/RVC_HFmeu/diffq/uniform.py

@@ -1,121 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Classic uniform quantization over n bits.
-"""
-from typing import Tuple
-import torch
-
-from .base import BaseQuantizer
-from .utils import simple_repr
-
-
-def uniform_quantize(p: torch.Tensor, bits: torch.Tensor = torch.tensor(8.)):
-    """
-    Quantize the given weights over `bits` bits.
-
-    Returns:
-        - quantized levels
-        - (min, max) range.
-
-    """
-    assert (bits >= 1).all() and (bits <= 15).all()
-    num_levels = (2 ** bits.float()).long()
-    mn = p.min().item()
-    mx = p.max().item()
-    p = (p - mn) / (mx - mn)  # put p in [0, 1]
-    unit = 1 / (num_levels - 1)  # quantization unit
-    levels = (p / unit).round()
-    if (bits <= 8).all():
-        levels = levels.byte()
-    else:
-        levels = levels.short()
-    return levels, (mn, mx)
-
-
-def uniform_unquantize(levels: torch.Tensor, scales: Tuple[float, float],
-                       bits: torch.Tensor = torch.tensor(8.)):
-    """
-    Unquantize the weights from the levels and scale. Return a float32 tensor.
-    """
-    mn, mx = scales
-    num_levels = 2 ** bits.float()
-    unit = 1 / (num_levels - 1)
-    levels = levels.float()
-    p = levels * unit  # in [0, 1]
-    return p * (mx - mn) + mn
-
-
-class UniformQuantizer(BaseQuantizer):
-    def __init__(self, model: torch.nn.Module, bits: float = 8., min_size: float = 0.01,
-                 float16: bool = False, qat: bool = False, exclude=[], detect_bound=True):
-        """
-        Args:
-            model (torch.nn.Module): model to quantize
-            bits (float): number of bits to quantize over.
-            min_size (float): minimum size in MB of a parameter to be quantized.
-            float16 (bool): if a layer is smaller than min_size, should we still do float16?
-            qat (bool): perform quantized aware training.
-            exclude (list[str]): list of patterns used to match parameters to exclude.
-                For instance `['bias']` to exclude all bias terms.
-            detect_bound (bool): if True, will detect bound parameters and reuse
-                the same quantized tensor for both.
-        """
-        self.bits = float(bits)
-        self.qat = qat
-
-        super().__init__(model, min_size, float16, exclude, detect_bound)
-
-    def __repr__(self):
-        return simple_repr(self, )
-
-    def _pre_forward_train(self):
-        if self.qat:
-            for qparam in self._qparams:
-                if qparam.other is not None:
-                    new_param = qparam.other.module._parameters[qparam.other.name]
-                else:
-                    quantized = self._quantize_param(qparam)
-                    qvalue = self._unquantize_param(qparam, quantized)
-                    new_param = qparam.param + (qvalue - qparam.param).detach()
-                qparam.module._parameters[qparam.name] = new_param
-            return True
-        return False
-
-    def _post_forward_train(self):
-        if self.qat:
-            for qparam in self._qparams:
-                qparam.module._parameters[qparam.name] = qparam.param
-            return True
-        return False
-
-    def _quantize_param(self, qparam):
-        levels, scales = uniform_quantize(qparam.param.data, torch.tensor(self.bits))
-        return (levels, scales)
-
-    def _unquantize_param(self, qparam, quantized):
-        levels, scales = quantized
-        return uniform_unquantize(levels, scales, torch.tensor(self.bits))
-
-    def model_size(self):
-        """
-        Non differentiable model size in MB.
-        """
-        total = super().model_size()
-        subtotal = 0
-        for qparam in self._qparams:
-            if qparam.other is None:  # if parameter is bound, count only one copy.
-                subtotal += self.bits * qparam.param.numel() + 64  # 2 float for the overall scales
-        subtotal /= 2**20 * 8  # bits to MegaBytes
-        return total + subtotal
-
-    def true_model_size(self):
-        """
-        Return the true quantized model size, in MB, without extra
-        compression.
-        """
-        return self.model_size().item()

spaces/EuroPython2022/latr-vqa/app.py

@@ -1,148 +0,0 @@
-# Requirements.txt
-from torch import cuda
-from transformers import T5Tokenizer, T5ForConditionalGeneration
-import gradio as gr
-from utils import convert_ans_to_token, convert_ques_to_token, rotate, convert_token_to_ques, convert_token_to_answer
-from modeling import LaTr_for_pretraining, LaTr_for_finetuning, LaTrForVQA
-from dataset import load_json_file, get_specific_file, resize_align_bbox, get_tokens_with_boxes, create_features
-import torch.nn as nn
-from PIL import Image, ImageDraw
-import pytesseract
-from tqdm.auto import tqdm
-import numpy as np
-import json
-import os
-import torch
-from torchvision import transforms
-
-
-# install PyTesseract
-os.system('pip install -q pytesseract')
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-
-
-# Default Library import
-# Visualization libraries
-
-# Specific libraries of LaTr
-
-# Setting the hyperparameters as well as primary configurations
-
-PAD_TOKEN_BOX = [0, 0, 0, 0]
-max_seq_len = 512
-batch_size = 2
-target_size = (500, 384)
-t5_model = "t5-base"
-
-
-device = 'cuda' if cuda.is_available() else 'cpu'
-
-
-# Configuration for the model
-config = {
-    't5_model': 't5-base',
-    'vocab_size': 32128,
-    'hidden_state': 768,
-    'max_2d_position_embeddings': 1001,
-    'classes': 32128,  # number of tokens
-    'seq_len': 512
-}
-
-tokenizer = T5Tokenizer.from_pretrained(t5_model)
-latr = LaTrForVQA(config)
-url = 'https://www.kaggleusercontent.com/kf/99663112/eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0..5-IY5sqV-Y5lb7On3LOjMg._mvffzQwAyb-JSgwqhyxcjz3clhuAIwZEep4DA0CEao2LVjijahLYK9Co6yYVbdaEVk8CVqIGCx-_08XSdcsYnkt4HzCxI6zCI6Rv9_PhHITzTCZPC4juNgsmbb3ebu2eu5kJxUGsQvikk6efkpNoXFhPS5XV-Pqx_9wfxDyRJCJ1hzSxtiZcnsobKfoQt6F2w09NWGT45ePd_UlQNloogUD6icJDSWvyLvXHaVryKPGhy3q0_yaVheoBqflipUcUb1Q7q8wRDYbA3Kg_pAJzuyfPGhEp1WUEVt9gMXO1IIUCQbiygZRdGpKZBJwDx2LylLD3NwKMqv_maUknV0pCRhES45pFpuXv0X8ITGcr8DtGeLBIa9ZHW-eUEXETZnFdJqj6lU32IEyjJBhx1nNC_w6-0AGgH9ZC2c54sxUtmfOHmB9AhjYAmXi7Nmr2mQpDTBgrlPCQmNFLJ8GPWP0G6cDAgvZryVyFUm2z7SEcUzzLH6jHyr48ggGJBikNxZ4WL3W7L-zx_6v8BQBxBUp2KcZFzrfaXO1uoY2EyD3Y4ynTEUuEncS-UdRczCZCz6PqViyHJLycMnQteTw0j0ivEsLOlJkADufPX11f8ScVadd1YU-824nD6D5Kc16DRy0z1fHl1ZouI6Ahp3wY3AT-CR5te9kvYJUn_ggjvsm4d8CYc1qI6i1lfrNeeBxXCaK.dhOQv7UopiggmdGfsp-xmQ/models/epoch=0-step=34602.ckpt'
-
-
-
-try:
-    latr = latr.load_from_checkpoint(url)
-    print("Checkpoint loaded successfully")
-except:
-    print("Checkpoint not loaded")
-    pass
-
-
-image = gr.inputs.Image(type="pil")
-question = gr.inputs.Textbox(label="Question")
-answer = gr.outputs.Textbox(label="Predicted answer")
-examples = [["remote.jpg", "what number is the button near the top left?"]]
-
-
-from transformers import ViTFeatureExtractor, ViTModel
-vit_feat_extract = ViTFeatureExtractor("google/vit-base-patch16-224-in21k")
-
-import torchvision
-import numpy as np
-
-def answer_question(image, question):
-
-    # Extracting features from the image
-    image.save("sample.png")
-    img, boxes, tokenized_words = create_features("sample.png",
-                                                  tokenizer=tokenizer,
-                                                  target_size=target_size,
-                                                  max_seq_length=max_seq_len,
-                                                  use_ocr=True
-                                                  )
-
-    ## Converting the boxes as per the format required for model input
-    boxes = torch.as_tensor(boxes, dtype=torch.int32)
-    width = (boxes[:, 2] - boxes[:, 0]).view(-1, 1)
-    height = (boxes[:, 3] - boxes[:, 1]).view(-1, 1)
-    boxes = torch.cat([boxes, width, height], axis = -1)
-
-    ## Clamping the value,as some of the box values are out of bound
-    boxes[:, 0] = torch.clamp(boxes[:, 0], min = 0, max = 0)
-    boxes[:, 2] = torch.clamp(boxes[:, 2], min = 1000, max = 1000)
-    boxes[:, 4] = torch.clamp(boxes[:, 4], min = 1000, max = 1000)
-    
-    boxes[:, 1] = torch.clamp(boxes[:, 1], min = 0, max = 0)
-    boxes[:, 3] = torch.clamp(boxes[:, 3], min = 1000, max = 1000)
-    boxes[:, 5] = torch.clamp(boxes[:, 5], min = 1000, max = 1000)
-
-    ## Tensor tokenized words
-    tokenized_words = torch.as_tensor(tokenized_words, dtype=torch.int32)    
-    img = np.array(img)
-    img = torchvision.transforms.ToTensor()(img)
-    question = convert_ques_to_token(question = question, tokenizer = tokenizer)
-
-    ## Expanding the dimension for inference
-    boxes = boxes.unsqueeze(0)
-    tokenized_words = tokenized_words.unsqueeze(0)
-    question = question.unsqueeze(0)
-
-    # print("Shape of Image is:", img.shape)
-    img = vit_feat_extract(img, return_tensors = 'pt')['pixel_values']
-    if int(len(img.shape)) == 3:
-      img = img.unsqueeze(0)
-
-    encoding = {'img': img, 'boxes': boxes, 'tokenized_words': tokenized_words, 'question': question}
-    
-    with torch.no_grad():
-        logits = latr.forward(encoding)
-        logits = logits.squeeze(0)
-
-    _, preds = torch.max(logits, dim = 1)
-    preds = preds.detach().cpu()
-    mask = torch.clamp(preds, min = 0, max = 1)
-    last_non_zero_argument = (mask != 0).nonzero()[1][-1]
-    
-    predicted_ans = convert_token_to_ques(preds[:last_non_zero_argument], tokenizer)
-    return predicted_ans
-
-
-# Taken from here: https://huggingface.co/spaces/nielsr/vilt-vqa/blob/main/app.py
-title = "Interactive demo: LaTr (Layout Aware Transformer) for VQA"
-description = "Gradio Demo for LaTr (Layout Aware Transformer),trained on TextVQA Dataset. To use it, simply upload your image and type a question and click 'submit', or click one of the examples to load them. Read more at the links below."
-article = "<p style='text-align: center'><a href='https://arxiv.org/abs/2112.12494' target='_blank'>LaTr: Layout-aware transformer for scene-text VQA,a novel multimodal architecture for Scene Text Visual Question Answering (STVQA)</a> | <a href='https://github.com/uakarsh/latr' target='_blank'>Github Repo</a></p>"
-examples = [['remote.png', "Is remote present in the picture?"]]
-
-interface = gr.Interface(fn=answer_question,
-                         inputs=[image, question],
-                         outputs=answer,
-                         examples=examples,
-                         title=title,
-                         description=description,
-                         article=article,
-                         enable_queue=True)
-interface.launch(debug=True)

spaces/Faridmaruf/rvc-genshin-v2/lib/infer_pack/onnx_inference.py

@@ -1,145 +0,0 @@
-import onnxruntime
-import librosa
-import numpy as np
-import soundfile
-
-
-class ContentVec:
-    def __init__(self, vec_path="pretrained/vec-768-layer-12.onnx", device=None):
-        print("load model(s) from {}".format(vec_path))
-        if device == "cpu" or device is None:
-            providers = ["CPUExecutionProvider"]
-        elif device == "cuda":
-            providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
-        elif device == "dml":
-            providers = ["DmlExecutionProvider"]
-        else:
-            raise RuntimeError("Unsportted Device")
-        self.model = onnxruntime.InferenceSession(vec_path, providers=providers)
-
-    def __call__(self, wav):
-        return self.forward(wav)
-
-    def forward(self, wav):
-        feats = wav
-        if feats.ndim == 2:  # double channels
-            feats = feats.mean(-1)
-        assert feats.ndim == 1, feats.ndim
-        feats = np.expand_dims(np.expand_dims(feats, 0), 0)
-        onnx_input = {self.model.get_inputs()[0].name: feats}
-        logits = self.model.run(None, onnx_input)[0]
-        return logits.transpose(0, 2, 1)
-
-
-def get_f0_predictor(f0_predictor, hop_length, sampling_rate, **kargs):
-    if f0_predictor == "pm":
-        from lib.infer_pack.modules.F0Predictor.PMF0Predictor import PMF0Predictor
-
-        f0_predictor_object = PMF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    elif f0_predictor == "harvest":
-        from lib.infer_pack.modules.F0Predictor.HarvestF0Predictor import (
-            HarvestF0Predictor,
-        )
-
-        f0_predictor_object = HarvestF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    elif f0_predictor == "dio":
-        from lib.infer_pack.modules.F0Predictor.DioF0Predictor import DioF0Predictor
-
-        f0_predictor_object = DioF0Predictor(
-            hop_length=hop_length, sampling_rate=sampling_rate
-        )
-    else:
-        raise Exception("Unknown f0 predictor")
-    return f0_predictor_object
-
-
-class OnnxRVC:
-    def __init__(
-        self,
-        model_path,
-        sr=40000,
-        hop_size=512,
-        vec_path="vec-768-layer-12",
-        device="cpu",
-    ):
-        vec_path = f"pretrained/{vec_path}.onnx"
-        self.vec_model = ContentVec(vec_path, device)
-        if device == "cpu" or device is None:
-            providers = ["CPUExecutionProvider"]
-        elif device == "cuda":
-            providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
-        elif device == "dml":
-            providers = ["DmlExecutionProvider"]
-        else:
-            raise RuntimeError("Unsportted Device")
-        self.model = onnxruntime.InferenceSession(model_path, providers=providers)
-        self.sampling_rate = sr
-        self.hop_size = hop_size
-
-    def forward(self, hubert, hubert_length, pitch, pitchf, ds, rnd):
-        onnx_input = {
-            self.model.get_inputs()[0].name: hubert,
-            self.model.get_inputs()[1].name: hubert_length,
-            self.model.get_inputs()[2].name: pitch,
-            self.model.get_inputs()[3].name: pitchf,
-            self.model.get_inputs()[4].name: ds,
-            self.model.get_inputs()[5].name: rnd,
-        }
-        return (self.model.run(None, onnx_input)[0] * 32767).astype(np.int16)
-
-    def inference(
-        self,
-        raw_path,
-        sid,
-        f0_method="dio",
-        f0_up_key=0,
-        pad_time=0.5,
-        cr_threshold=0.02,
-    ):
-        f0_min = 50
-        f0_max = 1100
-        f0_mel_min = 1127 * np.log(1 + f0_min / 700)
-        f0_mel_max = 1127 * np.log(1 + f0_max / 700)
-        f0_predictor = get_f0_predictor(
-            f0_method,
-            hop_length=self.hop_size,
-            sampling_rate=self.sampling_rate,
-            threshold=cr_threshold,
-        )
-        wav, sr = librosa.load(raw_path, sr=self.sampling_rate)
-        org_length = len(wav)
-        if org_length / sr > 50.0:
-            raise RuntimeError("Reached Max Length")
-
-        wav16k = librosa.resample(wav, orig_sr=self.sampling_rate, target_sr=16000)
-        wav16k = wav16k
-
-        hubert = self.vec_model(wav16k)
-        hubert = np.repeat(hubert, 2, axis=2).transpose(0, 2, 1).astype(np.float32)
-        hubert_length = hubert.shape[1]
-
-        pitchf = f0_predictor.compute_f0(wav, hubert_length)
-        pitchf = pitchf * 2 ** (f0_up_key / 12)
-        pitch = pitchf.copy()
-        f0_mel = 1127 * np.log(1 + pitch / 700)
-        f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
-            f0_mel_max - f0_mel_min
-        ) + 1
-        f0_mel[f0_mel <= 1] = 1
-        f0_mel[f0_mel > 255] = 255
-        pitch = np.rint(f0_mel).astype(np.int64)
-
-        pitchf = pitchf.reshape(1, len(pitchf)).astype(np.float32)
-        pitch = pitch.reshape(1, len(pitch))
-        ds = np.array([sid]).astype(np.int64)
-
-        rnd = np.random.randn(1, 192, hubert_length).astype(np.float32)
-        hubert_length = np.array([hubert_length]).astype(np.int64)
-
-        out_wav = self.forward(hubert, hubert_length, pitch, pitchf, ds, rnd).squeeze()
-        out_wav = np.pad(out_wav, (0, 2 * self.hop_size), "constant")
-        return out_wav[0:org_length]

spaces/Fengbinbin/gpt-academic/docs/waifu_plugin/waifu-tips.js

@@ -1,405 +0,0 @@
-window.live2d_settings = Array(); /*
-
-    く__,.ヘヽ.　　　　/　,ー､ 〉
-    　　　　　＼ ', !-─‐-i　/　/´
-    　　　 　 ／｀ｰ'　　　 L/／｀ヽ､            Live2D 看板娘 参数设置
-    　　 　 /　 ／,　 /|　 ,　 ,　　　 ',                                           Version 1.4.2
-    　　　ｲ 　/ /-‐/　ｉ　L_ ﾊ ヽ!　 i                            Update 2018.11.12
-    　　　 ﾚ ﾍ 7ｲ｀ﾄ　 ﾚ'ｧ-ﾄ､!ハ|　 |  
-    　　　　 !,/7 '0'　　 ´0iソ| 　 |　　　
-    　　　　 |.从"　　_　　 ,,,, / |./ 　 |             网页添加 Live2D 看板娘
-    　　　　 ﾚ'| i＞.､,,__　_,.イ / 　.i 　|                    https://www.fghrsh.net/post/123.html
-    　　　　　 ﾚ'| | / k_７_/ﾚ'ヽ,　ﾊ.　|           
-    　　　　　　 | |/i 〈|/　 i　,.ﾍ |　i　|    Thanks
-    　　　　　　.|/ /　ｉ： 　 ﾍ!　　＼　|          journey-ad / https://github.com/journey-ad/live2d_src
-    　　　 　 　 kヽ>､ﾊ 　 _,.ﾍ､ 　 /､!            xiazeyu / https://github.com/xiazeyu/live2d-widget.js
-    　　　　　　 !'〈//｀Ｔ´', ＼ ｀'7'ｰr'          Live2d Cubism SDK WebGL 2.1 Projrct & All model authors.
-    　　　　　　 ﾚ'ヽL__|___i,___,ンﾚ|ノ
-    　　　　　 　　　ﾄ-,/　|___./
-    　　　　　 　　　'ｰ'　　!_,.:*********************************************************************************/
-
-
-// 后端接口
-live2d_settings['modelAPI']             = '//live2d.fghrsh.net/api/';   // 自建 API 修改这里
-live2d_settings['tipsMessage']          = 'waifu-tips.json';            // 同目录下可省略路径
-live2d_settings['hitokotoAPI']          = 'lwl12.com';                  // 一言 API，可选 'lwl12.com', 'hitokoto.cn', 'jinrishici.com'(古诗词)
-
-// 默认模型
-live2d_settings['modelId']              = 1;            // 默认模型 ID，可在 F12 控制台找到
-live2d_settings['modelTexturesId']      = 53;           // 默认材质 ID，可在 F12 控制台找到
-
-// 工具栏设置
-live2d_settings['showToolMenu']         = true;         // 显示 工具栏          ，可选 true(真), false(假)
-live2d_settings['canCloseLive2d']       = true;         // 显示 关闭看板娘  按钮，可选 true(真), false(假)
-live2d_settings['canSwitchModel']       = true;         // 显示 模型切换    按钮，可选 true(真), false(假)
-live2d_settings['canSwitchTextures']    = true;         // 显示 材质切换    按钮，可选 true(真), false(假)
-live2d_settings['canSwitchHitokoto']    = true;         // 显示 一言切换    按钮，可选 true(真), false(假)
-live2d_settings['canTakeScreenshot']    = true;         // 显示 看板娘截图  按钮，可选 true(真), false(假)
-live2d_settings['canTurnToHomePage']    = true;         // 显示 返回首页    按钮，可选 true(真), false(假)
-live2d_settings['canTurnToAboutPage']   = true;         // 显示 跳转关于页  按钮，可选 true(真), false(假)
-
-// 模型切换模式
-live2d_settings['modelStorage']         = true;         // 记录 ID (刷新后恢复)，可选 true(真), false(假)
-live2d_settings['modelRandMode']        = 'switch';     // 模型切换，可选 'rand'(随机), 'switch'(顺序)
-live2d_settings['modelTexturesRandMode']= 'rand';       // 材质切换，可选 'rand'(随机), 'switch'(顺序)
-
-// 提示消息选项
-live2d_settings['showHitokoto']         = true;         // 显示一言
-live2d_settings['showF12Status']        = true;         // 显示加载状态
-live2d_settings['showF12Message']       = false;        // 显示看板娘消息
-live2d_settings['showF12OpenMsg']       = true;         // 显示控制台打开提示
-live2d_settings['showCopyMessage']      = true;         // 显示 复制内容 提示
-live2d_settings['showWelcomeMessage']   = true;         // 显示进入面页欢迎词
-
-//看板娘样式设置
-live2d_settings['waifuSize']            = '280x250';    // 看板娘大小，例如 '280x250', '600x535'
-live2d_settings['waifuTipsSize']        = '250x70';     // 提示框大小，例如 '250x70', '570x150'
-live2d_settings['waifuFontSize']        = '12px';       // 提示框字体，例如 '12px', '30px'
-live2d_settings['waifuToolFont']        = '14px';       // 工具栏字体，例如 '14px', '36px'
-live2d_settings['waifuToolLine']        = '20px';       // 工具栏行高，例如 '20px', '36px'
-live2d_settings['waifuToolTop']         = '0px'         // 工具栏顶部边距，例如 '0px', '-60px'
-live2d_settings['waifuMinWidth']        = '768px';      // 面页小于 指定宽度 隐藏看板娘，例如 'disable'(禁用), '768px'
-live2d_settings['waifuEdgeSide']        = 'left:0';     // 看板娘贴边方向，例如 'left:0'(靠左 0px), 'right:30'(靠右 30px)
-live2d_settings['waifuDraggable']       = 'disable';    // 拖拽样式，例如 'disable'(禁用), 'axis-x'(只能水平拖拽), 'unlimited'(自由拖拽)
-live2d_settings['waifuDraggableRevert'] = true;         // 松开鼠标还原拖拽位置，可选 true(真), false(假)
-
-// 其他杂项设置
-live2d_settings['l2dVersion']           = '1.4.2';        // 当前版本
-live2d_settings['l2dVerDate']           = '2018.11.12'; // 版本更新日期
-live2d_settings['homePageUrl']          = 'auto';       // 主页地址，可选 'auto'(自动), '{URL 网址}'
-live2d_settings['aboutPageUrl']         = 'https://www.fghrsh.net/post/123.html';   // 关于页地址, '{URL 网址}'
-live2d_settings['screenshotCaptureName']= 'live2d.png'; // 看板娘截图文件名，例如 'live2d.png'
-
-/****************************************************************************************************/
-
-String.prototype.render = function(context) {
-    var tokenReg = /(\\)?\{([^\{\}\\]+)(\\)?\}/g;
-
-    return this.replace(tokenReg, function (word, slash1, token, slash2) {
-        if (slash1 || slash2) { return word.replace('\\', ''); }
-        
-        var variables = token.replace(/\s/g, '').split('.');
-        var currentObject = context;
-        var i, length, variable;
-        
-        for (i = 0, length = variables.length; i < length; ++i) {
-            variable = variables[i];
-            currentObject = currentObject[variable];
-            if (currentObject === undefined || currentObject === null) return '';
-        }
-        return currentObject;
-    });
-};
-
-var re = /x/;
-console.log(re);
-
-function empty(obj) {return typeof obj=="undefined"||obj==null||obj==""?true:false}
-function getRandText(text) {return Array.isArray(text) ? text[Math.floor(Math.random() * text.length + 1)-1] : text}
-
-function showMessage(text, timeout, flag) {
-    if(flag || sessionStorage.getItem('waifu-text') === '' || sessionStorage.getItem('waifu-text') === null){
-        if(Array.isArray(text)) text = text[Math.floor(Math.random() * text.length + 1)-1];
-        if (live2d_settings.showF12Message) console.log('[Message]', text.replace(/<[^<>]+>/g,''));
-        
-        if(flag) sessionStorage.setItem('waifu-text', text);
-        
-        $('.waifu-tips').stop();
-        $('.waifu-tips').html(text).fadeTo(200, 1);
-        if (timeout === undefined) timeout = 5000;
-        hideMessage(timeout);
-    }
-}
-
-function hideMessage(timeout) {
-    $('.waifu-tips').stop().css('opacity',1);
-    if (timeout === undefined) timeout = 5000;
-    window.setTimeout(function() {sessionStorage.removeItem('waifu-text')}, timeout);
-    $('.waifu-tips').delay(timeout).fadeTo(200, 0);
-}
-
-function initModel(waifuPath, type) {
-    /* console welcome message */
-    eval(function(p,a,c,k,e,r){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--)r[e(c)]=k[c]||e(c);k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}('8.d(" ");8.d("\\U,.\\y\\5.\\1\\1\\1\\1/\\1,\\u\\2 \\H\\n\\1\\1\\1\\1\\1\\b \', !-\\r\\j-i\\1/\\1/\\g\\n\\1\\1\\1 \\1 \\a\\4\\f\'\\1\\1\\1 L/\\a\\4\\5\\2\\n\\1\\1 \\1 /\\1 \\a,\\1 /|\\1 ,\\1 ,\\1\\1\\1 \',\\n\\1\\1\\1\\q \\1/ /-\\j/\\1\\h\\E \\9 \\5!\\1 i\\n\\1\\1\\1 \\3 \\6 7\\q\\4\\c\\1 \\3\'\\s-\\c\\2!\\t|\\1 |\\n\\1\\1\\1\\1 !,/7 \'0\'\\1\\1 \\X\\w| \\1 |\\1\\1\\1\\n\\1\\1\\1\\1 |.\\x\\"\\1\\l\\1\\1 ,,,, / |./ \\1 |\\n\\1\\1\\1\\1 \\3\'| i\\z.\\2,,A\\l,.\\B / \\1.i \\1|\\n\\1\\1\\1\\1\\1 \\3\'| | / C\\D/\\3\'\\5,\\1\\9.\\1|\\n\\1\\1\\1\\1\\1\\1 | |/i \\m|/\\1 i\\1,.\\6 |\\F\\1|\\n\\1\\1\\1\\1\\1\\1.|/ /\\1\\h\\G \\1 \\6!\\1\\1\\b\\1|\\n\\1\\1\\1 \\1 \\1 k\\5>\\2\\9 \\1 o,.\\6\\2 \\1 /\\2!\\n\\1\\1\\1\\1\\1\\1 !\'\\m//\\4\\I\\g\', \\b \\4\'7\'\\J\'\\n\\1\\1\\1\\1\\1\\1 \\3\'\\K|M,p,\\O\\3|\\P\\n\\1\\1\\1\\1\\1 \\1\\1\\1\\c-,/\\1|p./\\n\\1\\1\\1\\1\\1 \\1\\1\\1\'\\f\'\\1\\1!o,.:\\Q \\R\\S\\T v"+e.V+" / W "+e.N);8.d(" ");',60,60,'|u3000|uff64|uff9a|uff40|u30fd|uff8d||console|uff8a|uff0f|uff3c|uff84|log|live2d_settings|uff70|u00b4|uff49||u2010||u3000_|u3008||_|___|uff72|u2500|uff67|u30cf|u30fc||u30bd|u4ece|u30d8|uff1e|__|u30a4|k_|uff17_|u3000L_|u3000i|uff1a|u3009|uff34|uff70r|u30fdL__||___i|l2dVerDate|u30f3|u30ce|nLive2D|u770b|u677f|u5a18|u304f__|l2dVersion|FGHRSH|u00b40i'.split('|'),0,{}));
-    
-    /* 判断 JQuery */
-    if (typeof($.ajax) != 'function') typeof(jQuery.ajax) == 'function' ? window.$ = jQuery : console.log('[Error] JQuery is not defined.');
-    
-    /* 加载看板娘样式 */
-    live2d_settings.waifuSize = live2d_settings.waifuSize.split('x');
-    live2d_settings.waifuTipsSize = live2d_settings.waifuTipsSize.split('x');
-    live2d_settings.waifuEdgeSide = live2d_settings.waifuEdgeSide.split(':');
-    
-    $("#live2d").attr("width",live2d_settings.waifuSize[0]);
-    $("#live2d").attr("height",live2d_settings.waifuSize[1]);
-    $(".waifu-tips").width(live2d_settings.waifuTipsSize[0]);
-    $(".waifu-tips").height(live2d_settings.waifuTipsSize[1]);
-    $(".waifu-tips").css("top",live2d_settings.waifuToolTop);
-    $(".waifu-tips").css("font-size",live2d_settings.waifuFontSize);
-    $(".waifu-tool").css("font-size",live2d_settings.waifuToolFont);
-    $(".waifu-tool span").css("line-height",live2d_settings.waifuToolLine);
-    
-    if (live2d_settings.waifuEdgeSide[0] == 'left') $(".waifu").css("left",live2d_settings.waifuEdgeSide[1]+'px');
-    else if (live2d_settings.waifuEdgeSide[0] == 'right') $(".waifu").css("right",live2d_settings.waifuEdgeSide[1]+'px');
-    
-    window.waifuResize = function() { $(window).width() <= Number(live2d_settings.waifuMinWidth.replace('px','')) ? $(".waifu").hide() : $(".waifu").show(); };
-    if (live2d_settings.waifuMinWidth != 'disable') { waifuResize(); $(window).resize(function() {waifuResize()}); }
-    
-    try {
-        if (live2d_settings.waifuDraggable == 'axis-x') $(".waifu").draggable({ axis: "x", revert: live2d_settings.waifuDraggableRevert });
-        else if (live2d_settings.waifuDraggable == 'unlimited') $(".waifu").draggable({ revert: live2d_settings.waifuDraggableRevert });
-        else $(".waifu").css("transition", 'all .3s ease-in-out');
-    } catch(err) { console.log('[Error] JQuery UI is not defined.') }
-    
-    live2d_settings.homePageUrl = live2d_settings.homePageUrl == 'auto' ? window.location.protocol+'//'+window.location.hostname+'/' : live2d_settings.homePageUrl;
-    if (window.location.protocol == 'file:' && live2d_settings.modelAPI.substr(0,2) == '//') live2d_settings.modelAPI = 'http:'+live2d_settings.modelAPI;
-    
-    $('.waifu-tool .fui-home').click(function (){
-        //window.location = 'https://www.fghrsh.net/';
-        window.location = live2d_settings.homePageUrl;
-    });
-    
-    $('.waifu-tool .fui-info-circle').click(function (){
-        //window.open('https://imjad.cn/archives/lab/add-dynamic-poster-girl-with-live2d-to-your-blog-02');
-        window.open(live2d_settings.aboutPageUrl);
-    });
-    
-    if (typeof(waifuPath) == "object") loadTipsMessage(waifuPath); else {
-        $.ajax({
-            cache: true,
-            url: waifuPath == '' ? live2d_settings.tipsMessage : (waifuPath.substr(waifuPath.length-15)=='waifu-tips.json'?waifuPath:waifuPath+'waifu-tips.json'),
-            dataType: "json",
-            success: function (result){ loadTipsMessage(result); }
-        });
-    }
-    
-    if (!live2d_settings.showToolMenu) $('.waifu-tool').hide();
-    if (!live2d_settings.canCloseLive2d) $('.waifu-tool .fui-cross').hide();
-    if (!live2d_settings.canSwitchModel) $('.waifu-tool .fui-eye').hide();
-    if (!live2d_settings.canSwitchTextures) $('.waifu-tool .fui-user').hide();
-    if (!live2d_settings.canSwitchHitokoto) $('.waifu-tool .fui-chat').hide();
-    if (!live2d_settings.canTakeScreenshot) $('.waifu-tool .fui-photo').hide();
-    if (!live2d_settings.canTurnToHomePage) $('.waifu-tool .fui-home').hide();
-    if (!live2d_settings.canTurnToAboutPage) $('.waifu-tool .fui-info-circle').hide();
-
-    if (waifuPath === undefined) waifuPath = '';
-    var modelId = localStorage.getItem('modelId');
-    var modelTexturesId = localStorage.getItem('modelTexturesId');
-    
-    if (!live2d_settings.modelStorage || modelId == null) {
-        var modelId = live2d_settings.modelId;
-        var modelTexturesId = live2d_settings.modelTexturesId;
-    } loadModel(modelId, modelTexturesId);
-}
-
-function loadModel(modelId, modelTexturesId=0) {
-    if (live2d_settings.modelStorage) {
-        localStorage.setItem('modelId', modelId);
-        localStorage.setItem('modelTexturesId', modelTexturesId);
-    } else {
-        sessionStorage.setItem('modelId', modelId);
-        sessionStorage.setItem('modelTexturesId', modelTexturesId);
-    } loadlive2d('live2d', live2d_settings.modelAPI+'get/?id='+modelId+'-'+modelTexturesId, (live2d_settings.showF12Status ? console.log('[Status]','live2d','模型',modelId+'-'+modelTexturesId,'加载完成'):null));
-}
-
-function loadTipsMessage(result) {
-    window.waifu_tips = result;
-    
-    $.each(result.mouseover, function (index, tips){
-        $(document).on("mouseover", tips.selector, function (){
-            var text = getRandText(tips.text);
-            text = text.render({text: $(this).text()});
-            showMessage(text, 3000);
-        });
-    });
-    $.each(result.click, function (index, tips){
-        $(document).on("click", tips.selector, function (){
-            var text = getRandText(tips.text);
-            text = text.render({text: $(this).text()});
-            showMessage(text, 3000, true);
-        });
-    });
-    $.each(result.seasons, function (index, tips){
-        var now = new Date();
-        var after = tips.date.split('-')[0];
-        var before = tips.date.split('-')[1] || after;
-        
-        if((after.split('/')[0] <= now.getMonth()+1 && now.getMonth()+1 <= before.split('/')[0]) && 
-           (after.split('/')[1] <= now.getDate() && now.getDate() <= before.split('/')[1])){
-            var text = getRandText(tips.text);
-            text = text.render({year: now.getFullYear()});
-            showMessage(text, 6000, true);
-        }
-    });
-    
-    if (live2d_settings.showF12OpenMsg) {
-        re.toString = function() {
-            showMessage(getRandText(result.waifu.console_open_msg), 5000, true);
-            return '';
-        };
-    }
-    
-    if (live2d_settings.showCopyMessage) {
-        $(document).on('copy', function() {
-            showMessage(getRandText(result.waifu.copy_message), 5000, true);
-        });
-    }
-    
-    $('.waifu-tool .fui-photo').click(function(){
-        showMessage(getRandText(result.waifu.screenshot_message), 5000, true);
-        window.Live2D.captureName = live2d_settings.screenshotCaptureName;
-        window.Live2D.captureFrame = true;
-    });
-    
-    $('.waifu-tool .fui-cross').click(function(){
-        sessionStorage.setItem('waifu-dsiplay', 'none');
-        showMessage(getRandText(result.waifu.hidden_message), 1300, true);
-        window.setTimeout(function() {$('.waifu').hide();}, 1300);
-    });
-    
-    window.showWelcomeMessage = function(result) {
-        var text;
-        if (window.location.href == live2d_settings.homePageUrl) {
-            var now = (new Date()).getHours();
-            if (now > 23 || now <= 5) text = getRandText(result.waifu.hour_tips['t23-5']);
-            else if (now > 5 && now <= 7) text = getRandText(result.waifu.hour_tips['t5-7']);
-            else if (now > 7 && now <= 11) text = getRandText(result.waifu.hour_tips['t7-11']);
-            else if (now > 11 && now <= 14) text = getRandText(result.waifu.hour_tips['t11-14']);
-            else if (now > 14 && now <= 17) text = getRandText(result.waifu.hour_tips['t14-17']);
-            else if (now > 17 && now <= 19) text = getRandText(result.waifu.hour_tips['t17-19']);
-            else if (now > 19 && now <= 21) text = getRandText(result.waifu.hour_tips['t19-21']);
-            else if (now > 21 && now <= 23) text = getRandText(result.waifu.hour_tips['t21-23']);
-            else text = getRandText(result.waifu.hour_tips.default);
-        } else {
-            var referrer_message = result.waifu.referrer_message;
-            if (document.referrer !== '') {
-                var referrer = document.createElement('a');
-                referrer.href = document.referrer;
-                var domain = referrer.hostname.split('.')[1];
-                if (window.location.hostname == referrer.hostname)
-                    text = referrer_message.localhost[0] + document.title.split(referrer_message.localhost[2])[0] + referrer_message.localhost[1];
-                else if (domain == 'baidu')
-                    text = referrer_message.baidu[0] + referrer.search.split('&wd=')[1].split('&')[0] + referrer_message.baidu[1];
-                else if (domain == 'so')
-                    text = referrer_message.so[0] + referrer.search.split('&q=')[1].split('&')[0] + referrer_message.so[1];
-                else if (domain == 'google')
-                    text = referrer_message.google[0] + document.title.split(referrer_message.google[2])[0] + referrer_message.google[1];
-                else {
-                    $.each(result.waifu.referrer_hostname, function(i,val) {if (i==referrer.hostname) referrer.hostname = getRandText(val)});
-                    text = referrer_message.default[0] + referrer.hostname + referrer_message.default[1];
-                }
-            } else text = referrer_message.none[0] + document.title.split(referrer_message.none[2])[0] + referrer_message.none[1];
-        }
-        showMessage(text, 6000);
-    }; if (live2d_settings.showWelcomeMessage) showWelcomeMessage(result);
-    
-    var waifu_tips = result.waifu;
-    
-    function loadOtherModel() {
-        var modelId = modelStorageGetItem('modelId');
-        var modelRandMode = live2d_settings.modelRandMode;
-        
-        $.ajax({
-            cache: modelRandMode == 'switch' ? true : false,
-            url: live2d_settings.modelAPI+modelRandMode+'/?id='+modelId,
-            dataType: "json",
-            success: function(result) {
-                loadModel(result.model['id']);
-                var message = result.model['message'];
-                $.each(waifu_tips.model_message, function(i,val) {if (i==result.model['id']) message = getRandText(val)});
-                showMessage(message, 3000, true);
-            }
-        });
-    }
-    
-    function loadRandTextures() {
-        var modelId = modelStorageGetItem('modelId');
-        var modelTexturesId = modelStorageGetItem('modelTexturesId');
-        var modelTexturesRandMode = live2d_settings.modelTexturesRandMode;
-        
-        $.ajax({
-            cache: modelTexturesRandMode == 'switch' ? true : false,
-            url: live2d_settings.modelAPI+modelTexturesRandMode+'_textures/?id='+modelId+'-'+modelTexturesId,
-            dataType: "json",
-            success: function(result) {
-                if (result.textures['id'] == 1 && (modelTexturesId == 1 || modelTexturesId == 0))
-                    showMessage(waifu_tips.load_rand_textures[0], 3000, true);
-                else showMessage(waifu_tips.load_rand_textures[1], 3000, true);
-                loadModel(modelId, result.textures['id']);
-            }
-        });
-    }
-    
-    function modelStorageGetItem(key) { return live2d_settings.modelStorage ? localStorage.getItem(key) : sessionStorage.getItem(key); }
-    
-    /* 检测用户活动状态，并在空闲时显示一言 */
-    if (live2d_settings.showHitokoto) {
-        window.getActed = false; window.hitokotoTimer = 0; window.hitokotoInterval = false;
-        $(document).mousemove(function(e){getActed = true;}).keydown(function(){getActed = true;});
-        setInterval(function(){ if (!getActed) ifActed(); else elseActed(); }, 1000);
-    }
-    
-    function ifActed() {
-        if (!hitokotoInterval) {
-            hitokotoInterval = true;
-            hitokotoTimer = window.setInterval(showHitokotoActed, 30000);
-        }
-    }
-    
-    function elseActed() {
-        getActed = hitokotoInterval = false;
-        window.clearInterval(hitokotoTimer);
-    }
-    
-    function showHitokotoActed() {
-        if ($(document)[0].visibilityState == 'visible') showHitokoto();
-    }
-    
-    function showHitokoto() {
-    	switch(live2d_settings.hitokotoAPI) {
-    	    case 'lwl12.com':
-    	        $.getJSON('https://api.lwl12.com/hitokoto/v1?encode=realjson',function(result){
-        	        if (!empty(result.source)) {
-                        var text = waifu_tips.hitokoto_api_message['lwl12.com'][0];
-                        if (!empty(result.author)) text += waifu_tips.hitokoto_api_message['lwl12.com'][1];
-                        text = text.render({source: result.source, creator: result.author});
-                        window.setTimeout(function() {showMessage(text+waifu_tips.hitokoto_api_message['lwl12.com'][2], 3000, true);}, 5000);
-                    } showMessage(result.text, 5000, true);
-                });break;
-    	    case 'fghrsh.net':
-    	        $.getJSON('https://api.fghrsh.net/hitokoto/rand/?encode=jsc&uid=3335',function(result){
-            	    if (!empty(result.source)) {
-                        var text = waifu_tips.hitokoto_api_message['fghrsh.net'][0];
-                        text = text.render({source: result.source, date: result.date});
-                        window.setTimeout(function() {showMessage(text, 3000, true);}, 5000);
-                        showMessage(result.hitokoto, 5000, true);
-            	    }
-                });break;
-            case 'jinrishici.com':
-                $.ajax({
-                    url: 'https://v2.jinrishici.com/one.json',
-                    xhrFields: {withCredentials: true},
-                    success: function (result, status) {
-                        if (!empty(result.data.origin.title)) {
-                            var text = waifu_tips.hitokoto_api_message['jinrishici.com'][0];
-                            text = text.render({title: result.data.origin.title, dynasty: result.data.origin.dynasty, author:result.data.origin.author});
-                            window.setTimeout(function() {showMessage(text, 3000, true);}, 5000);
-                        } showMessage(result.data.content, 5000, true);
-                    }
-                });break;
-    	    default:
-    	        $.getJSON('https://v1.hitokoto.cn',function(result){
-            	    if (!empty(result.from)) {
-                        var text = waifu_tips.hitokoto_api_message['hitokoto.cn'][0];
-                        text = text.render({source: result.from, creator: result.creator});
-                        window.setTimeout(function() {showMessage(text, 3000, true);}, 5000);
-            	    }
-                    showMessage(result.hitokoto, 5000, true);
-                });
-    	}
-    }
-    
-    $('.waifu-tool .fui-eye').click(function (){loadOtherModel()});
-    $('.waifu-tool .fui-user').click(function (){loadRandTextures()});
-    $('.waifu-tool .fui-chat').click(function (){showHitokoto()});
-}

spaces/Flux9665/IMS-Toucan/Preprocessing/AudioPreprocessor.py

@@ -1,166 +0,0 @@
-import librosa
-import librosa.core as lb
-import librosa.display as lbd
-import matplotlib.pyplot as plt
-import numpy
-import numpy as np
-import pyloudnorm as pyln
-import torch
-from torchaudio.transforms import Resample
-
-
-class AudioPreprocessor:
-
-    def __init__(self, input_sr, output_sr=None, melspec_buckets=80, hop_length=256, n_fft=1024, cut_silence=False, device="cpu"):
-        """
-        The parameters are by default set up to do well
-        on a 16kHz signal. A different sampling rate may
-        require different hop_length and n_fft (e.g.
-        doubling frequency --> doubling hop_length and
-        doubling n_fft)
-        """
-        self.cut_silence = cut_silence
-        self.device = device
-        self.sr = input_sr
-        self.new_sr = output_sr
-        self.hop_length = hop_length
-        self.n_fft = n_fft
-        self.mel_buckets = melspec_buckets
-        self.meter = pyln.Meter(input_sr)
-        self.final_sr = input_sr
-        if cut_silence:
-            torch.hub._validate_not_a_forked_repo = lambda a, b, c: True  # torch 1.9 has a bug in the hub loading, this is a workaround
-            # careful: assumes 16kHz or 8kHz audio
-            self.silero_model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad',
-                                                      model='silero_vad',
-                                                      force_reload=False,
-                                                      onnx=False,
-                                                      verbose=False)
-            (self.get_speech_timestamps,
-             self.save_audio,
-             self.read_audio,
-             self.VADIterator,
-             self.collect_chunks) = utils
-            self.silero_model = self.silero_model.to(self.device)
-        if output_sr is not None and output_sr != input_sr:
-            self.resample = Resample(orig_freq=input_sr, new_freq=output_sr).to(self.device)
-            self.final_sr = output_sr
-        else:
-            self.resample = lambda x: x
-
-    def cut_silence_from_audio(self, audio):
-        """
-        https://github.com/snakers4/silero-vad
-        """
-        return self.collect_chunks(self.get_speech_timestamps(audio, self.silero_model, sampling_rate=self.final_sr), audio)
-
-    def to_mono(self, x):
-        """
-        make sure we deal with a 1D array
-        """
-        if len(x.shape) == 2:
-            return lb.to_mono(numpy.transpose(x))
-        else:
-            return x
-
-    def normalize_loudness(self, audio):
-        """
-        normalize the amplitudes according to
-        their decibels, so this should turn any
-        signal with different magnitudes into
-        the same magnitude by analysing loudness
-        """
-        loudness = self.meter.integrated_loudness(audio)
-        loud_normed = pyln.normalize.loudness(audio, loudness, -30.0)
-        peak = numpy.amax(numpy.abs(loud_normed))
-        peak_normed = numpy.divide(loud_normed, peak)
-        return peak_normed
-
-    def logmelfilterbank(self, audio, sampling_rate, fmin=40, fmax=8000, eps=1e-10):
-        """
-        Compute log-Mel filterbank
-
-        one day this could be replaced by torchaudio's internal log10(melspec(audio)), but
-        for some reason it gives slightly different results, so in order not to break backwards
-        compatibility, this is kept for now. If there is ever a reason to completely re-train
-        all models, this would be a good opportunity to make the switch.
-        """
-        if isinstance(audio, torch.Tensor):
-            audio = audio.numpy()
-        # get amplitude spectrogram
-        x_stft = librosa.stft(audio, n_fft=self.n_fft, hop_length=self.hop_length, win_length=None, window="hann", pad_mode="reflect")
-        spc = np.abs(x_stft).T
-        # get mel basis
-        fmin = 0 if fmin is None else fmin
-        fmax = sampling_rate / 2 if fmax is None else fmax
-        mel_basis = librosa.filters.mel(sampling_rate, self.n_fft, self.mel_buckets, fmin, fmax)
-        # apply log and return
-        return torch.Tensor(np.log10(np.maximum(eps, np.dot(spc, mel_basis.T)))).transpose(0, 1)
-
-    def normalize_audio(self, audio):
-        """
-        one function to apply them all in an
-        order that makes sense.
-        """
-        audio = self.to_mono(audio)
-        audio = self.normalize_loudness(audio)
-        audio = torch.Tensor(audio).to(self.device)
-        audio = self.resample(audio)
-        if self.cut_silence:
-            audio = self.cut_silence_from_audio(audio)
-        return audio.to("cpu")
-
-    def visualize_cleaning(self, unclean_audio):
-        """
-        displays Mel Spectrogram of unclean audio
-        and then displays Mel Spectrogram of the
-        cleaned version.
-        """
-        fig, ax = plt.subplots(nrows=2, ncols=1)
-        unclean_audio_mono = self.to_mono(unclean_audio)
-        unclean_spec = self.audio_to_mel_spec_tensor(unclean_audio_mono, normalize=False).numpy()
-        clean_spec = self.audio_to_mel_spec_tensor(unclean_audio_mono, normalize=True).numpy()
-        lbd.specshow(unclean_spec, sr=self.sr, cmap='GnBu', y_axis='mel', ax=ax[0], x_axis='time')
-        ax[0].set(title='Uncleaned Audio')
-        ax[0].label_outer()
-        if self.new_sr is not None:
-            lbd.specshow(clean_spec, sr=self.new_sr, cmap='GnBu', y_axis='mel', ax=ax[1], x_axis='time')
-        else:
-            lbd.specshow(clean_spec, sr=self.sr, cmap='GnBu', y_axis='mel', ax=ax[1], x_axis='time')
-        ax[1].set(title='Cleaned Audio')
-        ax[1].label_outer()
-        plt.show()
-
-    def audio_to_wave_tensor(self, audio, normalize=True):
-        if normalize:
-            return self.normalize_audio(audio)
-        else:
-            if isinstance(audio, torch.Tensor):
-                return audio
-            else:
-                return torch.Tensor(audio)
-
-    def audio_to_mel_spec_tensor(self, audio, normalize=True, explicit_sampling_rate=None):
-        """
-        explicit_sampling_rate is for when
-        normalization has already been applied
-        and that included resampling. No way
-        to detect the current sr of the incoming
-        audio
-        """
-        if explicit_sampling_rate is None:
-            if normalize:
-                audio = self.normalize_audio(audio)
-                return self.logmelfilterbank(audio=audio, sampling_rate=self.final_sr)
-            return self.logmelfilterbank(audio=audio, sampling_rate=self.sr)
-        if normalize:
-            audio = self.normalize_audio(audio)
-        return self.logmelfilterbank(audio=audio, sampling_rate=explicit_sampling_rate)
-
-
-if __name__ == '__main__':
-    import soundfile
-
-    wav, sr = soundfile.read("../audios/test.wav")
-    ap = AudioPreprocessor(input_sr=sr, output_sr=16000)
-    ap.visualize_cleaning(wav)