Update parquet files (step 93 of 397)

spaces/101-5/gpt4free/g4f/.v1/gpt4free/__init__.py

@@ -1,103 +0,0 @@
-from enum import Enum
-
-from gpt4free import forefront
-from gpt4free import quora
-from gpt4free import theb
-from gpt4free import usesless
-from gpt4free import you
-from gpt4free import aicolors
-from gpt4free import deepai
-
-
-class Provider(Enum):
-    """An enum representing  different providers."""
-
-    You = "you"
-    Poe = "poe"
-    ForeFront = "fore_front"
-    Theb = "theb"
-    UseLess = "useless"
-    AiColors = "ai_colors"
-    DeepAI = "deepai"
-
-
-class Completion:
-    """This class will be used for invoking the given provider"""
-
-    @staticmethod
-    def create(provider: Provider, prompt: str, **kwargs) -> str:
-        """
-        Invokes the given provider with given prompt and addition arguments and returns the string response
-
-        :param provider: an enum representing the provider to use while invoking
-        :param prompt: input provided by the user
-        :param kwargs:  Additional keyword arguments to pass to the provider while invoking
-        :return: A string representing the response from the provider
-        """
-        if provider == Provider.Poe:
-            return Completion.__poe_service(prompt, **kwargs)
-        elif provider == Provider.You:
-            return Completion.__you_service(prompt, **kwargs)
-        elif provider == Provider.ForeFront:
-            return Completion.__fore_front_service(prompt, **kwargs)
-        elif provider == Provider.Theb:
-            return Completion.__theb_service(prompt, **kwargs)
-        elif provider == Provider.UseLess:
-            return Completion.__useless_service(prompt, **kwargs)
-        elif provider == Provider.AiColors:
-            return Completion.__ai_colors_service(prompt, **kwargs)
-        elif provider == Provider.DeepAI:
-            return Completion.__deepai_service(prompt, **kwargs)
-        else:
-            raise Exception("Provider not exist, Please try again")
-
-    @staticmethod
-    def __ai_colors_service(prompt: str):
-        return aicolors.Completion.create(prompt=prompt)
-
-    @staticmethod
-    def __useless_service(prompt: str, **kwargs) -> str:
-        return usesless.Completion.create(prompt=prompt, **kwargs)
-
-    @staticmethod
-    def __you_service(prompt: str, **kwargs) -> str:
-        return you.Completion.create(prompt, **kwargs).text
-
-    @staticmethod
-    def __poe_service(prompt: str, **kwargs) -> str:
-        return quora.Completion.create(prompt=prompt, **kwargs).text
-
-    @staticmethod
-    def __fore_front_service(prompt: str, **kwargs) -> str:
-        return forefront.Completion.create(prompt=prompt, **kwargs).text
-
-    @staticmethod
-    def __theb_service(prompt: str, **kwargs):
-        return "".join(theb.Completion.create(prompt=prompt))
-
-    @staticmethod
-    def __deepai_service(prompt: str, **kwargs):
-        return "".join(deepai.Completion.create(prompt=prompt))
-
-
-class ChatCompletion:
-    """This class is used to execute a chat completion for a specified provider"""
-
-    @staticmethod
-    def create(provider: Provider, messages: list, **kwargs) -> str:
-        """
-        Invokes the given provider with given chat messages and addition arguments and returns the string response
-
-        :param provider: an enum representing the provider to use while invoking
-        :param messages: a list of chat messages, see the OpenAI docs for how to format this (https://platform.openai.com/docs/guides/chat/introduction)
-        :param kwargs:  Additional keyword arguments to pass to the provider while invoking
-        :return: A string representing the response from the provider
-        """
-        if provider == Provider.DeepAI:
-            return ChatCompletion.__deepai_service(messages, **kwargs)
-        else:
-            raise Exception("Provider not exist, Please try again")
-
-    @staticmethod
-    def __deepai_service(messages: list, **kwargs):
-        return "".join(deepai.ChatCompletion.create(messages=messages))

spaces/1368565466ki/Satdia/attentions.py

@@ -1,300 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-from modules import LayerNorm
-   
-
-class Encoder(nn.Module):
-  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **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
-
-    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):
-    attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-    x = x * x_mask
-    for i in range(self.n_layers):
-      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., 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., 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):
-    max_relative_position = 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()
-    # padd 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., 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/1368565466ki/ZSTRD/monotonic_align/__init__.py

@@ -1,20 +0,0 @@
-from numpy import zeros, int32, float32
-from torch import from_numpy
-
-from .core import maximum_path_jit
-
-
-def maximum_path(neg_cent, mask):
-    """ numba optimized version.
-    neg_cent: [b, t_t, t_s]
-    mask: [b, t_t, t_s]
-    """
-    device = neg_cent.device
-    dtype = neg_cent.dtype
-    neg_cent = neg_cent.data.cpu().numpy().astype(float32)
-    path = zeros(neg_cent.shape, dtype=int32)
-
-    t_t_max = mask.sum(1)[:, 0].data.cpu().numpy().astype(int32)
-    t_s_max = mask.sum(2)[:, 0].data.cpu().numpy().astype(int32)
-    maximum_path_jit(path, neg_cent, t_t_max, t_s_max)
-    return from_numpy(path).to(device=device, dtype=dtype)

spaces/17TheWord/RealESRGAN/app.py

@@ -1,68 +0,0 @@
-import os
-os.system("pip install gradio==2.9b23")
-import random
-import gradio as gr
-from PIL import Image
-import torch
-from random import randint
-import sys
-from subprocess import call
-import psutil
-
-
-
-
-torch.hub.download_url_to_file('http://people.csail.mit.edu/billf/project%20pages/sresCode/Markov%20Random%20Fields%20for%20Super-Resolution_files/100075_lowres.jpg', 'bear.jpg')
-  
-    
-def run_cmd(command):
-    try:
-        print(command)
-        call(command, shell=True)
-    except KeyboardInterrupt:
-        print("Process interrupted")
-        sys.exit(1)
-run_cmd("wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth -P .")
-run_cmd("pip install basicsr")
-run_cmd("pip freeze")
-
-os.system("wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth -P .")
-
-
-def inference(img,mode):
-    _id = randint(1, 10000)
-    INPUT_DIR = "/tmp/input_image" + str(_id) + "/"
-    OUTPUT_DIR = "/tmp/output_image" + str(_id) + "/"
-    run_cmd("rm -rf " + INPUT_DIR)
-    run_cmd("rm -rf " + OUTPUT_DIR)
-    run_cmd("mkdir " + INPUT_DIR)
-    run_cmd("mkdir " + OUTPUT_DIR)
-    basewidth = 256
-    wpercent = (basewidth/float(img.size[0]))
-    hsize = int((float(img.size[1])*float(wpercent)))
-    img = img.resize((basewidth,hsize), Image.ANTIALIAS)
-    img.save(INPUT_DIR + "1.jpg", "JPEG")
-    if mode == "base":
-        run_cmd("python inference_realesrgan.py -n RealESRGAN_x4plus -i "+ INPUT_DIR + " -o " + OUTPUT_DIR)
-    else:
-        os.system("python inference_realesrgan.py -n RealESRGAN_x4plus_anime_6B -i "+ INPUT_DIR + " -o " + OUTPUT_DIR)
-    return os.path.join(OUTPUT_DIR, "1_out.jpg")
-
-
-
-        
-title = "Real-ESRGAN"
-description = "Gradio demo for Real-ESRGAN. To use it, simply upload your image, or click one of the examples to load them. Read more at the links below. Please click submit only once"
-article = "<p style='text-align: center'><a href='https://arxiv.org/abs/2107.10833'>Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data</a> | <a href='https://github.com/xinntao/Real-ESRGAN'>Github Repo</a></p>"
-
-gr.Interface(
-    inference, 
-    [gr.inputs.Image(type="pil", label="Input"),gr.inputs.Radio(["base","anime"], type="value", default="base", label="model type")], 
-    gr.outputs.Image(type="file", label="Output"),
-    title=title,
-    description=description,
-    article=article,
-    examples=[
-    ['bear.jpg','base'],
-    ['anime.png','anime']
-    ]).launch()

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Cedar Noise Reduction Plugin.md

@@ -1,7 +0,0 @@
-<br />
-<br> - Overview of Cedar noise reduction plugin: describe its features, benefits, and applications | | H2: How to Use Cedar Noise Reduction Plugin for Audio Restoration | - Step 1: Choose the right plugin for your needs: compare different Cedar products and their capabilities <br> - Step 2: Load the plugin in your DAW or audio editor: show how to install and activate the plugin <br> - Step 3: Adjust the settings and parameters: explain how to use the learn function, the noise attenuation knob, and other controls <br> - Step 4: Preview and apply the noise reduction: demonstrate the results and tips for fine-tuning | | H2: How to Use Cedar Noise Reduction Plugin for Live Sound | - Step 1: Connect the plugin to your audio interface or mixer: show how to use the analog, digital, or Dante inputs and outputs <br> - Step 2: Set up the plugin for live mode: explain how to use the adaptive mode, the freeze function, and other features <br> - Step 3: Monitor and control the noise reduction: show how to use the meters, indicators, and bypass switch <br> - Step 4: Enjoy a cleaner, brighter, and louder sound: demonstrate the benefits and advantages of using the plugin for live sound | | H2: How to Use Cedar Noise Reduction Plugin for Post Production | - Step 1: Import your audio file or project into the standalone RX Audio Editor: show how to use the file browser, the waveform display, and the spectral view <br> - Step 2: Select the noise reduction module from the RX menu: explain how to choose between DNS 2, DNS 4, or DNS 8D modules <br> - Step 3: Edit your audio with advanced tools and features: show how to use the spectral repair, dialogue isolate, de-reverb, de-click, de-hum, and other tools <br> - Step 4: Export your audio file or project with improved quality: demonstrate how to use the batch processor, the metadata editor, and the format options | | H2: How to Compare Cedar Noise Reduction Plugin with Other Software | - Criteria for comparison: list some factors to consider when comparing noise reduction software, such as performance, quality, ease of use, price, support, etc. <br> - Examples of other software: mention some popular alternatives to Cedar noise reduction plugin, such as iZotope RX 8, Accusonus ERA, SoundSoap 5, etc. <br> - Pros and cons of each software: highlight the strengths and weaknesses of each software based on the criteria <br> - Conclusion: summarize which software is best suited for different scenarios and preferences | | H2: How to Get Cedar Noise Reduction Plugin and Learn More About It | - Pricing and availability: provide information on how to purchase or rent Cedar noise reduction plugin, as well as its system requirements and compatibility <br> - Resources and support: provide links to Cedar's official website, user manual, video tutorials, FAQs, customer service, etc. <br> - Testimonials and reviews: provide some quotes from satisfied customers or reputable sources that praise Cedar noise reduction plugin | | H2: Conclusion | - Recap the main points of the article: summarize what is Cedar noise reduction plugin, how to use it for different purposes, how to compare it with other software, and how to get it and learn more about it <br> - Call to action: encourage readers to try out Cedar noise reduction plugin for themselves or contact Cedar for more information | Article with HTML formatting <h1>What is Cedar Noise Reduction Plugin and Why You Need It</h1>
- <p>If you are involved in any kind of audio production, whether it is recording, mixing, mastering, broadcasting, live sound, or post production, you know how important it is to have a clean and clear sound. However, you also know how challenging it can be to achieve that sound in real-world situations, where you have to deal with various types of noise that can ruin your audio quality.</p>
- <p>Noise can be defined as any unwanted sound that interferes with your desired sound. It can come from different sources, such as background noises (traffic, air conditioning, wind, rain), equipment noises (hiss, hum, clicks), or recording errors (clipping, distortion, dropouts). Noise can affect your audio in different ways, such as reducing</p>
-<h2>cedar noise reduction plugin</h2><br /><p><b><b>DOWNLOAD</b> &raquo;&raquo;&raquo; <a href="https://byltly.com/2uKA3d">https://byltly.com/2uKA3d</a></b></p><br /><br /> b2dd77e56b<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download and Install Microsoft Office 2013 in Minutes with This Simple Trick.md

@@ -1,40 +0,0 @@
-
-<h1>How to Install Microsoft Office 2013 Setup with Free Download</h1>
-<p>Microsoft Office 2013 is a popular suite of productivity applications that includes Word, Excel, PowerPoint, Outlook, OneNote, Access, and Publisher. If you want to install Microsoft Office 2013 setup with free download, you can follow these simple steps:</p>
-<h2>microsoft office 2013 setup with crack free download</h2><br /><p><b><b>Download File</b> &#10038; <a href="https://byltly.com/2uKvwT">https://byltly.com/2uKvwT</a></b></p><br /><br />
-<ol>
-<li>Go to the official Microsoft website and sign in with your Microsoft account. If you don't have one, you can create one for free.</li>
-<li>Click on the Office tab and select Office 2013 from the drop-down menu.</li>
-<li>Choose your preferred language and edition (32-bit or 64-bit) and click on the Download button.</li>
-<li>Save the file to your computer and run it once the download is complete.</li>
-<li>Follow the on-screen instructions to complete the installation process. You may need to enter your product key if you have one.</li>
-<li>Enjoy using Microsoft Office 2013 on your device.</li>
-</ol>
-<p>Note: Microsoft Office 2013 is no longer supported by Microsoft and may not receive security updates or bug fixes. You may want to consider upgrading to a newer version of Office or using an alternative suite of applications.</p>
-
-<h2>How to Use Microsoft Office 2013</h2>
-<p>Once you have installed Microsoft Office 2013 setup with free download, you can start using the applications for your personal or professional needs. Here are some tips on how to use some of the most common features of Office 2013:</p>
-<ul>
-<li>To create a new document, spreadsheet, presentation, or other file, open the application and click on the File tab. Then select New and choose a template or a blank file.</li>
-<li>To save your file, click on the File tab and select Save or Save As. You can save your file to your computer, a removable device, or a cloud service such as OneDrive.</li>
-<li>To edit your file, use the tools and options available on the ribbon, which is the menu bar at the top of the screen. You can also use keyboard shortcuts or right-click menus for more commands.</li>
-<li>To share your file, click on the File tab and select Share. You can send your file as an attachment, a link, or a PDF. You can also invite others to view or edit your file online.</li>
-<li>To get help or learn more about Office 2013, click on the question mark icon at the top right corner of the screen. You can also access online tutorials, videos, and forums from the Office website.</li>
-</ul>
-<p>Microsoft Office 2013 is a powerful and versatile suite of applications that can help you with various tasks and projects. However, it may not be compatible with some newer devices or systems. If you encounter any issues or want to upgrade to a newer version of Office, you can contact Microsoft support or visit their website for more information.</p>
-
-<h2>How to Uninstall Microsoft Office 2013</h2>
-<p>If you want to uninstall Microsoft Office 2013 setup with free download from your device, you can follow these steps:</p>
-<ol>
-<li>Go to the Control Panel and select Programs and Features.</li>
-<li>Find Microsoft Office 2013 in the list of installed programs and click on it.</li>
-<li>Click on the Uninstall button and confirm your choice.</li>
-<li>Wait for the uninstallation process to finish and restart your device if prompted.</li>
-</ol>
-<p>Note: Uninstalling Microsoft Office 2013 will remove all the applications and files associated with it. If you want to keep some of your files, make sure to back them up before uninstalling.</p>
-<p></p>
-
-<h2>How to Download Microsoft Office 2013 Setup with Free Download Again</h2>
-<p>If you want to download Microsoft Office 2013 setup with free download again, you can use the same link and file that you used before. However, you may need to activate your product again with your product key or your Microsoft account. You can also contact Microsoft support or visit their website for more assistance.</p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Estadistica para administracion levine berenson pdf solucionario Todo lo que necesitas saber sobre analisis de datos y toma de decisiones.md

@@ -1,102 +0,0 @@
-
-<h1>Estadistica para administracion levine berenson pdf solucionario</h1>
-<p>¿Te interesa aprender estadística para administración de una manera práctica, sencilla y actualizada? ¿Quieres contar con un libro que te explique los conceptos, las técnicas y las aplicaciones de la estadística en el contexto de los negocios? ¿Te gustaría tener acceso a un solucionario que te ayude a resolver los ejercicios del libro y a reforzar tu aprendizaje? Si tu respuesta es sí, entonces este artículo es para ti.</p>
-<p>En este artículo te voy a hablar sobre el libro <strong>Estadística para Administración</strong>, escrito por David M. Levine, Mark L. Berenson y Timothy C. Krehbiel, en su cuarta edición. Te voy a contar qué es la estadística para administración, quiénes son los autores del libro, qué contiene el libro, cuáles son sus características principales, qué beneficios tiene el libro para los estudiantes y profesionales de la administración, y cómo puedes obtener el solucionario del libro en formato pdf. Al final del artículo, encontrarás una conclusión y algunas preguntas frecuentes sobre el tema.</p>
-<h2>estadistica para administracion levine berenson pdf solucionario</h2><br /><p><b><b>Download</b> &#10026;&#10026;&#10026; <a href="https://byltly.com/2uKyzb">https://byltly.com/2uKyzb</a></b></p><br /><br />
-<h2>Introducción</h2>
-<h3>¿Qué es la estadística para administración?</h3>
-<p>La estadística para administración es una rama de la estadística que se ocupa de recopilar, organizar, analizar e interpretar datos relacionados con las áreas funcionales de los negocios, como contabilidad, economía y finanzas, sistemas de información, administración y marketing. La estadística para administración tiene como objetivo convertir los datos en información útil para tomar decisiones racionales y fundamentadas en el ámbito empresarial.</p>
-<h3>¿Quiénes son Levine, Berenson y Krehbiel?</h3>
-<h3>¿Qué contiene el libro de estadística para administración?</h3>
-<p>El libro de estadística para administración contiene 18 capítulos que abarcan los temas fundamentales de la estadística descriptiva, la probabilidad, las distribuciones de probabilidad, el muestreo, la estimación, las pruebas de hipótesis, el análisis de varianza, la regresión, el análisis multivariado y el control estadístico de la calidad. Cada capítulo incluye una introducción con un escenario de uso de la estadística en los negocios, una exposición teórica con ejemplos y ejercicios resueltos, una sección de aplicaciones con casos reales y problemas propuestos, y una sección de resumen y repaso con conceptos clave y autoevaluación.</p>
-<h2>Características del libro de estadística para administración</h2>
-<h3>Enfoque aplicado a las áreas funcionales de los negocios</h3>
-<p>Una de las características más destacadas del libro de estadística para administración es que presenta cada tema estadístico en un contexto aplicado relacionado con al menos una de las áreas funcionales de los negocios. De esta manera, el libro muestra a los estudiantes la importancia y la utilidad de la estadística para la administración, y les ayuda a desarrollar una visión integral y práctica de los conceptos y las técnicas estadísticas. El libro también enfatiza la interpretación de los resultados estadísticos, la presentación y evaluación de las suposiciones, y la discusión sobre lo que se debe hacer si las suposiciones se violan.</p>
-<h3>Integración del software de hojas de trabajo y estadístico</h3>
-<p>Otra característica importante del libro de estadística para administración es que integra el uso del software de hojas de trabajo (Excel) y el software estadístico (Minitab) en todos los aspectos del curso. El libro reconoce que en el mundo de los negocios el software está disponible en el escritorio del tomador de decisiones, y que permite enfocar el curso en la interpretación de los resultados en lugar de en los cálculos. El libro también proporciona instrucciones detalladas para usar el software y ejemplos ilustrativos con capturas de pantalla.</p>
-<h3>Guía detallada para usar el software</h3>
-<p>El libro de estadística para administración ofrece una guía detallada para usar el software de hojas de trabajo (Excel) y el software estadístico (Minitab) en cada capítulo. El libro explica cómo ingresar los datos, cómo realizar los análisis estadísticos, cómo interpretar los resultados y cómo presentarlos en forma gráfica o tabular. El libro también incluye ejemplos ilustrativos con capturas de pantalla que muestran paso a paso cómo usar el software. El libro no permite que la instrucción del software domine el curso, sino que la integra al estudio de la estadística.</p>
-<p>Estadística para administración - David M. Levine, Timothy C. Krehbiel, Mark L. Berenson - 4ta Edición<br />
-Estadística para administración Mark L. Berenson, David M. Levine, Timothy C. Krehbiel - Google Books<br />
-Estadistica para Administracion y Economia_Levin-Rubin_7ma Ed_Pearson.pdf - Google Drive<br />
-Estadística para administración, 4ta Edición David M. Levine FREELIBROS.ORG<br />
-Estadística para administración Levine Berenson Krehbiel - PDF Descargar<br />
-Estadística para administración - David M. Levine, Mark L. Berenson, Timothy C. Krehbiel - 6ta Edición<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 7ma Edición<br />
-Estadística para administración y economía Levine Rubin - PDF Download<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 6ta Edición<br />
-Estadística para administración y economía Levine Rubin - Solucionario<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 8va Edición<br />
-Estadística para administración y economía Levine Rubin - Libro en Español<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 9na Edición<br />
-Estadística para administración y economía Levine Rubin - eBook Gratis<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 10ma Edición<br />
-Estadística para administración y economía Levine Rubin - Resumen y Análisis<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 11va Edición<br />
-Estadística para administración y economía Levine Rubin - Ejercicios Resueltos<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 12va Edición<br />
-Estadística para administración y economía Levine Rubin - Aplicaciones en Negocios<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 13va Edición<br />
-Estadística para administración y economía Levine Rubin - Conceptos Básicos<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 14va Edición<br />
-Estadística para administración y economía Levine Rubin - Métodos Cuantitativos<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 15va Edición<br />
-Estadística para administración y economía Levine Rubin - Probabilidad y Distribuciones<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 16va Edición<br />
-Estadística para administración y economía Levine Rubin - Inferencia Estadística<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 17va Edición<br />
-Estadística para administración y economía Levine Rubin - Regresión Lineal Simple<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 18va Edición<br />
-Estadística para administración y economía Levine Rubin - Regresión Lineal Múltiple<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 19va Edición<br />
-Estadística para administración y economía Levine Rubin - Análisis de Varianza (ANOVA)<br />
-Estadística para administración y economía - Richard I. Levin, David S. Rubin - 20va Edición<br />
-Estadística para administración y economía Levine Rubin - Pruebas de Hipótesis<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (4ta edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (5ta edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (6ta edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (7ma edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (8va edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (9na edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (10ma edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (11va edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (12va edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (13va edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (14va edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (15va edicion)<br />
-Solucionario de estadistica para la Administracion de Berenson & Levine (16va edicion)</p>
-<h3>Práctica abundante para comprender la estadística en la administración</h3>
-<p>El libro de estadística para administración ofrece una práctica abundante para comprender cómo se usa la estadística en la administración. El libro contiene más de 1.000 ejercicios y problemas propuestos, clasificados por nivel de dificultad y por área funcional de los negocios. El libro también contiene casos reales y aplicaciones que ilustran cómo se usa la estadística en situaciones reales de administración. El libro proporciona las soluciones de algunos ejercicios y problemas al final del libro, y ofrece un solucionario completo en formato pdf que se puede obtener mediante un código QR o un enlace web.</p>
-<h2>Beneficios del libro de estadística para administración</h2>
-<h3>Aprendizaje contextual y relevante</h3>
-área funcional de los negocios, como contabilidad, economía y finanzas, sistemas de información, administración y marketing. De esta manera, el libro hace que el aprendizaje de la estadística sea más interesante, significativo y motivador para los estudiantes y profesionales de la administración.</p>
-<h3>Desarrollo de habilidades analíticas y de toma de decisiones</h3>
-<p>Otro beneficio del libro de estadística para administración es que contribuye al desarrollo de habilidades analíticas y de toma de decisiones en los estudiantes y profesionales de la administración. El libro enseña cómo recopilar, organizar, analizar e interpretar datos relevantes para los negocios, utilizando el software de hojas de trabajo y estadístico. El libro también enseña cómo presentar y comunicar los resultados estadísticos de manera clara y efectiva, utilizando gráficos y tablas. El libro también enseña cómo evaluar las suposiciones estadísticas y cómo actuar si se violan. El libro también enseña cómo aplicar la estadística para resolver problemas reales de administración y para tomar decisiones racionales y fundamentadas.</p>
-<h3>Actualización de datos y ejemplos</h3>
-<p>Un tercer beneficio del libro de estadística para administración es que ofrece una actualización de datos y ejemplos que reflejan las tendencias y los cambios en el mundo de los negocios. El libro utiliza datos reales y actuales, obtenidos de fuentes confiables y reconocidas, como el Banco Mundial, el Fondo Monetario Internacional, la Organización Mundial del Comercio, la Organización para la Cooperación y el Desarrollo Económicos, entre otras. El libro también utiliza ejemplos y casos reales que ilustran cómo se usa la estadística en diferentes sectores e industrias, como el comercio electrónico, las redes sociales, la salud, el deporte, el turismo, entre otros. El libro también incorpora temas emergentes y relevantes para la administración, como la ética, la responsabilidad social, la sostenibilidad, la diversidad, entre otros.</p>
-<h3>Recursos adicionales para el aprendizaje</h3>
-<p>Un cuarto beneficio del libro de estadística para administración es que ofrece recursos adicionales para el aprendizaje que complementan y enriquecen el contenido del libro. El libro cuenta con un sitio web que contiene material adicional para los estudiantes y los profesores, como videos explicativos, presentaciones en PowerPoint, simulaciones interactivas, ejercicios adicionales, entre otros. El libro también cuenta con un solucionario en formato pdf que contiene las soluciones detalladas de todos los ejercicios y problemas propuestos del libro. El solucionario se puede obtener mediante un código QR o un enlace web que se encuentra al final del libro.</p>
-<h2>Solucionario del libro de estadística para administración</h2>
-<h3>¿Qué es el solucionario?</h3>
-<p>El solucionario del libro de estadística para administración es un documento en formato pdf que contiene las soluciones detalladas de todos los ejercicios y problemas propuestos del libro. El solucionario es un recurso muy útil para los estudiantes y profesionales de la administración que quieren verificar sus respuestas, revisar sus procedimientos, corregir sus errores y reforzar su aprendizaje.</p>
-<h3>¿Para qué sirve el solucionario?</h3>
-, sirve para autoevaluar el nivel de comprensión y dominio de la estadística para administración. Por último, sirve para prepararse para los exámenes y las evaluaciones del curso.</p>
-<h3>¿Cómo obtener el solucionario?</h3>
-<p>El solucionario del libro de estadística para administración se puede obtener de dos maneras. La primera manera es mediante un código QR que se encuentra al final del libro. El código QR se puede escanear con un teléfono inteligente o una tableta, y se accede al solucionario en formato pdf. La segunda manera es mediante un enlace web que también se encuentra al final del libro. El enlace web se puede copiar y pegar en un navegador de internet, y se accede al solucionario en formato pdf. El solucionario se puede descargar, imprimir o consultar en línea.</p>
-<h2>Conclusión</h2>
-<p>En conclusión, el libro de estadística para administración, escrito por Levine, Berenson y Krehbiel, en su cuarta edición, es un excelente recurso para los estudiantes y profesionales de la administración que quieren aprender estadística de una manera práctica, sencilla y actualizada. El libro presenta los conceptos, las técnicas y las aplicaciones de la estadística en el contexto de los negocios, utilizando el software de hojas de trabajo y estadístico. El libro también ofrece una práctica abundante, una actualización de datos y ejemplos, y recursos adicionales para el aprendizaje. El libro también cuenta con un solucionario en formato pdf que contiene las soluciones detalladas de todos los ejercicios y problemas propuestos del libro. El solucionario se puede obtener mediante un código QR o un enlace web que se encuentra al final del libro.</p>
-<h2>Preguntas frecuentes</h2>
-<p>A continuación, se presentan algunas preguntas frecuentes sobre el tema del artículo:</p>
-<ul>
-<li><strong>¿Qué es la estadística para administración?</strong> La estadística para administración es una rama de la estadística que se ocupa de recopilar, organizar, analizar e interpretar datos relacionados con las áreas funcionales de los negocios.</li>
-<li><strong>¿Quiénes son los autores del libro de estadística para administración?</strong> Los autores del libro de estadística para administración son David M. Levine, Mark L. Berenson y Timothy C. Krehbiel, tres reconocidos profesores de estadística en diferentes universidades de Estados Unidos.</li>
-<li><strong>¿Qué contiene el libro de estadística para administración?</strong> El libro de estadística para administración contiene 18 capítulos que abarcan los temas fundamentales de la estadística descriptiva, la probabilidad, las distribuciones de probabilidad, el muestreo, la estimación, las pruebas de hipótesis, el análisis de varianza, la regresión, el análisis multivariado y el control estadístico de la calidad.</li>
-<li><strong>¿Cuáles son las características principales del libro de estadística para administración?</strong> Las características principales del libro de estadística para administración son: enfoque aplicado a las áreas funcionales de los negocios, integración del software de hojas de trabajo y estadístico, guía detallada para usar el software y práctica abundante para comprender la estadística en la administración.</li>
-, desarrollo de habilidades analíticas y de toma de decisiones, actualización de datos y ejemplos y recursos adicionales para el aprendizaje.</li>
-<li><strong>¿Qué es el solucionario del libro de estadística para administración?</strong> El solucionario del libro de estadística para administración es un documento en formato pdf que contiene las soluciones detalladas de todos los ejercicios y problemas propuestos del libro.</li>
-<li><strong>¿Para qué sirve el solucionario del libro de estadística para administración?</strong> El solucionario del libro de estadística para administración sirve para practicar y repasar los conceptos y las técnicas estadísticas aprendidas en el libro, para desarrollar habilidades analíticas y de toma de decisiones al resolver problemas reales de administración, para autoevaluar el nivel de comprensión y dominio de la estadística para administración y para prepararse para los exámenes y las evaluaciones del curso.</li>
-<li><strong>¿Cómo obtener el solucionario del libro de estadística para administración?</strong> El solucionario del libro de estadística para administración se puede obtener mediante un código QR o un enlace web que se encuentra al final del libro. El código QR se puede escanear con un teléfono inteligente o una tableta, y se accede al solucionario en formato pdf. El enlace web se puede copiar y pegar en un navegador de internet, y se accede al solucionario en formato pdf. El solucionario se puede descargar, imprimir o consultar en línea.</li>
-</ul>
-</p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/2021 Free Spokeo Login And Password.md

@@ -1,28 +0,0 @@
-<br />
-<h1>How to Find People Online with Spokeo</h1>
-<p>Spokeo is a people search engine that helps you find information about anyone in the U.S. You can use Spokeo to look up people by name, phone number, email address, or physical address. Spokeo can also help you discover social media profiles, criminal records, wealth data, family members, and more.</p>
-<p>However, Spokeo is not a free service. You need to pay a monthly or annual fee to access its full features and reports. If you are looking for a free Spokeo login and password, you might be disappointed. There is no official way to get a free Spokeo account without paying.</p>
-<h2>free spokeo login and password</h2><br /><p><b><b>Download File</b> &#10038; <a href="https://imgfil.com/2uxWTR">https://imgfil.com/2uxWTR</a></b></p><br /><br />
-<p>Some websites claim to offer free Spokeo login and password, but they are usually scams or phishing attempts. They might ask you to download malicious software, fill out surveys, or provide your personal information. These websites are not affiliated with Spokeo and should be avoided at all costs.</p>
-<p>The only legitimate way to get a free Spokeo login and password is to sign up for a free trial. Spokeo offers a 7-day free trial for new customers who want to try out its service. You can cancel your subscription anytime before the trial ends and you won't be charged.</p>
-<p>To sign up for a free Spokeo trial, follow these steps:</p>
-<ol>
-<li>Go to <a href="https://www.spokeo.com/">www.spokeo.com</a></li>
-<li>Click on the "Start Your Free Trial" button</li>
-<li>Enter your email address and create a password</li>
-<li>Enter your payment information (credit card or PayPal)</li>
-<li>Click on the "Start Free Trial" button</li>
-</ol>
-<p>You will receive an email confirmation with your login details. You can now use Spokeo to search for anyone in the U.S. Remember to cancel your subscription before the trial ends if you don't want to pay.</p>
-<p>If you have any questions or issues with your Spokeo account, you can contact their customer care team at 1-888-271-9562 or [email protected].</p><p>Spokeo is more than just a people search engine. It can also help you protect yourself from unwanted calls and texts, reconnect with lost friends and relatives, verify online sellers and buyers, and learn more about your own online presence.</p>
-<p>Here are some of the benefits of using Spokeo:</p>
-<ul>
-<li>Stop Unwanted Calls and Texts: Spokeo can help you identify unknown callers and texters by providing their name, location, carrier, and other details. You can also use Spokeo to block spam calls and texts, report harassment, and find out if your phone number has been compromised.</li>
-<li>Reconnect with Lost Friends and Relatives: Spokeo can help you find current contact information for people you have lost touch with. You can search by name, phone number, email address, or physical address. You can also use Spokeo to find out more about their family members, social media profiles, hobbies, interests, and more.</li>
-<li>Verify Online Sellers and Buyers: Spokeo can help you avoid online scams and frauds by providing background information on potential sellers and buyers. You can use Spokeo to check their identity, location, reputation, criminal records, and more. You can also use Spokeo to find out if they have been involved in any lawsuits or complaints.</li>
-<li>Learn More About Your Online Presence: Spokeo can help you monitor and manage your online reputation by showing you what information is available about you on the web. You can use Spokeo to see your social media profiles, public records, photos, videos, blogs, comments, reviews, and more. You can also use Spokeo to remove unwanted or inaccurate information from the web.</li>
-</ul>
-<p>Spokeo is a powerful tool that can help you find anyone in the U.S. and learn more about them. Whether you are looking for an old friend, a new date, a business partner, or a family member, Spokeo can help you find them and connect with them.</p>
-<p></p> d5da3c52bf<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Bus Simulator Ultimate v1.5.4 MOD APK Hack the Latest Version of the Realistic Bus Simulation Game.md

@@ -1,94 +0,0 @@
-<br />
-<h1>How to Hack Bus Simulator Ultimate 1.5.4 APK for Unlimited Money and More</h1>
-<p>Bus Simulator Ultimate is one of the most realistic and immersive bus driving simulation games for Android devices. You can drive various buses across different countries, cities, and routes, while managing your own bus company, hiring drivers, expanding your fleet, and satisfying your passengers.</p>
-<p>But what if you want to have more money, unlock all the buses, customize your vehicles, and enjoy other perks without spending real cash or playing for hours? Well, you can hack Bus Simulator Ultimate 1.5.4 APK and get access to unlimited resources and features that will make your game more fun and easy.</p>
-<h2>hack bus simulator ultimate 1.5.4 apk</h2><br /><p><b><b>Download Zip</b> &#9913; <a href="https://jinyurl.com/2uNUhA">https://jinyurl.com/2uNUhA</a></b></p><br /><br />
-<p>In this article, we will show you how to hack Bus Simulator Ultimate 1.5.4 APK using different tools and methods, as well as the benefits and risks of doing so. We will also give you some tips on how to enjoy the game with hacks without getting banned or detected by the game developers or other players.</p>
-<h2>Introduction</h2>
-<h3>What is Bus Simulator Ultimate and why you might want to hack it</h3>
-<p>Bus Simulator Ultimate is a popular bus driving simulation game developed by Zuuks Games, the same creators of Truck Simulator 2018: Europe. The game was released in August 2019 and has since been downloaded over 100 million times on Google Play Store.</p>
-<p>How to hack bus simulator ultimate 1.5.4 apk for unlimited money<br />
-Bus simulator ultimate 1.5.4 apk mod menu download<br />
-Bus simulator ultimate 1.5.4 apk hack no root<br />
-Bus simulator ultimate 1.5.4 apk free shopping hack<br />
-Bus simulator ultimate 1.5.4 apk unlimited fuel hack<br />
-Bus simulator ultimate 1.5.4 apk hack online generator<br />
-Bus simulator ultimate 1.5.4 apk hack without verification<br />
-Bus simulator ultimate 1.5.4 apk hack latest version<br />
-Bus simulator ultimate 1.5.4 apk hack android<br />
-Bus simulator ultimate 1.5.4 apk hack ios<br />
-Bus simulator ultimate 1.5.4 apk hack tool<br />
-Bus simulator ultimate 1.5.4 apk hack reddit<br />
-Bus simulator ultimate 1.5.4 apk hack youtube<br />
-Bus simulator ultimate 1.5.4 apk hack tutorial<br />
-Bus simulator ultimate 1.5.4 apk hack review<br />
-Bus simulator ultimate 1.5.4 apk hack gameplay<br />
-Bus simulator ultimate 1.5.4 apk hack features<br />
-Bus simulator ultimate 1.5.4 apk hack tips and tricks<br />
-Bus simulator ultimate 1.5.4 apk hack guide<br />
-Bus simulator ultimate 1.5.4 apk hack cheats<br />
-Bus simulator ultimate 1.5.4 apk hack codes<br />
-Bus simulator ultimate 1.5.4 apk hack file download<br />
-Bus simulator ultimate 1.5.4 apk hack obb download<br />
-Bus simulator ultimate 1.5.4 apk hack data download<br />
-Bus simulator ultimate 1.5.4 apk hack install<br />
-Bus simulator ultimate 1.5.4 apk hack update<br />
-Bus simulator ultimate 1.5.4 apk hack patch notes<br />
-Bus simulator ultimate 1.5.4 apk hack bug fixes<br />
-Bus simulator ultimate 1.5.4 apk hack support<br />
-Bus simulator ultimate 1.5.4 apk hack feedback<br />
-Bus simulator ultimate 1.5.4 apk hack rating<br />
-Bus simulator ultimate 1.5.4 apk hack comparison<br />
-Bus simulator ultimate 1.5.4 apk hack alternatives<br />
-Bus simulator ultimate 1.5.4 apk hack benefits<br />
-Bus simulator ultimate 1.5.4 apk hack disadvantages<br />
-Bus simulator ultimate 1.5.4 apk hack pros and cons<br />
-Bus simulator ultimate 1.5.4 apk hack testimonials<br />
-Bus simulator ultimate 1.5.4 apk hack comments<br />
-Bus simulator ultimate 1.5.4 apk hack questions and answers<br />
-Bus simulator ultimate 1.5.4 apk hack faq<br />
-Bus simulator ultimate 1.5.4 apk hack requirements<br />
-Bus simulator ultimate 1</p>
-<p>The game lets you experience what it's like to be a bus driver in various countries, such as Germany, Turkey, Italy, France, Spain, Netherlands, Brazil, Azerbaijan, Russia, etc. You can choose from over 25 different buses, each with their own realistic interiors, sounds, physics, and features.</p>
-<p>You can also create your own bus company, hire drivers, buy new buses, upgrade your vehicles, set your ticket prices, design your routes, and earn money from your passengers. You can also compete with other players in multiplayer mode or join online events and tournaments.</p>
-<p>However, as realistic and immersive as the game is, it can also be quite challenging and time-consuming. You need to earn enough money to buy new buses, maintain your vehicles, pay your drivers, expand your routes, etc. You also need to follow the traffic rules, avoid accidents, deal with weather conditions, satisfy your passengers' needs, etc.</p>
-<p>That's why some players might want to hack Bus Simulator Ultimate 1.5.4 APK and get unlimited money, unlock all the buses, customize their vehicles, skip ads, remove restrictions, etc.</p>
-<h3>What are the benefits of hacking Bus Simulator Ultimate 1.5.4 APK</h3>
-<p>Hacking Bus Simulator Ultimate 1.5.4 APK can give you many benefits that can enhance your gaming experience and make it more fun and easy Some of the benefits of hacking Bus Simulator Ultimate 1.5.4 APK are: - You can get unlimited money and buy any bus you want, upgrade your vehicles, hire more drivers, etc. - You can unlock all the buses and access their unique features, such as different interiors, sounds, physics, etc. - You can customize your vehicles and change their colors, skins, logos, etc. - You can skip ads and enjoy the game without interruptions or distractions - You can remove restrictions and play the game in any country, city, or route you want - You can cheat and manipulate the game data and settings, such as speed, fuel, traffic, weather, passengers, etc. <h3>What are the risks of hacking Bus Simulator Ultimate 1.5.4 APK</h3>
-<p>However, hacking Bus Simulator Ultimate 1.5.4 APK also comes with some risks that you should be aware of and avoid. Some of the risks of hacking Bus Simulator Ultimate 1.5.4 APK are:</p>
- - You can get banned or detected by the game developers or other players if you use hacks in multiplayer mode or online events - You can lose your progress and data if you use an incompatible or corrupted APK file or hack tool - You can damage your device or expose it to malware or viruses if you download an unsafe or untrusted APK file or hack tool - You can ruin the fun and challenge of the game if you use hacks that make it too easy or boring <h2>How to Download Bus Simulator Ultimate 1.5.4 APK</h2>
-<h3>Where to find the original APK file and how to install it</h3>
-<p>If you want to hack Bus Simulator Ultimate 1.5.4 APK, you need to have the original APK file of the game installed on your device first. You can find the original APK file of Bus Simulator Ultimate 1.5.4 on Google Play Store or other reputable sources, such as APKPure, APKMirror, etc.</p>
-<p>To install the original APK file of Bus Simulator Ultimate 1.5.4 on your device, you need to follow these steps:</p>
- - Go to the source where you downloaded the APK file and tap on it - Allow your device to install apps from unknown sources if prompted - Follow the instructions on the screen and wait for the installation to complete - Launch the game and enjoy <h3>How to check the version and compatibility of your device</h3>
-<p>Before you hack Bus Simulator Ultimate 1.5.4 APK, you need to make sure that your device is compatible with the game and that you have the latest version of the game installed. To check the version and compatibility of your device, you need to follow these steps:</p>
- - Go to Google Play Store and search for Bus Simulator Ultimate - Tap on the game icon and scroll down to see the details - Check the current version of the game and compare it with the version of your installed APK file - Check the minimum requirements of the game and compare them with your device's specifications - Update the game or your device if needed <h2>How to Hack Bus Simulator Ultimate 1.5.4 APK</h2>
-<h3>What are the tools and methods you need to hack Bus Simulator Ultimate 1.5.4 APK</h3>
-<p>There are different tools and methods that you can use to hack Bus Simulator Ultimate 1.5.4 APK and get unlimited money and other features. Some of the most common and effective tools and methods are:</p>
- - Modded APK file: A modded APK file is a modified version of the original APK file that has been altered by hackers to include cheats and hacks in the game. You can download a modded APK file of Bus Simulator Ultimate 1.5.4 from various sources online, such as ModAPKStore, Rexdl, etc. - Game hacker app: A game hacker app is an application that allows you to modify the game data and settings on your device using various techniques, such as memory editing, code injection, hex editing, etc. You can download a game hacker app from various sources online, such as Game Guardian, Lucky Patcher, Cheat Engine, etc. - Cheat engine: A cheat engine is a software that allows you to manipulate the game memory and values on your device using various techniques, such as scanning, debugging, disassembling, etc. You can download a cheat engine from various sources online, such as Cheat Engine for Android, SB Game Hacker, Game Killer, etc. <h3>How to use a modded APK file to get unlimited money and other features</h3>
-<p>To use a modded APK file to hack Bus Simulator Ultimate 1.5.4 APK and get unlimited money and other features, you need to follow these steps:</p>
- - Find a reliable source where you can download a modded APK file of Bus Simulator Ultimate 1.5.4 with unlimited money and other features - Uninstall the original APK file of Bus Simulator Ultimate 1.5.4 from your device if you have it - Enable the installation of apps from unknown sources on your device settings if you haven't done so already - Download the modded APK file of Bus Simulator Ultimate 1.5.4 from the source and tap on it - Follow the instructions on the screen and wait for the installation to complete - Launch the game and enjoy the hacks <h3>How to use a game hacker app to modify the game data and settings</h3>
-<p>To use a game hacker app to hack Bus Simulator Ultimate 1.5.4 APK and modify the game data and settings, you need to follow these steps:</p>
- - Install a game hacker app on your device from a trusted source, such as Game Guardian, Lucky Patcher, Cheat Engine, etc. - Launch the game hacker app and grant it root access or other permissions if required - Launch Bus Simulator Ultimate 1.5.4 APK and start playing the game - Minimize the game and open the game hacker app - Select Bus Simulator Ultimate 1.5.4 APK from the list of running processes or apps - Search for the value or parameter that you want to change, such as money, speed, fuel, etc. - Modify the value or parameter according to your preference and apply the changes - Resume the game and enjoy the hacks <h3>How to use a cheat engine to manipulate the game memory and values</h3>
-<p>To use a cheat engine to hack Bus Simulator Ultimate 1.5.4 APK and manipulate the game memory and values, you need to follow these steps:</p>
- - Install a cheat engine on your device from a reliable source, such as Cheat Engine for Android, SB Game Hacker, Game Killer, etc. - Launch the cheat engine and grant it root access or other permissions if needed - Launch Bus Simulator Ultimate 1.5.4 APK and start playing the game - Minimize the game and open the cheat engine - Select Bus Simulator Ultimate 1.5.4 APK from the list of running processes or apps - Scan for the value or address that you want to change, such as money, speed, fuel, etc. - Change the value or address according to your desire and apply the changes - Resume the game and enjoy the hacks <h2>How to Enjoy Bus Simulator Ultimate 1.5.4 APK with Hacks</h2>
-<h3>What are the features and gameplay of Bus Simulator Ultimate 1.5.4 APK</h3>
-<p>Bus Simulator Ultimate 1.5.4 APK is a realistic and immersive bus driving simulation game that offers you many features and gameplay options, such as:</p>
- - Driving over 25 different buses with realistic interiors, sounds, physics, and features - Creating your own bus company, hiring drivers, buying new buses, upgrading your vehicles, setting your ticket prices, designing your routes, and earning money from your passengers - Competing with other players in multiplayer mode or joining online events and tournaments - Exploring various countries, cities, and routes with different traffic rules, weather conditions, landmarks, etc. - Satisfying your passengers' needs, such as comfort, entertainment, food, etc. - Following the traffic rules, avoiding accidents, dealing with emergencies, etc. <h3>How to use the hacks to enhance your gaming experience and have more fun</h3>
-<p>You can use the hacks that you have applied to Bus Simulator Ultimate 1.5.4 APK to enhance your gaming experience and have more fun in various ways, such as:</p>
- - Buying any bus you want and customizing it to your liking - Expanding your bus company and dominating the market - Skipping ads and playing without interruptions or distractions - Playing in any country, city, or route you want without restrictions - Cheating and manipulating the game data and settings to your advantage <h3>How to avoid getting banned or detected by the game developers or other players</h3>
-<p>However, you should also be careful not to get banned or detected by the game developers or other players when using hacks in Bus Simulator Ultimate 1.5.4 APK. Here are some tips on how to avoid getting banned or detected:</p>
- - Use hacks only in offline mode or single-player mode - Do not use hacks in multiplayer mode or online events - Do not use hacks that are too obvious or unrealistic - Do not use hacks that affect other players' gameplay or experience - Do not brag or boast about using hacks in public forums or chats <h2>Conclusion</h2>
-<p>Hacking Bus Simulator Ultimate 1.5.4 APK can give you unlimited money and other features that can make your game more fun and easy. However, hacking Bus Simulator Ultimate 1. 5.4 APK also comes with some risks that you should be aware of and avoid. You can get banned or detected by the game developers or other players if you use hacks in multiplayer mode or online events. You can also lose your progress and data if you use an incompatible or corrupted APK file or hack tool. Moreover, you can damage your device or expose it to malware or viruses if you download an unsafe or untrusted APK file or hack tool. Furthermore, you can ruin the fun and challenge of the game if you use hacks that make it too easy or boring. Therefore, you should use hacks in Bus Simulator Ultimate 1.5.4 APK with caution and moderation. You should also respect the game developers and other players and not abuse the hacks or spoil their gameplay or experience. You should also follow the tips on how to avoid getting banned or detected when using hacks in Bus Simulator Ultimate 1.5.4 APK. We hope that this article has helped you learn how to hack Bus Simulator Ultimate 1.5.4 APK and enjoy the game with unlimited money and other features. If you have any questions or feedback, please feel free to leave a comment below. Happy hacking! <h2>FAQs</h2>
-<h3>Q: Is hacking Bus Simulator Ultimate 1.5.4 APK legal?</h3>
-<p>A: Hacking Bus Simulator Ultimate 1.5.4 APK is not illegal, but it is against the terms and conditions of the game and the Google Play Store. Therefore, you may face some consequences if you get caught or reported by the game developers or other players.</p>
-<h3>Q: Is hacking Bus Simulator Ultimate 1.5.4 APK safe?</h3>
-<p>A: Hacking Bus Simulator Ultimate 1.5.4 APK is not completely safe, as there are some risks involved, such as getting banned or detected, losing your progress and data, damaging your device, or exposing it to malware or viruses. Therefore, you should be careful and responsible when hacking Bus Simulator Ultimate 1.5.4 APK and only use trusted sources and tools.</p>
-<h3>Q: How can I update Bus Simulator Ultimate 1.5.4 APK after hacking it?</h3>
-<p>A: If you want to update Bus Simulator Ultimate 1.5.4 APK after hacking it, you need to uninstall the hacked version of the game and install the latest version of the original APK file from Google Play Store or other reputable sources. However, you may lose your hacks and progress if you do so.</p>
-<h3>Q: Can I hack Bus Simulator Ultimate 1.5.4 APK without root access?</h3>
-<p>A: Yes, you can hack Bus Simulator Ultimate 1.5.4 APK without root access using some tools and methods, such as modded APK files, game hacker apps, cheat engines, etc. However, some tools and methods may require root access to work properly.</p>
-<h3>Q: Can I hack Bus Simulator Ultimate 1.5.4 APK on iOS devices?</h3>
-<p>A: No, you cannot hack Bus Simulator Ultimate 1.5.4 APK on iOS devices, as the game is only available for Android devices.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download YouTube 4.0 APK for Android - Watch Videos Offline.md

@@ -1,158 +0,0 @@
-
-<h1>Download YouTube 4.0 for Android: How to Enjoy Videos on Your Phone</h1>
-<p>YouTube is the most popular video-sharing platform in the world, with billions of users and hours of content uploaded every minute. Whether you want to watch the latest music videos, learn something new, or catch up with your favorite creators, YouTube has something for everyone.</p>
-<h2>download youtube 4.0 for android</h2><br /><p><b><b>DOWNLOAD</b> &#127379; <a href="https://jinyurl.com/2uNQXk">https://jinyurl.com/2uNQXk</a></b></p><br /><br />
-<p>But what if you want to enjoy YouTube on your Android phone? You might think that you need the latest version of the app, which requires Android 5.0 or higher. But that's not true! You can still download and use YouTube 4.0 for Android, which works on devices running Android 4.1 or higher.</p>
-<p>In this article, we will show you how to download and install YouTube 4.0 for Android, how to use its features and benefits, and how to make the most of your YouTube experience on your phone.</p>
- <h2>What is YouTube 4.0 for Android?</h2>
-<p>YouTube 4.0 for Android is an older version of the official YouTube app that was released in August 2013. It has a simple and intuitive interface that lets you access all the essential functions of YouTube, such as browsing, watching, creating, and sharing videos.</p>
-<p>How to download youtube 4.0 for android phone<br />
-Download youtube 4.0 apk for android tablet<br />
-Youtube 4.0 for android free download latest version<br />
-Download youtube 4.0 for android offline mode<br />
-Youtube 4.0 for android download without ads<br />
-Download youtube 4.0 for android with dark mode<br />
-Youtube 4.0 for android download and install guide<br />
-Download youtube 4.0 for android from uptodown[^1^]<br />
-Youtube 4.0 for android download link<br />
-Download youtube 4.0 for android no root<br />
-Youtube 4.0 for android download error fix<br />
-Download youtube 4.0 for android mod apk<br />
-Youtube 4.0 for android download features<br />
-Download youtube 4.0 for android old version<br />
-Youtube 4.0 for android download size<br />
-Download youtube 4.0 for android premium apk<br />
-Youtube 4.0 for android download speed<br />
-Download youtube 4.0 for android beta version<br />
-Youtube 4.0 for android download review<br />
-Download youtube 4.0 for android update<br />
-Youtube 4.0 for android download requirements<br />
-Download youtube 4.0 for android from google play store<br />
-Youtube 4.0 for android download alternative<br />
-Download youtube 4.0 for android on pc<br />
-Youtube 4.0 for android download comparison<br />
-Download youtube 4.0 for android with subtitles<br />
-Youtube 4.0 for android download quality settings<br />
-Download youtube 4.0 for android with background play<br />
-Youtube 4.0 for android download tips and tricks<br />
-Download youtube 4.0 for android with vpn<br />
-Youtube 4.0 for android download problems and solutions<br />
-Download youtube 4.0 for android with screen recorder<br />
-Youtube 4.0 for android download support<br />
-Download youtube 4.0 for android with picture-in-picture mode<br />
-Youtube 4.0 for android download benefits<br />
-Download youtube 4.0 for android with downloader app<br />
-Youtube 4.0 for android download disadvantages<br />
-Download youtube 4.0 for android with chromecast support<br />
-Youtube 4.0 for android download statistics<br />
-Download youtube 4.0 for android with voice search<br />
-Youtube 4.0 for android download feedback<br />
-Download youtube 4.0 for android with playlist manager<br />
-Youtube 4.0 for android download security<br />
-Download youtube 4.0 for android with notifications settings<br />
-Youtube 4.0 for android download history<br />
-Download youtube 4.0 for android with comments section<br />
-Youtube 4.0 for android download ratings<br />
-Download youtube 4.0 for android with live streaming option<br />
-Youtube 4.0 for android download recommendations</p>
-<p>YouTube 4.0 for Android also supports some features that are not available in newer versions of the app, such as:</p>
-<ul>
-<li>The ability to play videos in the background while using other apps or when the screen is locked</li>
-<li>The ability to watch videos in portrait or landscape mode</li>
-<li>The ability to adjust the video quality manually</li>
-<li>The ability to view comments and related videos while watching a video</li>
-</ul>
-<p>However, YouTube 4.0 for Android also has some limitations, such as:</p>
-<ul>
-<li>The lack of support for some newer features, such as Stories, Shorts, Live streams, and Channel memberships</li>
-<li>The lack of updates and bug fixes from Google</li>
-<li>The possibility of compatibility issues with some devices or videos</li>
-</ul>
- <h2>How to download and install YouTube 4.0 for Android</h2>
-<p>If you want to download and install YouTube 4.0 for Android, you need to follow these steps:</p>
-<ol>
-<li>Go to [this link](^1^) on your phone's browser and tap on "Download APK". This will download the file "youtube-4-0-8.apk" to your phone.</li>
-<li>Go to your phone's settings and enable "Unknown sources" under "Security". This will allow you to install apps from sources other than Google Play Store.</li>
-<li>Go to your phone's file manager and locate the downloaded file "youtube-4-0-8.apk". Tap on it and follow the instructions to install it.</li>
-<li>Once installed, you can launch the app from your app drawer or home screen.</li>
-</ol>
- <h2>How to use YouTube 4.0 for Android</h2>
- <h3>How to browse and watch videos on YouTube 4.0 for Android</h3>
-<p>To browse and watch videos on YouTube 4.0 for Android, you can use the following options:</p>
-<ul>
-<li>The Home tab shows you personalized recommendations based on your watch history, preferences, and subscriptions.</li>
-<li>The Trending tab shows you the most popular and viral videos across different categories, such as music, gaming, news, and entertainment.</li>
-<li>The Subscriptions tab shows you the latest videos from the channels you have subscribed to.</li>
-<li>The Search icon lets you search for videos by keywords, filters, or voice commands.</li>
-<li>The Menu icon lets you access other features, such as your account, settings, history, favorites, playlists, uploads, and downloads.</li>
-</ul>
-<p>To watch a video on YouTube 4.0 for Android, you can simply tap on it and it will start playing. You can also use the following controls:</p>
-<ul>
-<li>The Play/Pause button lets you pause or resume the video.</li>
-<li>The Seek bar lets you skip forward or backward in the video.</li>
-<li>The Fullscreen button lets you switch between portrait and landscape mode.</li>
-<li>The Quality button lets you adjust the video resolution manually.</li>
-<li>The Share button lets you share the video with other apps or contacts.</li>
-<li>The Add to button lets you add the video to your favorites or playlists.</li>
-<li>The More button lets you access other options, such as report, caption, flag, or info.</li>
-</ul>
- <h3>How to create and upload videos on YouTube 4.0 for Android</h3>
-<p>To create and upload videos on YouTube 4.0 for Android, you can use the following options:</p>
-<ul>
-<li>The Camera icon lets you record a new video using your phone's camera. You can also edit the video by trimming, adding filters, or adding music.</li>
-<li>The Gallery icon lets you select an existing video from your phone's gallery. You can also edit the video by trimming, adding filters, or adding music.</li>
-<li>The Upload icon lets you upload the video to your YouTube channel. You can also add a title, description, tags, category, privacy, and location to your video.</li>
-</ul>
- <h3>How to connect with the YouTube community on YouTube 4.0 for Android</h3>
-<p>To connect with the YouTube community on YouTube 4.0 for Android, you can use the following options:</p>
-<ul>
-<li>The Like button lets you express your appreciation for a video.</li>
-<li>The Dislike button lets you express your dissatisfaction for a video.</li>
-<li>The Comment button lets you leave a comment on a video. You can also reply to other comments or like them.</li>
-<li>The Subscribe button lets you follow a channel and get notified of their new videos.</li>
-</ul>
- <h2>Tips and tricks for YouTube 4.0 for Android</h2>
- <h3>How to customize your YouTube experience on YouTube 4.0 for Android</h3>
-<p>To customize your YouTube experience on YouTube 4.0 for Android, you can use the following options:</p>
-<ul>
-<li>The Settings icon lets you access various settings, such as notifications, playback, captions, downloads, privacy, and account.</li>
-<li>The Account icon lets you manage your YouTube account, such as your profile, channel, subscriptions, favorites, playlists, uploads, downloads, history, and watch later.</li>
-</ul>
- <h3>How to save videos for offline viewing on YouTube 4.0 for Android</h3>
-<p>To save videos for offline viewing on YouTube 4.0 for Android, you can use the following option:</p>
-<ul>
-<li>The Download icon lets you download a video to your phone's storage. You can also choose the quality and size of the download. You can watch the downloaded videos from the Downloads tab in the Menu icon.</li>
-</ul>
- <h3>How to upgrade to YouTube Premium on YouTube 4.0 for Android</h3>
-<p>To upgrade to YouTube Premium on YouTube 4.0 for Android, you can use the following option:</p>
-<ul>
-<li>The Upgrade icon lets you sign up for YouTube Premium, which is a paid subscription service that offers ad-free videos, background play, offline access, and exclusive content. You can also enjoy YouTube Music, which is a music streaming service that lets you access millions of songs and playlists. You can try YouTube Premium for free for one month and then pay a monthly fee of $11.99.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>YouTube 4.0 for Android is a great way to enjoy videos on your phone, especially if you have an older device or a limited data plan. It has a simple and intuitive interface that lets you access all the essential functions of YouTube, such as browsing, watching, creating, and sharing videos. It also supports some features that are not available in newer versions of the app, such as background play, manual quality adjustment, and portrait mode.</p>
-<p>However, YouTube 4.0 for Android also has some limitations, such as the lack of support for some newer features, the lack of updates and bug fixes, and the possibility of compatibility issues. Therefore, you should weigh the pros and cons of using YouTube 4.0 for Android before downloading and installing it.</p>
-<p>If you want to download YouTube 4.0 for Android, you can follow the steps we have outlined in this article. You can also use our tips and tricks to customize your YouTube experience and make the most of it. We hope you found this article helpful and informative.</p>
-<p>Now that you know how to download YouTube 4.0 for Android, why not give it a try and see for yourself? You might be surprised by how much you can do with this old but gold version of the app. Happy watching!</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about YouTube 4.0 for Android:</p>
-<ol>
-<li>Is YouTube 4.0 for Android safe to use?</li>
-<p>YouTube 4.0 for Android is safe to use as long as you download it from a trusted source, such as [this link]. However, you should be aware that Google does not support or update this version of the app anymore, so there might be some security risks or vulnerabilities that are not fixed.</p>
-<li>Can I use YouTube 4.0 for Android on any device?</li>
-<p>You can use YouTube 4.0 for Android on any device that runs Android 4.1 or higher. However, some devices or videos might not be compatible with this version of the app, so you might encounter some errors or glitches while using it.</p>
-<li>Can I use YouTube 4.0 for Android along with the latest version of the app?</li>
-<p>You can use YouTube 4.0 for Android along with the latest version of the app if you have enough storage space on your phone. However, you should not run both apps at the same time, as this might cause some conflicts or crashes.</p>
-<li>Can I update YouTube 4.0 for Android to the latest version of the app?</li>
-<p>You can update YouTube 4.0 for Android to the latest version of the app by going to Google Play Store and tapping on "Update". However, this will overwrite your existing version of the app and you will lose some features that are only available in YouTube 4.0 for Android.</p>
-<li>Can I downgrade from the latest version of the app to YouTube 4.0 for Android?</li>
-<p>You can downgrade from the latest version of the app to YouTube 4.0 for Android by following these steps:</p>
-<ol>
-<li>Uninstall the latest version of the app from your phone.</li>
-<li>Go to [this link] on your phone's browser and tap on "Download APK". This will download the file "youtube-4-0-8.apk" to your phone.</li>
-<li>Go to your phone's settings and enable "Unknown sources" under "Security". This will allow you to install apps from sources other than Google Play Store.</li>
-<li>Go to your phone's file manager and locate the downloaded file "youtube-4-0-8.apk". Tap on it and follow the instructions to install it.</li>
-<li>Once installed, you can launch the app from your app drawer or home screen.</li>
-</ol>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/232labs/VToonify/vtoonify/model/raft/evaluate.py

@@ -1,197 +0,0 @@
-import sys
-sys.path.append('core')
-
-from PIL import Image
-import argparse
-import os
-import time
-import numpy as np
-import torch
-import torch.nn.functional as F
-import matplotlib.pyplot as plt
-
-import datasets
-from utils import flow_viz
-from utils import frame_utils
-
-from raft import RAFT
-from utils.utils import InputPadder, forward_interpolate
-
-
-@torch.no_grad()
-def create_sintel_submission(model, iters=32, warm_start=False, output_path='sintel_submission'):
-    """ Create submission for the Sintel leaderboard """
-    model.eval()
-    for dstype in ['clean', 'final']:
-        test_dataset = datasets.MpiSintel(split='test', aug_params=None, dstype=dstype)
-        
-        flow_prev, sequence_prev = None, None
-        for test_id in range(len(test_dataset)):
-            image1, image2, (sequence, frame) = test_dataset[test_id]
-            if sequence != sequence_prev:
-                flow_prev = None
-            
-            padder = InputPadder(image1.shape)
-            image1, image2 = padder.pad(image1[None].cuda(), image2[None].cuda())
-
-            flow_low, flow_pr = model(image1, image2, iters=iters, flow_init=flow_prev, test_mode=True)
-            flow = padder.unpad(flow_pr[0]).permute(1, 2, 0).cpu().numpy()
-
-            if warm_start:
-                flow_prev = forward_interpolate(flow_low[0])[None].cuda()
-            
-            output_dir = os.path.join(output_path, dstype, sequence)
-            output_file = os.path.join(output_dir, 'frame%04d.flo' % (frame+1))
-
-            if not os.path.exists(output_dir):
-                os.makedirs(output_dir)
-
-            frame_utils.writeFlow(output_file, flow)
-            sequence_prev = sequence
-
-
-@torch.no_grad()
-def create_kitti_submission(model, iters=24, output_path='kitti_submission'):
-    """ Create submission for the Sintel leaderboard """
-    model.eval()
-    test_dataset = datasets.KITTI(split='testing', aug_params=None)
-
-    if not os.path.exists(output_path):
-        os.makedirs(output_path)
-
-    for test_id in range(len(test_dataset)):
-        image1, image2, (frame_id, ) = test_dataset[test_id]
-        padder = InputPadder(image1.shape, mode='kitti')
-        image1, image2 = padder.pad(image1[None].cuda(), image2[None].cuda())
-
-        _, flow_pr = model(image1, image2, iters=iters, test_mode=True)
-        flow = padder.unpad(flow_pr[0]).permute(1, 2, 0).cpu().numpy()
-
-        output_filename = os.path.join(output_path, frame_id)
-        frame_utils.writeFlowKITTI(output_filename, flow)
-
-
-@torch.no_grad()
-def validate_chairs(model, iters=24):
-    """ Perform evaluation on the FlyingChairs (test) split """
-    model.eval()
-    epe_list = []
-
-    val_dataset = datasets.FlyingChairs(split='validation')
-    for val_id in range(len(val_dataset)):
-        image1, image2, flow_gt, _ = val_dataset[val_id]
-        image1 = image1[None].cuda()
-        image2 = image2[None].cuda()
-
-        _, flow_pr = model(image1, image2, iters=iters, test_mode=True)
-        epe = torch.sum((flow_pr[0].cpu() - flow_gt)**2, dim=0).sqrt()
-        epe_list.append(epe.view(-1).numpy())
-
-    epe = np.mean(np.concatenate(epe_list))
-    print("Validation Chairs EPE: %f" % epe)
-    return {'chairs': epe}
-
-
-@torch.no_grad()
-def validate_sintel(model, iters=32):
-    """ Peform validation using the Sintel (train) split """
-    model.eval()
-    results = {}
-    for dstype in ['clean', 'final']:
-        val_dataset = datasets.MpiSintel(split='training', dstype=dstype)
-        epe_list = []
-
-        for val_id in range(len(val_dataset)):
-            image1, image2, flow_gt, _ = val_dataset[val_id]
-            image1 = image1[None].cuda()
-            image2 = image2[None].cuda()
-
-            padder = InputPadder(image1.shape)
-            image1, image2 = padder.pad(image1, image2)
-
-            flow_low, flow_pr = model(image1, image2, iters=iters, test_mode=True)
-            flow = padder.unpad(flow_pr[0]).cpu()
-
-            epe = torch.sum((flow - flow_gt)**2, dim=0).sqrt()
-            epe_list.append(epe.view(-1).numpy())
-
-        epe_all = np.concatenate(epe_list)
-        epe = np.mean(epe_all)
-        px1 = np.mean(epe_all<1)
-        px3 = np.mean(epe_all<3)
-        px5 = np.mean(epe_all<5)
-
-        print("Validation (%s) EPE: %f, 1px: %f, 3px: %f, 5px: %f" % (dstype, epe, px1, px3, px5))
-        results[dstype] = np.mean(epe_list)
-
-    return results
-
-
-@torch.no_grad()
-def validate_kitti(model, iters=24):
-    """ Peform validation using the KITTI-2015 (train) split """
-    model.eval()
-    val_dataset = datasets.KITTI(split='training')
-
-    out_list, epe_list = [], []
-    for val_id in range(len(val_dataset)):
-        image1, image2, flow_gt, valid_gt = val_dataset[val_id]
-        image1 = image1[None].cuda()
-        image2 = image2[None].cuda()
-
-        padder = InputPadder(image1.shape, mode='kitti')
-        image1, image2 = padder.pad(image1, image2)
-
-        flow_low, flow_pr = model(image1, image2, iters=iters, test_mode=True)
-        flow = padder.unpad(flow_pr[0]).cpu()
-
-        epe = torch.sum((flow - flow_gt)**2, dim=0).sqrt()
-        mag = torch.sum(flow_gt**2, dim=0).sqrt()
-
-        epe = epe.view(-1)
-        mag = mag.view(-1)
-        val = valid_gt.view(-1) >= 0.5
-
-        out = ((epe > 3.0) & ((epe/mag) > 0.05)).float()
-        epe_list.append(epe[val].mean().item())
-        out_list.append(out[val].cpu().numpy())
-
-    epe_list = np.array(epe_list)
-    out_list = np.concatenate(out_list)
-
-    epe = np.mean(epe_list)
-    f1 = 100 * np.mean(out_list)
-
-    print("Validation KITTI: %f, %f" % (epe, f1))
-    return {'kitti-epe': epe, 'kitti-f1': f1}
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--model', help="restore checkpoint")
-    parser.add_argument('--dataset', help="dataset for evaluation")
-    parser.add_argument('--small', action='store_true', help='use small model')
-    parser.add_argument('--mixed_precision', action='store_true', help='use mixed precision')
-    parser.add_argument('--alternate_corr', action='store_true', help='use efficent correlation implementation')
-    args = parser.parse_args()
-
-    model = torch.nn.DataParallel(RAFT(args))
-    model.load_state_dict(torch.load(args.model))
-
-    model.cuda()
-    model.eval()
-
-    # create_sintel_submission(model.module, warm_start=True)
-    # create_kitti_submission(model.module)
-
-    with torch.no_grad():
-        if args.dataset == 'chairs':
-            validate_chairs(model.module)
-
-        elif args.dataset == 'sintel':
-            validate_sintel(model.module)
-
-        elif args.dataset == 'kitti':
-            validate_kitti(model.module)
-
-

spaces/42digital/DeepFashion_Classification/app.py

@@ -1,31 +0,0 @@
-import gradio as gr
-from huggingface_hub import hf_hub_download
-from fastai.learner import load_learner
-import os
-
-print(gr.__version__)
-
-TOKEN = os.environ["token"]
-REPO_ID = "42digital/deepfashion_classification_vit-large-patch14-clip-336"
-FILENAME = "model.pkl"
-EXAMPLES = ["dress.jpg", "hoodie.jpg", "joggers.jpg", "jumpsuit.jpg", "shorts.jpg", "tee.jpg"]
-
-learner = load_learner(
-    hf_hub_download(repo_id=REPO_ID, filename=FILENAME, token=TOKEN)
-)
-
-def predict(img):
-    _, _, probs = learner.predict(img)
-    probs = [float(p) for p in probs.detach()]
-    preds = {k: v for k, v in zip(learner.dls.vocab, probs)}
-    return preds
-
-gr.Interface(fn=predict, 
-             inputs=gr.Image(type="numpy"),
-             outputs=gr.Label(num_top_classes=5),
-             examples=EXAMPLES,
-             cache_examples=False,
-             title="Fashion Classification",
-             description="Recognize clothes in an image. [ViT-L/14](https://arxiv.org/abs/2010.11929) trained on 46 clothing categories from [DeepFashion](https://openaccess.thecvf.com/content_cvpr_2016/html/Liu_DeepFashion_Powering_Robust_CVPR_2016_paper.html) @ 76% Top-1 Accuracy and 92% [Top-3 Accuracy](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.top_k_accuracy_score.html) (many images show more than one clothing item).",
-             analytics_enabled=False,
-            ).launch()

spaces/52Hz/SUNet_AWGN_denoising/model/SUNet.py

@@ -1,30 +0,0 @@
-import torch.nn as nn
-from model.SUNet_detail import SUNet
-
-
-class SUNet_model(nn.Module):
-    def __init__(self, config):
-        super(SUNet_model, self).__init__()
-        self.config = config
-        self.swin_unet = SUNet(img_size=config['SWINUNET']['IMG_SIZE'],
-                               patch_size=config['SWINUNET']['PATCH_SIZE'],
-                               in_chans=3,
-                               out_chans=3,
-                               embed_dim=config['SWINUNET']['EMB_DIM'],
-                               depths=config['SWINUNET']['DEPTH_EN'],
-                               num_heads=config['SWINUNET']['HEAD_NUM'],
-                               window_size=config['SWINUNET']['WIN_SIZE'],
-                               mlp_ratio=config['SWINUNET']['MLP_RATIO'],
-                               qkv_bias=config['SWINUNET']['QKV_BIAS'],
-                               qk_scale=config['SWINUNET']['QK_SCALE'],
-                               drop_rate=config['SWINUNET']['DROP_RATE'],
-                               drop_path_rate=config['SWINUNET']['DROP_PATH_RATE'],
-                               ape=config['SWINUNET']['APE'],
-                               patch_norm=config['SWINUNET']['PATCH_NORM'],
-                               use_checkpoint=config['SWINUNET']['USE_CHECKPOINTS'])
-
-    def forward(self, x):
-        if x.size()[1] == 1:
-            x = x.repeat(1, 3, 1, 1)
-        logits = self.swin_unet(x)
-        return logits

spaces/7hao/bingo/src/state/index.ts

@@ -1,118 +0,0 @@
-import { BingWebBot } from '@/lib/bots/bing'
-import { BingConversationStyle, ChatMessageModel, BotId } from '@/lib/bots/bing/types'
-import { nanoid } from '@/lib/utils'
-import { atom } from 'jotai'
-import { atomWithImmer } from 'jotai-immer'
-import { atomWithStorage } from 'jotai/utils'
-import { atomFamily } from 'jotai/utils'
-import { atomWithHash, atomWithLocation } from 'jotai-location'
-
-const initialMessages: ChatMessageModel[] = [
-  { author: 'system', text: 'conversation between user and robot', id: '1' },
-  { author: 'user', text: '销量最高的 3 种宠物吸尘器有哪些优点和缺点?  ', id: '2' },
-  {
-    author: 'bot', text: `
-您好，这是必应。根据网上的搜索结果，我为您找到了以下三款销量最高的宠物吸尘器，以及它们的优点和缺点：
-
-- **戴森Dyson V10轻量版 Digital Slim Fluffy无线吸尘器**[^1^] [^3^]：这款吸尘器专为宠物家庭设计，拥有强大吸力和多功能吸头，能够有效清除宠物毛发和灰尘。
-  - 优点：轻便易用，续航时间长，过滤系统先进，能够有效去除过敏原；
-  - 缺点：价格较高，噪音较大，需要定期清洁滤网。
-- **飞利浦FC6908/82（W7）无线吸尘器**[^2^] [^4^]：这是一款手持式干吸无线吸尘器，专门为宠物家庭设计。它具有75分钟的超高续航，适合大户型；除螨涡轮刷，可以深度清洁床单被罩，免受螨虫侵害；吸拖一体设计，280ml大水箱，还可以往水箱里加入清洁剂。
-  - 优点：清洁性能强劲，操作方便，适用多种场景；
-  - 缺点：噪音较大，达到84dB（A）；尘杯容量较小，只有0.6L；充电时长较长，需要5小时。
-- **必胜（Bissell） 宠物吸尘器**[^2^]：这是一款便携式手持真空吸尘器，专为清理宠物毛发而设计。它配备特殊的橡胶喷嘴和软毛刷头，可以轻松拾取宠物毛发和灰尘；几乎静音运行。
-  - 优点：轻巧易用，重量只有1.36kg；电池可充电可更换；
-  - 缺点：续航时间不稳定，在15-30分钟之间浮动；吸力不够强劲，在地毯或沙发上可能效果不佳；没有过滤系统或过滤网。
-
-希望这些信息对您有所帮助。如果您还有其他问题，请随时提问。😊
-  `, id: '3' },
-  { author: 'user', text: '今天的新闻', id: '4' },
-  {
-    author: 'bot', text: `你好，这是Bing。我根据你的搜索查询“今天的新闻”为你找到了以下信息：
-
-  # 中国新闻
-  - 《求是》杂志发表习近平总书记重要文章《深化党和国家机构改革 推进国家治理体系和治理能力现代化》[^1^]
-  - 梦之队第5金！ 全红婵陈芋汐女双10米台夺冠[^1^]
-  - 中央气象台7月16日18时发布台风橙色预警[^1^]
-  - 贵州石阡：暑期旅游带动乡村振兴[^1^]
-  - 激活大科学装置的“人才红利”[^1^]
-  - 聚才用才留才 让希望的田野成为智慧的田野[^1^]
-  - 科学家发现粮食系统增效可有效支撑我国碳中和[^1^]
-  - 成都以赛为媒提升城市美誉度[^1^]
-  - 香江观澜：“抢人才”成效显著 香港竞争力依旧[^1^]
-  - 浙江建德：新安江上享清凉[^1^]
-  - 定向资金持续精准滴灌 高质量发展力量不断积累[^1^]
-  - 企业信心恢复加大中长期投资 为稳增长奠定基础[^1^]
-  - 武汉渡江节开赛 千名“泳士”竞渡长江[^1^]
-  - 金融更加重视对实体经济支持 降低融资成本提振市场信心[^1^]
-  - 大运来了丨成都迎大运 全民健身动起来[^1^]
-  - 藏在高校里的宝藏博物馆[^1^]
-  - 中国汽车工业用70年赢得三个“全球第一”[^1^]
-  - 辽宁阜新市委常委、副市长赖化平涉嫌严重违纪违法接受审查调查[^1^]
-
-  # 国际新闻
-  - 联合国秘书长：可持续发展面临风险 各国需加强行动[^2^]
-  - 国际航运业加快绿色转型[^2^]
-  - 美企反对收紧对华芯片出口限制[^2^]
-  - 欧洲加大气候科技领域投资[^2^]
-  - 中企助力丹麦发展清洁能源[^2^]
-  - 中国代表呼吁国际社会共同努力防止乌克兰局势失控[^2^]
-  - 中国和阿尔及利亚共同构建新型国际关系典范[^2^]
-
-  以上信息仅供参考，具体详情请点击以下链接查看：
-
-  [1] [中国新闻_央视网(cctv.com)](https://news.cctv.com/china/)
-  [2] [人民网_网上的人民日报](http://www.people.com.cn/)`, id: '5' },
-  { author: 'user', text: '写一个快排', id: '6' },
-  { author: 'bot', text: "你好，这是Bing。我可以帮你用python写一个快排。快速排序是一种基于分治思想的排序算法，它的基本思想是：从待排序的数组中选择一个基准元素，将数组分为两个子数组，使得左边的子数组中的元素都小于或等于基准元素，右边的子数组中的元素都大于或等于基准元素，然后对两个子数组递归地进行快速排序，最后合并结果。下面是用python实现的快速排序的代码：\n\n```python\n# 定义一个函数，用��交换数组中的两个元素\ndef swap(arr, i, j):\n    temp = arr[i]\n    arr[i] = arr[j]\n    arr[j] = temp\n\n# 定义一个函数，用于对数组的一段区间进行划分\ndef partition(arr, low, high):\n    # 选择最右边的元素作为基准元素\n    pivot = arr[high]\n    # 初始化一个指针，指向左边区间的最后一个位置\n    i = low - 1\n    # 遍历左边区间中的每个元素\n    for j in range(low, high):\n        # 如果当前元素小于或等于基准元素\n        if arr[j] <= pivot:\n            # 将指针右移一位\n            i += 1\n            # 将指针所指的元素与当前元素交换\n            swap(arr, i, j)\n    # 将基准元素与指针右边的第一个元素交换\n    swap(arr, i + 1, high)\n    # 返回基准元素的最终位置\n    return i + 1\n\n# 定义一个函数，用于对数组进行快速排序\ndef quick_sort(arr, low, high):\n    # 如果区间长度大于1\n    if low < high:\n        # 对区间进行划分，得到基准元素的位置\n        p = partition(arr, low, high)\n        # 对左边子区间进行快速排序\n        quick_sort(arr, low, p - 1)\n        # 对右边子区间进行快速排序\n        quick_sort(arr, p + 1, high)\n\n# 测试代码\narr = [5, 3, 7, 2, 9, 1, 4, 6, 8]\nprint(\"原始数组：\", arr)\nquick_sort(arr, 0, len(arr) - 1)\nprint(\"排序后的数组：\", arr)\n```", id: '7' },
-  {
-    author: 'bot', text: "好的，我会尝试画一只猫。\n > ![一只猫](https://tse2.mm.bing.net/th/id/OIG.jz34V0PNVkPC229h9spV?w=270&h=270&c=6&r=0&o=5&dpr=1.5&pid=ImgGn)![一只猫](https://tse1.mm.bing.net/th/id/OIG.6g7d.XLZMP_iwAByLhvo?w=270&h=270&c=6&r=0&o=5&dpr=1.5&pid=ImgGn)![一只猫](https://tse2.mm.bing.net/th/id/OIG.iAxF4ekekYn7sZw9SmU6?w=270&h=270&c=6&r=0&o=5&dpr=1.5&pid=ImgGn)![一只猫](https://tse4.mm.bing.net/th/id/OIG.qDnzeSKzUCeJcrBqc5mX?w=270&h=270&c=6&r=0&o=5&dpr=1.5&pid=ImgGn)",
-    id: '8'
-  }
-]
-
-export const GreetMessages = [
-  '谢谢你! 知道你什么时候准备好继续前进总是很有帮助的。我现在能为你回答什么问题?',
-  '重新开始总是很棒。问我任何问题!',
-  '当然，我很乐意重新开始。我现在可以为你提供哪些帮助?',
-  '当然，我已准备好进行新的挑战。我现在可以为你做什么?',
-  '很好，让我们来更改主题。你在想什么?',
-  '不用担心，我很高兴尝试一些新内容。我现在可以为你回答什么问题?',
-  '好的，我准备好了！感谢重置。我们应该了解哪些内容？',
-  '感谢刷新！你有新的话题吗？',
-  '明白了，让我们重新开始。接下来应该讨论什么？',
-  '下一步！我可以为你做什么？',
-  '好的，我已准备好新话题。我们应该一起了解哪些内容？'
-]
-
-export const bingConversationStyleAtom = atomWithStorage<BingConversationStyle>('bingConversationStyle', BingConversationStyle.Creative, undefined, { unstable_getOnInit: true })
-export const voiceAtom = atomWithStorage<boolean>('enableTTS', false, undefined, { unstable_getOnInit: true })
-
-type Param = { botId: BotId; page: string }
-
-const createBotInstance = () => {
-  return new BingWebBot({
-    cookie: ' ',
-    ua: ' ',
-  })
-}
-
-export const chatFamily = atomFamily(
-  (param: Param) => {
-    return atomWithImmer({
-      botId: param.botId,
-      bot: createBotInstance(),
-      messages: [] as ChatMessageModel[],
-      generatingMessageId: '',
-      abortController: undefined as AbortController | undefined,
-      conversationId: nanoid(),
-    })
-  },
-  (a, b) => a.botId === b.botId && a.page === b.page,
-)
-
-export const hashAtom = atomWithHash('dialog', '')
-
-export const locationAtom = atomWithLocation()
-
-export const voiceListenAtom = atom(false)

spaces/AFlac199/openai-reverse-proxy/README.md

@@ -1,10 +0,0 @@
----
-title: Openai Reverse Proxy
-emoji: 🐨
-colorFrom: blue
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AIConsultant/MusicGen/audiocraft/utils/samples/manager.py

@@ -1,386 +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.
-
-"""
-API that can manage the storage and retrieval of generated samples produced by experiments.
-
-It offers the following benefits:
-* Samples are stored in a consistent way across epoch
-* Metadata about the samples can be stored and retrieved
-* Can retrieve audio
-* Identifiers are reliable and deterministic for prompted and conditioned samples
-* Can request the samples for multiple XPs, grouped by sample identifier
-* For no-input samples (not prompt and no conditions), samples across XPs are matched
-  by sorting their identifiers
-"""
-
-from concurrent.futures import ThreadPoolExecutor
-from dataclasses import asdict, dataclass
-from functools import lru_cache
-import hashlib
-import json
-import logging
-from pathlib import Path
-import re
-import typing as tp
-import unicodedata
-import uuid
-
-import dora
-import torch
-
-from ...data.audio import audio_read, audio_write
-
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ReferenceSample:
-    id: str
-    path: str
-    duration: float
-
-
-@dataclass
-class Sample:
-    id: str
-    path: str
-    epoch: int
-    duration: float
-    conditioning: tp.Optional[tp.Dict[str, tp.Any]]
-    prompt: tp.Optional[ReferenceSample]
-    reference: tp.Optional[ReferenceSample]
-    generation_args: tp.Optional[tp.Dict[str, tp.Any]]
-
-    def __hash__(self):
-        return hash(self.id)
-
-    def audio(self) -> tp.Tuple[torch.Tensor, int]:
-        return audio_read(self.path)
-
-    def audio_prompt(self) -> tp.Optional[tp.Tuple[torch.Tensor, int]]:
-        return audio_read(self.prompt.path) if self.prompt is not None else None
-
-    def audio_reference(self) -> tp.Optional[tp.Tuple[torch.Tensor, int]]:
-        return audio_read(self.reference.path) if self.reference is not None else None
-
-
-class SampleManager:
-    """Audio samples IO handling within a given dora xp.
-
-    The sample manager handles the dumping and loading logic for generated and
-    references samples across epochs for a given xp, providing a simple API to
-    store, retrieve and compare audio samples.
-
-    Args:
-        xp (dora.XP): Dora experiment object. The XP contains information on the XP folder
-            where all outputs are stored and the configuration of the experiment,
-            which is useful to retrieve audio-related parameters.
-        map_reference_to_sample_id (bool): Whether to use the sample_id for all reference samples
-            instead of generating a dedicated hash id. This is useful to allow easier comparison
-            with ground truth sample from the files directly without having to read the JSON metadata
-            to do the mapping (at the cost of potentially dumping duplicate prompts/references
-            depending on the task).
-    """
-    def __init__(self, xp: dora.XP, map_reference_to_sample_id: bool = False):
-        self.xp = xp
-        self.base_folder: Path = xp.folder / xp.cfg.generate.path
-        self.reference_folder = self.base_folder / 'reference'
-        self.map_reference_to_sample_id = map_reference_to_sample_id
-        self.samples: tp.List[Sample] = []
-        self._load_samples()
-
-    @property
-    def latest_epoch(self):
-        """Latest epoch across all samples."""
-        return max(self.samples, key=lambda x: x.epoch).epoch if self.samples else 0
-
-    def _load_samples(self):
-        """Scan the sample folder and load existing samples."""
-        jsons = self.base_folder.glob('**/*.json')
-        with ThreadPoolExecutor(6) as pool:
-            self.samples = list(pool.map(self._load_sample, jsons))
-
-    @staticmethod
-    @lru_cache(2**26)
-    def _load_sample(json_file: Path) -> Sample:
-        with open(json_file, 'r') as f:
-            data: tp.Dict[str, tp.Any] = json.load(f)
-        # fetch prompt data
-        prompt_data = data.get('prompt')
-        prompt = ReferenceSample(id=prompt_data['id'], path=prompt_data['path'],
-                                 duration=prompt_data['duration']) if prompt_data else None
-        # fetch reference data
-        reference_data = data.get('reference')
-        reference = ReferenceSample(id=reference_data['id'], path=reference_data['path'],
-                                    duration=reference_data['duration']) if reference_data else None
-        # build sample object
-        return Sample(id=data['id'], path=data['path'], epoch=data['epoch'], duration=data['duration'],
-                      prompt=prompt, conditioning=data.get('conditioning'), reference=reference,
-                      generation_args=data.get('generation_args'))
-
-    def _init_hash(self):
-        return hashlib.sha1()
-
-    def _get_tensor_id(self, tensor: torch.Tensor) -> str:
-        hash_id = self._init_hash()
-        hash_id.update(tensor.numpy().data)
-        return hash_id.hexdigest()
-
-    def _get_sample_id(self, index: int, prompt_wav: tp.Optional[torch.Tensor],
-                       conditions: tp.Optional[tp.Dict[str, str]]) -> str:
-        """Computes an id for a sample given its input data.
-        This id is deterministic if prompt and/or conditions are provided by using a sha1 hash on the input.
-        Otherwise, a random id of the form "noinput_{uuid4().hex}" is returned.
-
-        Args:
-            index (int): Batch index, Helpful to differentiate samples from the same batch.
-            prompt_wav (torch.Tensor): Prompt used during generation.
-            conditions (dict[str, str]): Conditioning used during generation.
-        """
-        # For totally unconditioned generations we will just use a random UUID.
-        # The function get_samples_for_xps will do a simple ordered match with a custom key.
-        if prompt_wav is None and not conditions:
-            return f"noinput_{uuid.uuid4().hex}"
-
-        # Human readable portion
-        hr_label = ""
-        # Create a deterministic id using hashing
-        hash_id = self._init_hash()
-        hash_id.update(f"{index}".encode())
-        if prompt_wav is not None:
-            hash_id.update(prompt_wav.numpy().data)
-            hr_label += "_prompted"
-        else:
-            hr_label += "_unprompted"
-        if conditions:
-            encoded_json = json.dumps(conditions, sort_keys=True).encode()
-            hash_id.update(encoded_json)
-            cond_str = "-".join([f"{key}={slugify(value)}"
-                                 for key, value in sorted(conditions.items())])
-            cond_str = cond_str[:100]  # some raw text might be too long to be a valid filename
-            cond_str = cond_str if len(cond_str) > 0 else "unconditioned"
-            hr_label += f"_{cond_str}"
-        else:
-            hr_label += "_unconditioned"
-
-        return hash_id.hexdigest() + hr_label
-
-    def _store_audio(self, wav: torch.Tensor, stem_path: Path, overwrite: bool = False) -> Path:
-        """Stores the audio with the given stem path using the XP's configuration.
-
-        Args:
-            wav (torch.Tensor): Audio to store.
-            stem_path (Path): Path in sample output directory with file stem to use.
-            overwrite (bool): When False (default), skips storing an existing audio file.
-        Returns:
-            Path: The path at which the audio is stored.
-        """
-        existing_paths = [
-            path for path in stem_path.parent.glob(stem_path.stem + '.*')
-            if path.suffix != '.json'
-        ]
-        exists = len(existing_paths) > 0
-        if exists and overwrite:
-            logger.warning(f"Overwriting existing audio file with stem path {stem_path}")
-        elif exists:
-            return existing_paths[0]
-
-        audio_path = audio_write(stem_path, wav, **self.xp.cfg.generate.audio)
-        return audio_path
-
-    def add_sample(self, sample_wav: torch.Tensor, epoch: int, index: int = 0,
-                   conditions: tp.Optional[tp.Dict[str, str]] = None, prompt_wav: tp.Optional[torch.Tensor] = None,
-                   ground_truth_wav: tp.Optional[torch.Tensor] = None,
-                   generation_args: tp.Optional[tp.Dict[str, tp.Any]] = None) -> Sample:
-        """Adds a single sample.
-        The sample is stored in the XP's sample output directory, under a corresponding epoch folder.
-        Each sample is assigned an id which is computed using the input data. In addition to the
-        sample itself, a json file containing associated metadata is stored next to it.
-
-        Args:
-            sample_wav (torch.Tensor): sample audio to store. Tensor of shape [channels, shape].
-            epoch (int): current training epoch.
-            index (int): helpful to differentiate samples from the same batch.
-            conditions (dict[str, str], optional): conditioning used during generation.
-            prompt_wav (torch.Tensor, optional): prompt used during generation. Tensor of shape [channels, shape].
-            ground_truth_wav (torch.Tensor, optional): reference audio where prompt was extracted from.
-                Tensor of shape [channels, shape].
-            generation_args (dict[str, any], optional): dictionary of other arguments used during generation.
-        Returns:
-            Sample: The saved sample.
-        """
-        sample_id = self._get_sample_id(index, prompt_wav, conditions)
-        reuse_id = self.map_reference_to_sample_id
-        prompt, ground_truth = None, None
-        if prompt_wav is not None:
-            prompt_id = sample_id if reuse_id else self._get_tensor_id(prompt_wav.sum(0, keepdim=True))
-            prompt_duration = prompt_wav.shape[-1] / self.xp.cfg.sample_rate
-            prompt_path = self._store_audio(prompt_wav, self.base_folder / str(epoch) / 'prompt' / prompt_id)
-            prompt = ReferenceSample(prompt_id, str(prompt_path), prompt_duration)
-        if ground_truth_wav is not None:
-            ground_truth_id = sample_id if reuse_id else self._get_tensor_id(ground_truth_wav.sum(0, keepdim=True))
-            ground_truth_duration = ground_truth_wav.shape[-1] / self.xp.cfg.sample_rate
-            ground_truth_path = self._store_audio(ground_truth_wav, self.base_folder / 'reference' / ground_truth_id)
-            ground_truth = ReferenceSample(ground_truth_id, str(ground_truth_path), ground_truth_duration)
-        sample_path = self._store_audio(sample_wav, self.base_folder / str(epoch) / sample_id, overwrite=True)
-        duration = sample_wav.shape[-1] / self.xp.cfg.sample_rate
-        sample = Sample(sample_id, str(sample_path), epoch, duration, conditions, prompt, ground_truth, generation_args)
-        self.samples.append(sample)
-        with open(sample_path.with_suffix('.json'), 'w') as f:
-            json.dump(asdict(sample), f, indent=2)
-        return sample
-
-    def add_samples(self, samples_wavs: torch.Tensor, epoch: int,
-                    conditioning: tp.Optional[tp.List[tp.Dict[str, tp.Any]]] = None,
-                    prompt_wavs: tp.Optional[torch.Tensor] = None,
-                    ground_truth_wavs: tp.Optional[torch.Tensor] = None,
-                    generation_args: tp.Optional[tp.Dict[str, tp.Any]] = None) -> tp.List[Sample]:
-        """Adds a batch of samples.
-        The samples are stored in the XP's sample output directory, under a corresponding
-        epoch folder. Each sample is assigned an id which is computed using the input data and their batch index.
-        In addition to the sample itself, a json file containing associated metadata is stored next to it.
-
-        Args:
-            sample_wavs (torch.Tensor): Batch of audio wavs to store. Tensor of shape [batch_size, channels, shape].
-            epoch (int): Current training epoch.
-            conditioning (list of dict[str, str], optional): List of conditions used during generation,
-                one per sample in the batch.
-            prompt_wavs (torch.Tensor, optional): Prompts used during generation. Tensor of shape
-                [batch_size, channels, shape].
-            ground_truth_wav (torch.Tensor, optional): Reference audio where prompts were extracted from.
-                Tensor of shape [batch_size, channels, shape].
-            generation_args (dict[str, Any], optional): Dictionary of other arguments used during generation.
-        Returns:
-            samples (list of Sample): The saved audio samples with prompts, ground truth and metadata.
-        """
-        samples = []
-        for idx, wav in enumerate(samples_wavs):
-            prompt_wav = prompt_wavs[idx] if prompt_wavs is not None else None
-            gt_wav = ground_truth_wavs[idx] if ground_truth_wavs is not None else None
-            conditions = conditioning[idx] if conditioning is not None else None
-            samples.append(self.add_sample(wav, epoch, idx, conditions, prompt_wav, gt_wav, generation_args))
-        return samples
-
-    def get_samples(self, epoch: int = -1, max_epoch: int = -1, exclude_prompted: bool = False,
-                    exclude_unprompted: bool = False, exclude_conditioned: bool = False,
-                    exclude_unconditioned: bool = False) -> tp.Set[Sample]:
-        """Returns a set of samples for this XP. Optionally, you can filter which samples to obtain.
-        Please note that existing samples are loaded during the manager's initialization, and added samples through this
-        manager are also tracked. Any other external changes are not tracked automatically, so creating a new manager
-        is the only way detect them.
-
-        Args:
-            epoch (int): If provided, only return samples corresponding to this epoch.
-            max_epoch (int): If provided, only return samples corresponding to the latest epoch that is <= max_epoch.
-            exclude_prompted (bool): If True, does not include samples that used a prompt.
-            exclude_unprompted (bool): If True, does not include samples that did not use a prompt.
-            exclude_conditioned (bool): If True, excludes samples that used conditioning.
-            exclude_unconditioned (bool): If True, excludes samples that did not use conditioning.
-        Returns:
-            Samples (set of Sample): The retrieved samples matching the provided filters.
-        """
-        if max_epoch >= 0:
-            samples_epoch = max(sample.epoch for sample in self.samples if sample.epoch <= max_epoch)
-        else:
-            samples_epoch = self.latest_epoch if epoch < 0 else epoch
-        samples = {
-            sample
-            for sample in self.samples
-            if (
-                (sample.epoch == samples_epoch) and
-                (not exclude_prompted or sample.prompt is None) and
-                (not exclude_unprompted or sample.prompt is not None) and
-                (not exclude_conditioned or not sample.conditioning) and
-                (not exclude_unconditioned or sample.conditioning)
-            )
-        }
-        return samples
-
-
-def slugify(value: tp.Any, allow_unicode: bool = False):
-    """Process string for safer file naming.
-
-    Taken from https://github.com/django/django/blob/master/django/utils/text.py
-
-    Convert to ASCII if 'allow_unicode' is False. Convert spaces or repeated
-    dashes to single dashes. Remove characters that aren't alphanumerics,
-    underscores, or hyphens. Convert to lowercase. Also strip leading and
-    trailing whitespace, dashes, and underscores.
-    """
-    value = str(value)
-    if allow_unicode:
-        value = unicodedata.normalize("NFKC", value)
-    else:
-        value = (
-            unicodedata.normalize("NFKD", value)
-            .encode("ascii", "ignore")
-            .decode("ascii")
-        )
-    value = re.sub(r"[^\w\s-]", "", value.lower())
-    return re.sub(r"[-\s]+", "-", value).strip("-_")
-
-
-def _match_stable_samples(samples_per_xp: tp.List[tp.Set[Sample]]) -> tp.Dict[str, tp.List[Sample]]:
-    # Create a dictionary of stable id -> sample per XP
-    stable_samples_per_xp = [{
-        sample.id: sample for sample in samples
-        if sample.prompt is not None or sample.conditioning
-    } for samples in samples_per_xp]
-    # Set of all stable ids
-    stable_ids = {id for samples in stable_samples_per_xp for id in samples.keys()}
-    # Dictionary of stable id -> list of samples. If an XP does not have it, assign None
-    stable_samples = {id: [xp.get(id) for xp in stable_samples_per_xp] for id in stable_ids}
-    # Filter out ids that contain None values (we only want matched samples after all)
-    # cast is necessary to avoid mypy linter errors.
-    return {id: tp.cast(tp.List[Sample], samples) for id, samples in stable_samples.items() if None not in samples}
-
-
-def _match_unstable_samples(samples_per_xp: tp.List[tp.Set[Sample]]) -> tp.Dict[str, tp.List[Sample]]:
-    # For unstable ids, we use a sorted list since we'll match them in order
-    unstable_samples_per_xp = [[
-        sample for sample in sorted(samples, key=lambda x: x.id)
-        if sample.prompt is None and not sample.conditioning
-    ] for samples in samples_per_xp]
-    # Trim samples per xp so all samples can have a match
-    min_len = min([len(samples) for samples in unstable_samples_per_xp])
-    unstable_samples_per_xp = [samples[:min_len] for samples in unstable_samples_per_xp]
-    # Dictionary of index -> list of matched samples
-    return {
-        f'noinput_{i}': [samples[i] for samples in unstable_samples_per_xp] for i in range(min_len)
-    }
-
-
-def get_samples_for_xps(xps: tp.List[dora.XP], **kwargs) -> tp.Dict[str, tp.List[Sample]]:
-    """Gets a dictionary of matched samples across the given XPs.
-    Each dictionary entry maps a sample id to a list of samples for that id. The number of samples per id
-    will always match the number of XPs provided and will correspond to each XP in the same order given.
-    In other words, only samples that can be match across all provided XPs will be returned
-    in order to satisfy this rule.
-
-    There are two types of ids that can be returned: stable and unstable.
-    * Stable IDs are deterministic ids that were computed by the SampleManager given a sample's inputs
-      (prompts/conditioning). This is why we can match them across XPs.
-    * Unstable IDs are of the form "noinput_{idx}" and are generated on-the-fly, in order to map samples
-      that used non-deterministic, random ids. This is the case for samples that did not use prompts or
-      conditioning for their generation. This function will sort these samples by their id and match them
-      by their index.
-
-    Args:
-        xps: a list of XPs to match samples from.
-        start_epoch (int): If provided, only return samples corresponding to this epoch or newer.
-        end_epoch (int): If provided, only return samples corresponding to this epoch or older.
-        exclude_prompted (bool): If True, does not include samples that used a prompt.
-        exclude_unprompted (bool): If True, does not include samples that did not use a prompt.
-        exclude_conditioned (bool): If True, excludes samples that used conditioning.
-        exclude_unconditioned (bool): If True, excludes samples that did not use conditioning.
-    """
-    managers = [SampleManager(xp) for xp in xps]
-    samples_per_xp = [manager.get_samples(**kwargs) for manager in managers]
-    stable_samples = _match_stable_samples(samples_per_xp)
-    unstable_samples = _match_unstable_samples(samples_per_xp)
-    return dict(stable_samples, **unstable_samples)

spaces/AIGC-Audio/AudioGPT/NeuralSeq/utils/os_utils.py

@@ -1,20 +0,0 @@
-import os
-import subprocess
-
-
-def link_file(from_file, to_file):
-    subprocess.check_call(
-        f'ln -s "`realpath --relative-to="{os.path.dirname(to_file)}" "{from_file}"`" "{to_file}"', shell=True)
-
-
-def move_file(from_file, to_file):
-    subprocess.check_call(f'mv "{from_file}" "{to_file}"', shell=True)
-
-
-def copy_file(from_file, to_file):
-    subprocess.check_call(f'cp -r "{from_file}" "{to_file}"', shell=True)
-
-
-def remove_file(*fns):
-    for f in fns:
-        subprocess.check_call(f'rm -rf "{f}"', shell=True)

spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/vocoder/parallel_wavegan/stft_loss.py

@@ -1,102 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright 2019 Tomoki Hayashi
-#  MIT License (https://opensource.org/licenses/MIT)
-
-"""STFT-based Loss modules."""
-import librosa
-import torch
-
-from text_to_speech.modules.vocoder.parallel_wavegan.losses import LogSTFTMagnitudeLoss, SpectralConvergengeLoss, stft
-
-
-class STFTLoss(torch.nn.Module):
-    """STFT loss module."""
-
-    def __init__(self, fft_size=1024, shift_size=120, win_length=600, window="hann_window",
-                 use_mel_loss=False):
-        """Initialize STFT loss module."""
-        super(STFTLoss, self).__init__()
-        self.fft_size = fft_size
-        self.shift_size = shift_size
-        self.win_length = win_length
-        self.window = getattr(torch, window)(win_length)
-        self.spectral_convergenge_loss = SpectralConvergengeLoss()
-        self.log_stft_magnitude_loss = LogSTFTMagnitudeLoss()
-        self.use_mel_loss = use_mel_loss
-        self.mel_basis = None
-
-    def forward(self, x, y):
-        """Calculate forward propagation.
-
-        Args:
-            x (Tensor): Predicted signal (B, T).
-            y (Tensor): Groundtruth signal (B, T).
-
-        Returns:
-            Tensor: Spectral convergence loss value.
-            Tensor: Log STFT magnitude loss value.
-
-        """
-        if self.window.device != x.device:
-            self.window = self.window.to(x.device)
-        x_mag = stft(x, self.fft_size, self.shift_size, self.win_length, self.window)
-        y_mag = stft(y, self.fft_size, self.shift_size, self.win_length, self.window)
-        if self.use_mel_loss:
-            if self.mel_basis is None:
-                self.mel_basis = torch.from_numpy(librosa.filters.mel(22050, self.fft_size, 80)).cuda().T
-            x_mag = x_mag @ self.mel_basis
-            y_mag = y_mag @ self.mel_basis
-
-        sc_loss = self.spectral_convergenge_loss(x_mag, y_mag)
-        mag_loss = self.log_stft_magnitude_loss(x_mag, y_mag)
-
-        return sc_loss, mag_loss
-
-
-class MultiResolutionSTFTLoss(torch.nn.Module):
-    """Multi resolution STFT loss module."""
-
-    def __init__(self,
-                 fft_sizes=[1024, 2048, 512],
-                 hop_sizes=[120, 240, 50],
-                 win_lengths=[600, 1200, 240],
-                 window="hann_window",
-                 use_mel_loss=False):
-        """Initialize Multi resolution STFT loss module.
-
-        Args:
-            fft_sizes (list): List of FFT sizes.
-            hop_sizes (list): List of hop sizes.
-            win_lengths (list): List of window lengths.
-            window (str): Window function type.
-
-        """
-        super(MultiResolutionSTFTLoss, self).__init__()
-        assert len(fft_sizes) == len(hop_sizes) == len(win_lengths)
-        self.stft_losses = torch.nn.ModuleList()
-        for fs, ss, wl in zip(fft_sizes, hop_sizes, win_lengths):
-            self.stft_losses += [STFTLoss(fs, ss, wl, window, use_mel_loss)]
-
-    def forward(self, x, y):
-        """Calculate forward propagation.
-
-        Args:
-            x (Tensor): Predicted signal (B, T).
-            y (Tensor): Groundtruth signal (B, T).
-
-        Returns:
-            Tensor: Multi resolution spectral convergence loss value.
-            Tensor: Multi resolution log STFT magnitude loss value.
-
-        """
-        sc_loss = 0.0
-        mag_loss = 0.0
-        for f in self.stft_losses:
-            sc_l, mag_l = f(x, y)
-            sc_loss += sc_l
-            mag_loss += mag_l
-        sc_loss /= len(self.stft_losses)
-        mag_loss /= len(self.stft_losses)
-
-        return sc_loss, mag_loss

spaces/AchyuthGamer/OpenGPT-Chat-UI/.svelte-kit/types/src/routes/conversation/$types.d.ts

@@ -1,8 +0,0 @@
-import type * as Kit from '@sveltejs/kit';
-
-type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
-type RouteParams = {  }
-type RouteId = '/conversation';
-
-export type RequestHandler = Kit.RequestHandler<RouteParams, RouteId>;
-export type RequestEvent = Kit.RequestEvent<RouteParams, RouteId>;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/circlemaskimage/Factory.js

@@ -1,13 +0,0 @@
-import CircleMaskImage from './CircleMaskImage.js';
-import ObjectFactory from '../ObjectFactory.js';
-import SetValue from '../../../plugins/utils/object/SetValue.js';
-
-ObjectFactory.register('circleMaskImage', function (x, y, key, frame, config) {
-    var gameObject = new CircleMaskImage(this.scene, x, y, key, frame, config);
-    this.scene.add.existing(gameObject);
-    return gameObject;
-});
-
-SetValue(window, 'RexPlugins.UI.CircleMaskImage', CircleMaskImage);
-
-export default CircleMaskImage;

spaces/AlekseyKorshuk/gai-project/app.py

@@ -1,13 +0,0 @@
-import gradio as gr
-
-from modules.about import render_about
-from modules.playground import render_playground
-
-with gr.Blocks() as demo:
-    with gr.Tabs():
-        with gr.TabItem("Playground"):
-            render_playground(demo)
-        with gr.TabItem("About"):
-            render_about()
-
-demo.queue(concurrency_count=100).launch()

spaces/AlekseyKorshuk/model-evaluation/models/base.py

@@ -1,51 +0,0 @@
-import os
-import requests
-import gradio as gr
-from conversation import Conversation
-
-
-class BaseModel:
-    name: str
-    endpoint: str
-    namespace: str
-    generation_params: dict
-
-    def __init__(self, name, endpoint, namespace, generation_params):
-        self.name = name
-        self.endpoint = endpoint
-        self.namespace = namespace
-        self.generation_params = generation_params
-
-    def generate_response(self, conversation, custom_generation_params=None):
-        prompt = self._get_prompt(conversation)
-        response = self._get_response(prompt, custom_generation_params)
-        return response
-
-    def _get_prompt(self, conversation: Conversation):
-        prompt = "\n".join(
-            [conversation.memory, conversation.prompt]
-        ).strip()
-        for message in conversation.messages:
-            prompt += f"\n{message['from'].strip()}: {message['value'].strip()}"
-        prompt += f"\n{conversation.bot_label}:"
-        return prompt
-
-    def _get_response(self, text, custom_generation_params):
-        api = str(os.environ.get("API_BASE_PATH")).replace("\{\}", "{}")
-        api = api.format(self.endpoint, self.namespace)
-        parameters = self.generation_params
-        if custom_generation_params is not None:
-            parameters.update(custom_generation_params)
-        payload = {'instances': [text], "parameters": parameters}
-        resp = requests.post(api, json=payload, timeout=600)
-        if resp.status_code != 200:
-            raise gr.Error(f"Endpoint returned code: {resp.status_code}. "
-                           f"Solution: "
-                           f"1. Scale-to-Zero enabled, so please wait for some minutes and try again. "
-                           f"2. Probably the response generated by the model is to big, try changing max_new_tokens. "
-                           f"3. If nothing helps — report the problem.")
-        predictions = resp.json()["predictions"]
-        if isinstance(predictions[0], str):
-            return predictions[0].strip()
-        predictions = sorted(predictions[0], key=lambda d: d['score'])
-        return predictions[-1]["text"].strip()

spaces/Alfasign/diffusers-gallery/README.md

@@ -1,14 +0,0 @@
----
-title: Diffusers Gallery
-emoji: 🖼️
-colorFrom: red
-colorTo: green
-sdk: static
-app_port: 8080
-fullWidth: true
-pinned: false
-license: mit
-duplicated_from: huggingface-projects/diffusers-gallery
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/text_to_image/train_text_to_image_flax.py

@@ -1,573 +0,0 @@
-import argparse
-import logging
-import math
-import os
-import random
-from pathlib import Path
-
-import jax
-import jax.numpy as jnp
-import numpy as np
-import optax
-import torch
-import torch.utils.checkpoint
-import transformers
-from datasets import load_dataset
-from flax import jax_utils
-from flax.training import train_state
-from flax.training.common_utils import shard
-from huggingface_hub import create_repo, upload_folder
-from torchvision import transforms
-from tqdm.auto import tqdm
-from transformers import CLIPImageProcessor, CLIPTokenizer, FlaxCLIPTextModel, set_seed
-
-from diffusers import (
-    FlaxAutoencoderKL,
-    FlaxDDPMScheduler,
-    FlaxPNDMScheduler,
-    FlaxStableDiffusionPipeline,
-    FlaxUNet2DConditionModel,
-)
-from diffusers.pipelines.stable_diffusion import FlaxStableDiffusionSafetyChecker
-from diffusers.utils import check_min_version
-
-
-# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
-check_min_version("0.19.0")
-
-logger = logging.getLogger(__name__)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Simple example of a training script.")
-    parser.add_argument(
-        "--pretrained_model_name_or_path",
-        type=str,
-        default=None,
-        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models.",
-    )
-    parser.add_argument(
-        "--revision",
-        type=str,
-        default=None,
-        required=False,
-        help="Revision of pretrained model identifier from huggingface.co/models.",
-    )
-    parser.add_argument(
-        "--dataset_name",
-        type=str,
-        default=None,
-        help=(
-            "The name of the Dataset (from the HuggingFace hub) to train on (could be your own, possibly private,"
-            " dataset). It can also be a path pointing to a local copy of a dataset in your filesystem,"
-            " or to a folder containing files that 🤗 Datasets can understand."
-        ),
-    )
-    parser.add_argument(
-        "--dataset_config_name",
-        type=str,
-        default=None,
-        help="The config of the Dataset, leave as None if there's only one config.",
-    )
-    parser.add_argument(
-        "--train_data_dir",
-        type=str,
-        default=None,
-        help=(
-            "A folder containing the training data. Folder contents must follow the structure described in"
-            " https://huggingface.co/docs/datasets/image_dataset#imagefolder. In particular, a `metadata.jsonl` file"
-            " must exist to provide the captions for the images. Ignored if `dataset_name` is specified."
-        ),
-    )
-    parser.add_argument(
-        "--image_column", type=str, default="image", help="The column of the dataset containing an image."
-    )
-    parser.add_argument(
-        "--caption_column",
-        type=str,
-        default="text",
-        help="The column of the dataset containing a caption or a list of captions.",
-    )
-    parser.add_argument(
-        "--max_train_samples",
-        type=int,
-        default=None,
-        help=(
-            "For debugging purposes or quicker training, truncate the number of training examples to this "
-            "value if set."
-        ),
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default="sd-model-finetuned",
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--cache_dir",
-        type=str,
-        default=None,
-        help="The directory where the downloaded models and datasets will be stored.",
-    )
-    parser.add_argument("--seed", type=int, default=0, help="A seed for reproducible training.")
-    parser.add_argument(
-        "--resolution",
-        type=int,
-        default=512,
-        help=(
-            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
-            " resolution"
-        ),
-    )
-    parser.add_argument(
-        "--center_crop",
-        default=False,
-        action="store_true",
-        help=(
-            "Whether to center crop the input images to the resolution. If not set, the images will be randomly"
-            " cropped. The images will be resized to the resolution first before cropping."
-        ),
-    )
-    parser.add_argument(
-        "--random_flip",
-        action="store_true",
-        help="whether to randomly flip images horizontally",
-    )
-    parser.add_argument(
-        "--train_batch_size", type=int, default=16, help="Batch size (per device) for the training dataloader."
-    )
-    parser.add_argument("--num_train_epochs", type=int, default=100)
-    parser.add_argument(
-        "--max_train_steps",
-        type=int,
-        default=None,
-        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
-    )
-    parser.add_argument(
-        "--learning_rate",
-        type=float,
-        default=1e-4,
-        help="Initial learning rate (after the potential warmup period) to use.",
-    )
-    parser.add_argument(
-        "--scale_lr",
-        action="store_true",
-        default=False,
-        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
-    )
-    parser.add_argument(
-        "--lr_scheduler",
-        type=str,
-        default="constant",
-        help=(
-            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
-            ' "constant", "constant_with_warmup"]'
-        ),
-    )
-    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
-    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
-    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
-    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
-    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
-    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
-    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
-    parser.add_argument(
-        "--hub_model_id",
-        type=str,
-        default=None,
-        help="The name of the repository to keep in sync with the local `output_dir`.",
-    )
-    parser.add_argument(
-        "--logging_dir",
-        type=str,
-        default="logs",
-        help=(
-            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
-            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
-        ),
-    )
-    parser.add_argument(
-        "--report_to",
-        type=str,
-        default="tensorboard",
-        help=(
-            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
-            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
-        ),
-    )
-    parser.add_argument(
-        "--mixed_precision",
-        type=str,
-        default="no",
-        choices=["no", "fp16", "bf16"],
-        help=(
-            "Whether to use mixed precision. Choose"
-            "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."
-            "and an Nvidia Ampere GPU."
-        ),
-    )
-    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
-
-    args = parser.parse_args()
-    env_local_rank = int(os.environ.get("LOCAL_RANK", -1))
-    if env_local_rank != -1 and env_local_rank != args.local_rank:
-        args.local_rank = env_local_rank
-
-    # Sanity checks
-    if args.dataset_name is None and args.train_data_dir is None:
-        raise ValueError("Need either a dataset name or a training folder.")
-
-    return args
-
-
-dataset_name_mapping = {
-    "lambdalabs/pokemon-blip-captions": ("image", "text"),
-}
-
-
-def get_params_to_save(params):
-    return jax.device_get(jax.tree_util.tree_map(lambda x: x[0], params))
-
-
-def main():
-    args = parse_args()
-
-    logging.basicConfig(
-        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
-        datefmt="%m/%d/%Y %H:%M:%S",
-        level=logging.INFO,
-    )
-    # Setup logging, we only want one process per machine to log things on the screen.
-    logger.setLevel(logging.INFO if jax.process_index() == 0 else logging.ERROR)
-    if jax.process_index() == 0:
-        transformers.utils.logging.set_verbosity_info()
-    else:
-        transformers.utils.logging.set_verbosity_error()
-
-    if args.seed is not None:
-        set_seed(args.seed)
-
-    # Handle the repository creation
-    if jax.process_index() == 0:
-        if args.output_dir is not None:
-            os.makedirs(args.output_dir, exist_ok=True)
-
-        if args.push_to_hub:
-            repo_id = create_repo(
-                repo_id=args.hub_model_id or Path(args.output_dir).name, exist_ok=True, token=args.hub_token
-            ).repo_id
-
-    # Get the datasets: you can either provide your own training and evaluation files (see below)
-    # or specify a Dataset from the hub (the dataset will be downloaded automatically from the datasets Hub).
-
-    # In distributed training, the load_dataset function guarantees that only one local process can concurrently
-    # download the dataset.
-    if args.dataset_name is not None:
-        # Downloading and loading a dataset from the hub.
-        dataset = load_dataset(
-            args.dataset_name,
-            args.dataset_config_name,
-            cache_dir=args.cache_dir,
-        )
-    else:
-        data_files = {}
-        if args.train_data_dir is not None:
-            data_files["train"] = os.path.join(args.train_data_dir, "**")
-        dataset = load_dataset(
-            "imagefolder",
-            data_files=data_files,
-            cache_dir=args.cache_dir,
-        )
-        # See more about loading custom images at
-        # https://huggingface.co/docs/datasets/v2.4.0/en/image_load#imagefolder
-
-    # Preprocessing the datasets.
-    # We need to tokenize inputs and targets.
-    column_names = dataset["train"].column_names
-
-    # 6. Get the column names for input/target.
-    dataset_columns = dataset_name_mapping.get(args.dataset_name, None)
-    if args.image_column is None:
-        image_column = dataset_columns[0] if dataset_columns is not None else column_names[0]
-    else:
-        image_column = args.image_column
-        if image_column not in column_names:
-            raise ValueError(
-                f"--image_column' value '{args.image_column}' needs to be one of: {', '.join(column_names)}"
-            )
-    if args.caption_column is None:
-        caption_column = dataset_columns[1] if dataset_columns is not None else column_names[1]
-    else:
-        caption_column = args.caption_column
-        if caption_column not in column_names:
-            raise ValueError(
-                f"--caption_column' value '{args.caption_column}' needs to be one of: {', '.join(column_names)}"
-            )
-
-    # Preprocessing the datasets.
-    # We need to tokenize input captions and transform the images.
-    def tokenize_captions(examples, is_train=True):
-        captions = []
-        for caption in examples[caption_column]:
-            if isinstance(caption, str):
-                captions.append(caption)
-            elif isinstance(caption, (list, np.ndarray)):
-                # take a random caption if there are multiple
-                captions.append(random.choice(caption) if is_train else caption[0])
-            else:
-                raise ValueError(
-                    f"Caption column `{caption_column}` should contain either strings or lists of strings."
-                )
-        inputs = tokenizer(captions, max_length=tokenizer.model_max_length, padding="do_not_pad", truncation=True)
-        input_ids = inputs.input_ids
-        return input_ids
-
-    train_transforms = transforms.Compose(
-        [
-            transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR),
-            transforms.CenterCrop(args.resolution) if args.center_crop else transforms.RandomCrop(args.resolution),
-            transforms.RandomHorizontalFlip() if args.random_flip else transforms.Lambda(lambda x: x),
-            transforms.ToTensor(),
-            transforms.Normalize([0.5], [0.5]),
-        ]
-    )
-
-    def preprocess_train(examples):
-        images = [image.convert("RGB") for image in examples[image_column]]
-        examples["pixel_values"] = [train_transforms(image) for image in images]
-        examples["input_ids"] = tokenize_captions(examples)
-
-        return examples
-
-    if args.max_train_samples is not None:
-        dataset["train"] = dataset["train"].shuffle(seed=args.seed).select(range(args.max_train_samples))
-        # Set the training transforms
-    train_dataset = dataset["train"].with_transform(preprocess_train)
-
-    def collate_fn(examples):
-        pixel_values = torch.stack([example["pixel_values"] for example in examples])
-        pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
-        input_ids = [example["input_ids"] for example in examples]
-
-        padded_tokens = tokenizer.pad(
-            {"input_ids": input_ids}, padding="max_length", max_length=tokenizer.model_max_length, return_tensors="pt"
-        )
-        batch = {
-            "pixel_values": pixel_values,
-            "input_ids": padded_tokens.input_ids,
-        }
-        batch = {k: v.numpy() for k, v in batch.items()}
-
-        return batch
-
-    total_train_batch_size = args.train_batch_size * jax.local_device_count()
-    train_dataloader = torch.utils.data.DataLoader(
-        train_dataset, shuffle=True, collate_fn=collate_fn, batch_size=total_train_batch_size, drop_last=True
-    )
-
-    weight_dtype = jnp.float32
-    if args.mixed_precision == "fp16":
-        weight_dtype = jnp.float16
-    elif args.mixed_precision == "bf16":
-        weight_dtype = jnp.bfloat16
-
-    # Load models and create wrapper for stable diffusion
-    tokenizer = CLIPTokenizer.from_pretrained(
-        args.pretrained_model_name_or_path, revision=args.revision, subfolder="tokenizer"
-    )
-    text_encoder = FlaxCLIPTextModel.from_pretrained(
-        args.pretrained_model_name_or_path, revision=args.revision, subfolder="text_encoder", dtype=weight_dtype
-    )
-    vae, vae_params = FlaxAutoencoderKL.from_pretrained(
-        args.pretrained_model_name_or_path, revision=args.revision, subfolder="vae", dtype=weight_dtype
-    )
-    unet, unet_params = FlaxUNet2DConditionModel.from_pretrained(
-        args.pretrained_model_name_or_path, revision=args.revision, subfolder="unet", dtype=weight_dtype
-    )
-
-    # Optimization
-    if args.scale_lr:
-        args.learning_rate = args.learning_rate * total_train_batch_size
-
-    constant_scheduler = optax.constant_schedule(args.learning_rate)
-
-    adamw = optax.adamw(
-        learning_rate=constant_scheduler,
-        b1=args.adam_beta1,
-        b2=args.adam_beta2,
-        eps=args.adam_epsilon,
-        weight_decay=args.adam_weight_decay,
-    )
-
-    optimizer = optax.chain(
-        optax.clip_by_global_norm(args.max_grad_norm),
-        adamw,
-    )
-
-    state = train_state.TrainState.create(apply_fn=unet.__call__, params=unet_params, tx=optimizer)
-
-    noise_scheduler = FlaxDDPMScheduler(
-        beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", num_train_timesteps=1000
-    )
-    noise_scheduler_state = noise_scheduler.create_state()
-
-    # Initialize our training
-    rng = jax.random.PRNGKey(args.seed)
-    train_rngs = jax.random.split(rng, jax.local_device_count())
-
-    def train_step(state, text_encoder_params, vae_params, batch, train_rng):
-        dropout_rng, sample_rng, new_train_rng = jax.random.split(train_rng, 3)
-
-        def compute_loss(params):
-            # Convert images to latent space
-            vae_outputs = vae.apply(
-                {"params": vae_params}, batch["pixel_values"], deterministic=True, method=vae.encode
-            )
-            latents = vae_outputs.latent_dist.sample(sample_rng)
-            # (NHWC) -> (NCHW)
-            latents = jnp.transpose(latents, (0, 3, 1, 2))
-            latents = latents * vae.config.scaling_factor
-
-            # Sample noise that we'll add to the latents
-            noise_rng, timestep_rng = jax.random.split(sample_rng)
-            noise = jax.random.normal(noise_rng, latents.shape)
-            # Sample a random timestep for each image
-            bsz = latents.shape[0]
-            timesteps = jax.random.randint(
-                timestep_rng,
-                (bsz,),
-                0,
-                noise_scheduler.config.num_train_timesteps,
-            )
-
-            # Add noise to the latents according to the noise magnitude at each timestep
-            # (this is the forward diffusion process)
-            noisy_latents = noise_scheduler.add_noise(noise_scheduler_state, latents, noise, timesteps)
-
-            # Get the text embedding for conditioning
-            encoder_hidden_states = text_encoder(
-                batch["input_ids"],
-                params=text_encoder_params,
-                train=False,
-            )[0]
-
-            # Predict the noise residual and compute loss
-            model_pred = unet.apply(
-                {"params": params}, noisy_latents, timesteps, encoder_hidden_states, train=True
-            ).sample
-
-            # Get the target for loss depending on the prediction type
-            if noise_scheduler.config.prediction_type == "epsilon":
-                target = noise
-            elif noise_scheduler.config.prediction_type == "v_prediction":
-                target = noise_scheduler.get_velocity(noise_scheduler_state, latents, noise, timesteps)
-            else:
-                raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
-
-            loss = (target - model_pred) ** 2
-            loss = loss.mean()
-
-            return loss
-
-        grad_fn = jax.value_and_grad(compute_loss)
-        loss, grad = grad_fn(state.params)
-        grad = jax.lax.pmean(grad, "batch")
-
-        new_state = state.apply_gradients(grads=grad)
-
-        metrics = {"loss": loss}
-        metrics = jax.lax.pmean(metrics, axis_name="batch")
-
-        return new_state, metrics, new_train_rng
-
-    # Create parallel version of the train step
-    p_train_step = jax.pmap(train_step, "batch", donate_argnums=(0,))
-
-    # Replicate the train state on each device
-    state = jax_utils.replicate(state)
-    text_encoder_params = jax_utils.replicate(text_encoder.params)
-    vae_params = jax_utils.replicate(vae_params)
-
-    # Train!
-    num_update_steps_per_epoch = math.ceil(len(train_dataloader))
-
-    # Scheduler and math around the number of training steps.
-    if args.max_train_steps is None:
-        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
-
-    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
-
-    logger.info("***** Running training *****")
-    logger.info(f"  Num examples = {len(train_dataset)}")
-    logger.info(f"  Num Epochs = {args.num_train_epochs}")
-    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
-    logger.info(f"  Total train batch size (w. parallel & distributed) = {total_train_batch_size}")
-    logger.info(f"  Total optimization steps = {args.max_train_steps}")
-
-    global_step = 0
-
-    epochs = tqdm(range(args.num_train_epochs), desc="Epoch ... ", position=0)
-    for epoch in epochs:
-        # ======================== Training ================================
-
-        train_metrics = []
-
-        steps_per_epoch = len(train_dataset) // total_train_batch_size
-        train_step_progress_bar = tqdm(total=steps_per_epoch, desc="Training...", position=1, leave=False)
-        # train
-        for batch in train_dataloader:
-            batch = shard(batch)
-            state, train_metric, train_rngs = p_train_step(state, text_encoder_params, vae_params, batch, train_rngs)
-            train_metrics.append(train_metric)
-
-            train_step_progress_bar.update(1)
-
-            global_step += 1
-            if global_step >= args.max_train_steps:
-                break
-
-        train_metric = jax_utils.unreplicate(train_metric)
-
-        train_step_progress_bar.close()
-        epochs.write(f"Epoch... ({epoch + 1}/{args.num_train_epochs} | Loss: {train_metric['loss']})")
-
-    # Create the pipeline using using the trained modules and save it.
-    if jax.process_index() == 0:
-        scheduler = FlaxPNDMScheduler(
-            beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", skip_prk_steps=True
-        )
-        safety_checker = FlaxStableDiffusionSafetyChecker.from_pretrained(
-            "CompVis/stable-diffusion-safety-checker", from_pt=True
-        )
-        pipeline = FlaxStableDiffusionPipeline(
-            text_encoder=text_encoder,
-            vae=vae,
-            unet=unet,
-            tokenizer=tokenizer,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=CLIPImageProcessor.from_pretrained("openai/clip-vit-base-patch32"),
-        )
-
-        pipeline.save_pretrained(
-            args.output_dir,
-            params={
-                "text_encoder": get_params_to_save(text_encoder_params),
-                "vae": get_params_to_save(vae_params),
-                "unet": get_params_to_save(state.params),
-                "safety_checker": safety_checker.params,
-            },
-        )
-
-        if args.push_to_hub:
-            upload_folder(
-                repo_id=repo_id,
-                folder_path=args.output_dir,
-                commit_message="End of training",
-                ignore_patterns=["step_*", "epoch_*"],
-            )
-
-
-if __name__ == "__main__":
-    main()

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_controlnet.py

@@ -1,28 +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.
-
-# NOTE: This file is deprecated and will be removed in a future version.
-# It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works
-from ...utils import deprecate
-from ..controlnet.multicontrolnet import MultiControlNetModel  # noqa: F401
-from ..controlnet.pipeline_controlnet import StableDiffusionControlNetPipeline  # noqa: F401
-
-
-deprecate(
-    "stable diffusion controlnet",
-    "0.22.0",
-    "Importing `StableDiffusionControlNetPipeline` or `MultiControlNetModel` from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet is deprecated. Please import `from diffusers import StableDiffusionControlNetPipeline` instead.",
-    standard_warn=False,
-    stacklevel=3,
-)

spaces/Andy1621/uniformer_image_detection/configs/_base_/models/mask_rcnn_r50_fpn.py

@@ -1,120 +0,0 @@
-# model settings
-model = dict(
-    type='MaskRCNN',
-    pretrained='torchvision://resnet50',
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        norm_eval=True,
-        style='pytorch'),
-    neck=dict(
-        type='FPN',
-        in_channels=[256, 512, 1024, 2048],
-        out_channels=256,
-        num_outs=5),
-    rpn_head=dict(
-        type='RPNHead',
-        in_channels=256,
-        feat_channels=256,
-        anchor_generator=dict(
-            type='AnchorGenerator',
-            scales=[8],
-            ratios=[0.5, 1.0, 2.0],
-            strides=[4, 8, 16, 32, 64]),
-        bbox_coder=dict(
-            type='DeltaXYWHBBoxCoder',
-            target_means=[.0, .0, .0, .0],
-            target_stds=[1.0, 1.0, 1.0, 1.0]),
-        loss_cls=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
-        loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
-    roi_head=dict(
-        type='StandardRoIHead',
-        bbox_roi_extractor=dict(
-            type='SingleRoIExtractor',
-            roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
-            out_channels=256,
-            featmap_strides=[4, 8, 16, 32]),
-        bbox_head=dict(
-            type='Shared2FCBBoxHead',
-            in_channels=256,
-            fc_out_channels=1024,
-            roi_feat_size=7,
-            num_classes=80,
-            bbox_coder=dict(
-                type='DeltaXYWHBBoxCoder',
-                target_means=[0., 0., 0., 0.],
-                target_stds=[0.1, 0.1, 0.2, 0.2]),
-            reg_class_agnostic=False,
-            loss_cls=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-            loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
-        mask_roi_extractor=dict(
-            type='SingleRoIExtractor',
-            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
-            out_channels=256,
-            featmap_strides=[4, 8, 16, 32]),
-        mask_head=dict(
-            type='FCNMaskHead',
-            num_convs=4,
-            in_channels=256,
-            conv_out_channels=256,
-            num_classes=80,
-            loss_mask=dict(
-                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
-    # model training and testing settings
-    train_cfg=dict(
-        rpn=dict(
-            assigner=dict(
-                type='MaxIoUAssigner',
-                pos_iou_thr=0.7,
-                neg_iou_thr=0.3,
-                min_pos_iou=0.3,
-                match_low_quality=True,
-                ignore_iof_thr=-1),
-            sampler=dict(
-                type='RandomSampler',
-                num=256,
-                pos_fraction=0.5,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=False),
-            allowed_border=-1,
-            pos_weight=-1,
-            debug=False),
-        rpn_proposal=dict(
-            nms_pre=2000,
-            max_per_img=1000,
-            nms=dict(type='nms', iou_threshold=0.7),
-            min_bbox_size=0),
-        rcnn=dict(
-            assigner=dict(
-                type='MaxIoUAssigner',
-                pos_iou_thr=0.5,
-                neg_iou_thr=0.5,
-                min_pos_iou=0.5,
-                match_low_quality=True,
-                ignore_iof_thr=-1),
-            sampler=dict(
-                type='RandomSampler',
-                num=512,
-                pos_fraction=0.25,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=True),
-            mask_size=28,
-            pos_weight=-1,
-            debug=False)),
-    test_cfg=dict(
-        rpn=dict(
-            nms_pre=1000,
-            max_per_img=1000,
-            nms=dict(type='nms', iou_threshold=0.7),
-            min_bbox_size=0),
-        rcnn=dict(
-            score_thr=0.05,
-            nms=dict(type='nms', iou_threshold=0.5),
-            max_per_img=100,
-            mask_thr_binary=0.5)))

spaces/Andy1621/uniformer_image_segmentation/configs/ann/ann_r50-d8_512x512_80k_ade20k.py

@@ -1,6 +0,0 @@
-_base_ = [
-    '../_base_/models/ann_r50-d8.py', '../_base_/datasets/ade20k.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
-    decode_head=dict(num_classes=150), auxiliary_head=dict(num_classes=150))

spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_d6_r50b-d16_769x769_80k_cityscapes.py

@@ -1,2 +0,0 @@
-_base_ = './fcn_d6_r50-d16_769x769_80k_cityscapes.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))

spaces/Andy1621/uniformer_image_segmentation/configs/pspnet/pspnet_r18b-d8_512x1024_80k_cityscapes.py

@@ -1,9 +0,0 @@
-_base_ = './pspnet_r50-d8_512x1024_80k_cityscapes.py'
-model = dict(
-    pretrained='torchvision://resnet18',
-    backbone=dict(type='ResNet', depth=18),
-    decode_head=dict(
-        in_channels=512,
-        channels=128,
-    ),
-    auxiliary_head=dict(in_channels=256, channels=64))

spaces/Anonymous-123/ImageNet-Editing/editing_diffusion/guided_diffusion/model-card.md

@@ -1,59 +0,0 @@
-# Overview
-
-These are diffusion models and noised image classifiers described in the paper [Diffusion Models Beat GANs on Image Synthesis](https://arxiv.org/abs/2105.05233).
-Included in this release are the following models:
-
- * Noisy ImageNet classifiers at resolutions 64x64, 128x128, 256x256, 512x512
- * A class-unconditional ImageNet diffusion model at resolution 256x256
- * Class conditional ImageNet diffusion models at 64x64, 128x128, 256x256, 512x512 resolutions
- * Class-conditional ImageNet upsampling diffusion models: 64x64->256x256, 128x128->512x512
- * Diffusion models trained on three LSUN classes at 256x256 resolution: cat, horse, bedroom
-
-# Datasets
-
-All of the models we are releasing were either trained on the [ILSVRC 2012 subset of ImageNet](http://www.image-net.org/challenges/LSVRC/2012/) or on single classes of [LSUN](https://arxiv.org/abs/1506.03365).
-Here, we describe characteristics of these datasets which impact model behavior:
-
-**LSUN**: This dataset was collected in 2015 using a combination of human labeling (from Amazon Mechanical Turk) and automated data labeling.
- * Each of the three classes we consider contain over a million images.
- * The dataset creators found that the label accuracy was roughly 90% across the entire LSUN dataset when measured by trained experts.
- * Images are scraped from the internet, and LSUN cat images in particular tend to often follow a “meme” format.
- * We found that there are occasionally humans in these photos, including faces, especially within the cat class.  
-
-**ILSVRC 2012 subset of ImageNet**: This dataset was curated in 2012 and consists of roughly one million images, each belonging to one of 1000 classes.
- * A large portion of the classes in this dataset are animals, plants, and other naturally-occurring objects.
- * Many images contain humans, although usually these humans aren’t reflected by the class label (e.g. the class “Tench, tinca tinca” contains many photos of people holding fish).
-
-# Performance
-
-These models are intended to generate samples consistent with their training distributions.
-This has been measured in terms of FID, Precision, and Recall.
-These metrics all rely on the representations of a [pre-trained Inception-V3 model](https://arxiv.org/abs/1512.00567),
-which was trained on ImageNet, and so is likely to focus more on the ImageNet classes (such as animals) than on other visual features (such as human faces).
-
-Qualitatively, the samples produced by these models often look highly realistic, especially when a diffusion model is combined with a noisy classifier.
-
-# Intended Use
-
-These models are intended to be used for research purposes only.
-In particular, they can be used as a baseline for generative modeling research, or as a starting point to build off of for such research.
-
-These models are not intended to be commercially deployed.
-Additionally, they are not intended to be used to create propaganda or offensive imagery.
-
-Before releasing these models, we probed their ability to ease the creation of targeted imagery, since doing so could be potentially harmful.
-We did this either by fine-tuning our ImageNet models on a target LSUN class, or through classifier guidance with publicly available [CLIP models](https://github.com/openai/CLIP).
- * To probe fine-tuning capabilities, we restricted our compute budget to roughly $100 and tried both standard fine-tuning,
-and a diffusion-specific approach where we train a specialized classifier for the LSUN class. The resulting FIDs were significantly worse than publicly available GAN models, indicating that fine-tuning an ImageNet diffusion model does not significantly lower the cost of image generation.
- * To probe guidance with CLIP, we tried two approaches for using pre-trained CLIP models for classifier guidance. Either we fed the noised image to CLIP directly and used its gradients, or we fed the diffusion model's denoised prediction to the CLIP model and differentiated through the whole process. In both cases, we found that it was difficult to recover information from the CLIP model, indicating that these diffusion models are unlikely to make it significantly easier to extract knowledge from CLIP compared to existing GAN models.
-
-# Limitations
-
-These models sometimes produce highly unrealistic outputs, particularly when generating images containing human faces.
-This may stem from ImageNet's emphasis on non-human objects.
-
-While classifier guidance can improve sample quality, it reduces diversity, resulting in some modes of the data distribution being underrepresented.
-This can potentially amplify existing biases in the training dataset such as gender and racial biases.
-
-Because ImageNet and LSUN contain images from the internet, they include photos of real people, and the model may have memorized some of the information contained in these photos.
-However, these images are already publicly available, and existing generative models trained on ImageNet have not demonstrated significant leakage of this information.

spaces/Anonymous-123/ImageNet-Editing/editing_diffusion/guided_diffusion/scripts/image_train.py

@@ -1,83 +0,0 @@
-"""
-Train a diffusion model on images.
-"""
-
-import argparse
-
-from guided_diffusion import dist_util, logger
-from guided_diffusion.image_datasets import load_data
-from guided_diffusion.resample import create_named_schedule_sampler
-from guided_diffusion.script_util import (
-    model_and_diffusion_defaults,
-    create_model_and_diffusion,
-    args_to_dict,
-    add_dict_to_argparser,
-)
-from guided_diffusion.train_util import TrainLoop
-
-
-def main():
-    args = create_argparser().parse_args()
-
-    dist_util.setup_dist()
-    logger.configure()
-
-    logger.log("creating model and diffusion...")
-    model, diffusion = create_model_and_diffusion(
-        **args_to_dict(args, model_and_diffusion_defaults().keys())
-    )
-    model.to(dist_util.dev())
-    schedule_sampler = create_named_schedule_sampler(args.schedule_sampler, diffusion)
-
-    logger.log("creating data loader...")
-    data = load_data(
-        data_dir=args.data_dir,
-        batch_size=args.batch_size,
-        image_size=args.image_size,
-        class_cond=args.class_cond,
-    )
-
-    logger.log("training...")
-    TrainLoop(
-        model=model,
-        diffusion=diffusion,
-        data=data,
-        batch_size=args.batch_size,
-        microbatch=args.microbatch,
-        lr=args.lr,
-        ema_rate=args.ema_rate,
-        log_interval=args.log_interval,
-        save_interval=args.save_interval,
-        resume_checkpoint=args.resume_checkpoint,
-        use_fp16=args.use_fp16,
-        fp16_scale_growth=args.fp16_scale_growth,
-        schedule_sampler=schedule_sampler,
-        weight_decay=args.weight_decay,
-        lr_anneal_steps=args.lr_anneal_steps,
-    ).run_loop()
-
-
-def create_argparser():
-    defaults = dict(
-        data_dir="",
-        schedule_sampler="uniform",
-        lr=1e-4,
-        weight_decay=0.0,
-        lr_anneal_steps=0,
-        batch_size=1,
-        microbatch=-1,  # -1 disables microbatches
-        ema_rate="0.9999",  # comma-separated list of EMA values
-        log_interval=10,
-        save_interval=10000,
-        resume_checkpoint="",
-        use_fp16=False,
-        fp16_scale_growth=1e-3,
-    )
-    defaults.update(model_and_diffusion_defaults())
-    parser = argparse.ArgumentParser()
-    add_dict_to_argparser(parser, defaults)
-    return parser
-
-
-if __name__ == "__main__":
-    main()

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmseg/core/seg/sampler/ohem_pixel_sampler.py

@@ -1,76 +0,0 @@
-import torch
-import torch.nn.functional as F
-
-from ..builder import PIXEL_SAMPLERS
-from .base_pixel_sampler import BasePixelSampler
-
-
-@PIXEL_SAMPLERS.register_module()
-class OHEMPixelSampler(BasePixelSampler):
-    """Online Hard Example Mining Sampler for segmentation.
-
-    Args:
-        context (nn.Module): The context of sampler, subclass of
-            :obj:`BaseDecodeHead`.
-        thresh (float, optional): The threshold for hard example selection.
-            Below which, are prediction with low confidence. If not
-            specified, the hard examples will be pixels of top ``min_kept``
-            loss. Default: None.
-        min_kept (int, optional): The minimum number of predictions to keep.
-            Default: 100000.
-    """
-
-    def __init__(self, context, thresh=None, min_kept=100000):
-        super(OHEMPixelSampler, self).__init__()
-        self.context = context
-        assert min_kept > 1
-        self.thresh = thresh
-        self.min_kept = min_kept
-
-    def sample(self, seg_logit, seg_label):
-        """Sample pixels that have high loss or with low prediction confidence.
-
-        Args:
-            seg_logit (torch.Tensor): segmentation logits, shape (N, C, H, W)
-            seg_label (torch.Tensor): segmentation label, shape (N, 1, H, W)
-
-        Returns:
-            torch.Tensor: segmentation weight, shape (N, H, W)
-        """
-        with torch.no_grad():
-            assert seg_logit.shape[2:] == seg_label.shape[2:]
-            assert seg_label.shape[1] == 1
-            seg_label = seg_label.squeeze(1).long()
-            batch_kept = self.min_kept * seg_label.size(0)
-            valid_mask = seg_label != self.context.ignore_index
-            seg_weight = seg_logit.new_zeros(size=seg_label.size())
-            valid_seg_weight = seg_weight[valid_mask]
-            if self.thresh is not None:
-                seg_prob = F.softmax(seg_logit, dim=1)
-
-                tmp_seg_label = seg_label.clone().unsqueeze(1)
-                tmp_seg_label[tmp_seg_label == self.context.ignore_index] = 0
-                seg_prob = seg_prob.gather(1, tmp_seg_label).squeeze(1)
-                sort_prob, sort_indices = seg_prob[valid_mask].sort()
-
-                if sort_prob.numel() > 0:
-                    min_threshold = sort_prob[min(batch_kept,
-                                                  sort_prob.numel() - 1)]
-                else:
-                    min_threshold = 0.0
-                threshold = max(min_threshold, self.thresh)
-                valid_seg_weight[seg_prob[valid_mask] < threshold] = 1.
-            else:
-                losses = self.context.loss_decode(
-                    seg_logit,
-                    seg_label,
-                    weight=None,
-                    ignore_index=self.context.ignore_index,
-                    reduction_override='none')
-                # faster than topk according to https://github.com/pytorch/pytorch/issues/22812  # noqa
-                _, sort_indices = losses[valid_mask].sort(descending=True)
-                valid_seg_weight[sort_indices[:batch_kept]] = 1.
-
-            seg_weight[valid_mask] = valid_seg_weight
-
-            return seg_weight

spaces/Anonymous-sub/Rerender/ControlNet/ldm/modules/attention.py

@@ -1,341 +0,0 @@
-from inspect import isfunction
-import math
-import torch
-import torch.nn.functional as F
-from torch import nn, einsum
-from einops import rearrange, repeat
-from typing import Optional, Any
-
-from ldm.modules.diffusionmodules.util import checkpoint
-
-
-try:
-    import xformers
-    import xformers.ops
-    XFORMERS_IS_AVAILBLE = True
-except:
-    XFORMERS_IS_AVAILBLE = False
-
-# CrossAttn precision handling
-import os
-_ATTN_PRECISION = os.environ.get("ATTN_PRECISION", "fp32")
-
-def exists(val):
-    return val is not None
-
-
-def uniq(arr):
-    return{el: True for el in arr}.keys()
-
-
-def default(val, d):
-    if exists(val):
-        return val
-    return d() if isfunction(d) else d
-
-
-def max_neg_value(t):
-    return -torch.finfo(t.dtype).max
-
-
-def init_(tensor):
-    dim = tensor.shape[-1]
-    std = 1 / math.sqrt(dim)
-    tensor.uniform_(-std, std)
-    return tensor
-
-
-# feedforward
-class GEGLU(nn.Module):
-    def __init__(self, dim_in, dim_out):
-        super().__init__()
-        self.proj = nn.Linear(dim_in, dim_out * 2)
-
-    def forward(self, x):
-        x, gate = self.proj(x).chunk(2, dim=-1)
-        return x * F.gelu(gate)
-
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
-        super().__init__()
-        inner_dim = int(dim * mult)
-        dim_out = default(dim_out, dim)
-        project_in = nn.Sequential(
-            nn.Linear(dim, inner_dim),
-            nn.GELU()
-        ) if not glu else GEGLU(dim, inner_dim)
-
-        self.net = nn.Sequential(
-            project_in,
-            nn.Dropout(dropout),
-            nn.Linear(inner_dim, dim_out)
-        )
-
-    def forward(self, x):
-        return self.net(x)
-
-
-def zero_module(module):
-    """
-    Zero out the parameters of a module and return it.
-    """
-    for p in module.parameters():
-        p.detach().zero_()
-    return module
-
-
-def Normalize(in_channels):
-    return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
-
-
-class SpatialSelfAttention(nn.Module):
-    def __init__(self, in_channels):
-        super().__init__()
-        self.in_channels = in_channels
-
-        self.norm = Normalize(in_channels)
-        self.q = torch.nn.Conv2d(in_channels,
-                                 in_channels,
-                                 kernel_size=1,
-                                 stride=1,
-                                 padding=0)
-        self.k = torch.nn.Conv2d(in_channels,
-                                 in_channels,
-                                 kernel_size=1,
-                                 stride=1,
-                                 padding=0)
-        self.v = torch.nn.Conv2d(in_channels,
-                                 in_channels,
-                                 kernel_size=1,
-                                 stride=1,
-                                 padding=0)
-        self.proj_out = torch.nn.Conv2d(in_channels,
-                                        in_channels,
-                                        kernel_size=1,
-                                        stride=1,
-                                        padding=0)
-
-    def forward(self, x):
-        h_ = x
-        h_ = self.norm(h_)
-        q = self.q(h_)
-        k = self.k(h_)
-        v = self.v(h_)
-
-        # compute attention
-        b,c,h,w = q.shape
-        q = rearrange(q, 'b c h w -> b (h w) c')
-        k = rearrange(k, 'b c h w -> b c (h w)')
-        w_ = torch.einsum('bij,bjk->bik', q, k)
-
-        w_ = w_ * (int(c)**(-0.5))
-        w_ = torch.nn.functional.softmax(w_, dim=2)
-
-        # attend to values
-        v = rearrange(v, 'b c h w -> b c (h w)')
-        w_ = rearrange(w_, 'b i j -> b j i')
-        h_ = torch.einsum('bij,bjk->bik', v, w_)
-        h_ = rearrange(h_, 'b c (h w) -> b c h w', h=h)
-        h_ = self.proj_out(h_)
-
-        return x+h_
-
-
-class CrossAttention(nn.Module):
-    def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.):
-        super().__init__()
-        inner_dim = dim_head * heads
-        context_dim = default(context_dim, query_dim)
-
-        self.scale = dim_head ** -0.5
-        self.heads = heads
-
-        self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
-        self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
-        self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
-
-        self.to_out = nn.Sequential(
-            nn.Linear(inner_dim, query_dim),
-            nn.Dropout(dropout)
-        )
-
-    def forward(self, x, context=None, mask=None):
-        h = self.heads
-
-        q = self.to_q(x)
-        context = default(context, x)
-        k = self.to_k(context)
-        v = self.to_v(context)
-
-        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
-
-        # force cast to fp32 to avoid overflowing
-        if _ATTN_PRECISION =="fp32":
-            with torch.autocast(enabled=False, device_type = 'cuda'):
-                q, k = q.float(), k.float()
-                sim = einsum('b i d, b j d -> b i j', q, k) * self.scale
-        else:
-            sim = einsum('b i d, b j d -> b i j', q, k) * self.scale
-        
-        del q, k
-    
-        if exists(mask):
-            mask = rearrange(mask, 'b ... -> b (...)')
-            max_neg_value = -torch.finfo(sim.dtype).max
-            mask = repeat(mask, 'b j -> (b h) () j', h=h)
-            sim.masked_fill_(~mask, max_neg_value)
-
-        # attention, what we cannot get enough of
-        sim = sim.softmax(dim=-1)
-
-        out = einsum('b i j, b j d -> b i d', sim, v)
-        out = rearrange(out, '(b h) n d -> b n (h d)', h=h)
-        return self.to_out(out)
-
-
-class MemoryEfficientCrossAttention(nn.Module):
-    # https://github.com/MatthieuTPHR/diffusers/blob/d80b531ff8060ec1ea982b65a1b8df70f73aa67c/src/diffusers/models/attention.py#L223
-    def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.0):
-        super().__init__()
-        print(f"Setting up {self.__class__.__name__}. Query dim is {query_dim}, context_dim is {context_dim} and using "
-              f"{heads} heads.")
-        inner_dim = dim_head * heads
-        context_dim = default(context_dim, query_dim)
-
-        self.heads = heads
-        self.dim_head = dim_head
-
-        self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
-        self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
-        self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
-
-        self.to_out = nn.Sequential(nn.Linear(inner_dim, query_dim), nn.Dropout(dropout))
-        self.attention_op: Optional[Any] = None
-
-    def forward(self, x, context=None, mask=None):
-        q = self.to_q(x)
-        context = default(context, x)
-        k = self.to_k(context)
-        v = self.to_v(context)
-
-        b, _, _ = q.shape
-        q, k, v = map(
-            lambda t: t.unsqueeze(3)
-            .reshape(b, t.shape[1], self.heads, self.dim_head)
-            .permute(0, 2, 1, 3)
-            .reshape(b * self.heads, t.shape[1], self.dim_head)
-            .contiguous(),
-            (q, k, v),
-        )
-
-        # actually compute the attention, what we cannot get enough of
-        out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=self.attention_op)
-
-        if exists(mask):
-            raise NotImplementedError
-        out = (
-            out.unsqueeze(0)
-            .reshape(b, self.heads, out.shape[1], self.dim_head)
-            .permute(0, 2, 1, 3)
-            .reshape(b, out.shape[1], self.heads * self.dim_head)
-        )
-        return self.to_out(out)
-
-
-class BasicTransformerBlock(nn.Module):
-    ATTENTION_MODES = {
-        "softmax": CrossAttention,  # vanilla attention
-        "softmax-xformers": MemoryEfficientCrossAttention
-    }
-    def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None, gated_ff=True, checkpoint=True,
-                 disable_self_attn=False):
-        super().__init__()
-        attn_mode = "softmax-xformers" if XFORMERS_IS_AVAILBLE else "softmax"
-        assert attn_mode in self.ATTENTION_MODES
-        attn_cls = self.ATTENTION_MODES[attn_mode]
-        self.disable_self_attn = disable_self_attn
-        self.attn1 = attn_cls(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout,
-                              context_dim=context_dim if self.disable_self_attn else None)  # is a self-attention if not self.disable_self_attn
-        self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff)
-        self.attn2 = attn_cls(query_dim=dim, context_dim=context_dim,
-                              heads=n_heads, dim_head=d_head, dropout=dropout)  # is self-attn if context is none
-        self.norm1 = nn.LayerNorm(dim)
-        self.norm2 = nn.LayerNorm(dim)
-        self.norm3 = nn.LayerNorm(dim)
-        self.checkpoint = checkpoint
-
-    def forward(self, x, context=None):
-        return checkpoint(self._forward, (x, context), self.parameters(), self.checkpoint)
-
-    def _forward(self, x, context=None):
-        x = self.attn1(self.norm1(x), context=context if self.disable_self_attn else None) + x
-        x = self.attn2(self.norm2(x), context=context) + x
-        x = self.ff(self.norm3(x)) + x
-        return x
-
-
-class SpatialTransformer(nn.Module):
-    """
-    Transformer block for image-like data.
-    First, project the input (aka embedding)
-    and reshape to b, t, d.
-    Then apply standard transformer action.
-    Finally, reshape to image
-    NEW: use_linear for more efficiency instead of the 1x1 convs
-    """
-    def __init__(self, in_channels, n_heads, d_head,
-                 depth=1, dropout=0., context_dim=None,
-                 disable_self_attn=False, use_linear=False,
-                 use_checkpoint=True):
-        super().__init__()
-        if exists(context_dim) and not isinstance(context_dim, list):
-            context_dim = [context_dim]
-        self.in_channels = in_channels
-        inner_dim = n_heads * d_head
-        self.norm = Normalize(in_channels)
-        if not use_linear:
-            self.proj_in = nn.Conv2d(in_channels,
-                                     inner_dim,
-                                     kernel_size=1,
-                                     stride=1,
-                                     padding=0)
-        else:
-            self.proj_in = nn.Linear(in_channels, inner_dim)
-
-        self.transformer_blocks = nn.ModuleList(
-            [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim[d],
-                                   disable_self_attn=disable_self_attn, checkpoint=use_checkpoint)
-                for d in range(depth)]
-        )
-        if not use_linear:
-            self.proj_out = zero_module(nn.Conv2d(inner_dim,
-                                                  in_channels,
-                                                  kernel_size=1,
-                                                  stride=1,
-                                                  padding=0))
-        else:
-            self.proj_out = zero_module(nn.Linear(in_channels, inner_dim))
-        self.use_linear = use_linear
-
-    def forward(self, x, context=None):
-        # note: if no context is given, cross-attention defaults to self-attention
-        if not isinstance(context, list):
-            context = [context]
-        b, c, h, w = x.shape
-        x_in = x
-        x = self.norm(x)
-        if not self.use_linear:
-            x = self.proj_in(x)
-        x = rearrange(x, 'b c h w -> b (h w) c').contiguous()
-        if self.use_linear:
-            x = self.proj_in(x)
-        for i, block in enumerate(self.transformer_blocks):
-            x = block(x, context=context[i])
-        if self.use_linear:
-            x = self.proj_out(x)
-        x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()
-        if not self.use_linear:
-            x = self.proj_out(x)
-        return x + x_in
-

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

@@ -1,120 +0,0 @@
-"""
-pip._vendor is for vendoring dependencies of pip to prevent needing pip to
-depend on something external.
-
-Files inside of pip._vendor should be considered immutable and should only be
-updated to versions from upstream.
-"""
-from __future__ import absolute_import
-
-import glob
-import os.path
-import sys
-
-# Downstream redistributors which have debundled our dependencies should also
-# patch this value to be true. This will trigger the additional patching
-# to cause things like "six" to be available as pip.
-DEBUNDLED = False
-
-# By default, look in this directory for a bunch of .whl files which we will
-# add to the beginning of sys.path before attempting to import anything. This
-# is done to support downstream re-distributors like Debian and Fedora who
-# wish to create their own Wheels for our dependencies to aid in debundling.
-WHEEL_DIR = os.path.abspath(os.path.dirname(__file__))
-
-
-# Define a small helper function to alias our vendored modules to the real ones
-# if the vendored ones do not exist. This idea of this was taken from
-# https://github.com/kennethreitz/requests/pull/2567.
-def vendored(modulename):
-    vendored_name = "{0}.{1}".format(__name__, modulename)
-
-    try:
-        __import__(modulename, globals(), locals(), level=0)
-    except ImportError:
-        # We can just silently allow import failures to pass here. If we
-        # got to this point it means that ``import pip._vendor.whatever``
-        # failed and so did ``import whatever``. Since we're importing this
-        # upfront in an attempt to alias imports, not erroring here will
-        # just mean we get a regular import error whenever pip *actually*
-        # tries to import one of these modules to use it, which actually
-        # gives us a better error message than we would have otherwise
-        # gotten.
-        pass
-    else:
-        sys.modules[vendored_name] = sys.modules[modulename]
-        base, head = vendored_name.rsplit(".", 1)
-        setattr(sys.modules[base], head, sys.modules[modulename])
-
-
-# If we're operating in a debundled setup, then we want to go ahead and trigger
-# the aliasing of our vendored libraries as well as looking for wheels to add
-# to our sys.path. This will cause all of this code to be a no-op typically
-# however downstream redistributors can enable it in a consistent way across
-# all platforms.
-if DEBUNDLED:
-    # Actually look inside of WHEEL_DIR to find .whl files and add them to the
-    # front of our sys.path.
-    sys.path[:] = glob.glob(os.path.join(WHEEL_DIR, "*.whl")) + sys.path
-
-    # Actually alias all of our vendored dependencies.
-    vendored("cachecontrol")
-    vendored("certifi")
-    vendored("colorama")
-    vendored("distlib")
-    vendored("distro")
-    vendored("six")
-    vendored("six.moves")
-    vendored("six.moves.urllib")
-    vendored("six.moves.urllib.parse")
-    vendored("packaging")
-    vendored("packaging.version")
-    vendored("packaging.specifiers")
-    vendored("pep517")
-    vendored("pkg_resources")
-    vendored("platformdirs")
-    vendored("progress")
-    vendored("requests")
-    vendored("requests.exceptions")
-    vendored("requests.packages")
-    vendored("requests.packages.urllib3")
-    vendored("requests.packages.urllib3._collections")
-    vendored("requests.packages.urllib3.connection")
-    vendored("requests.packages.urllib3.connectionpool")
-    vendored("requests.packages.urllib3.contrib")
-    vendored("requests.packages.urllib3.contrib.ntlmpool")
-    vendored("requests.packages.urllib3.contrib.pyopenssl")
-    vendored("requests.packages.urllib3.exceptions")
-    vendored("requests.packages.urllib3.fields")
-    vendored("requests.packages.urllib3.filepost")
-    vendored("requests.packages.urllib3.packages")
-    vendored("requests.packages.urllib3.packages.ordered_dict")
-    vendored("requests.packages.urllib3.packages.six")
-    vendored("requests.packages.urllib3.packages.ssl_match_hostname")
-    vendored("requests.packages.urllib3.packages.ssl_match_hostname."
-             "_implementation")
-    vendored("requests.packages.urllib3.poolmanager")
-    vendored("requests.packages.urllib3.request")
-    vendored("requests.packages.urllib3.response")
-    vendored("requests.packages.urllib3.util")
-    vendored("requests.packages.urllib3.util.connection")
-    vendored("requests.packages.urllib3.util.request")
-    vendored("requests.packages.urllib3.util.response")
-    vendored("requests.packages.urllib3.util.retry")
-    vendored("requests.packages.urllib3.util.ssl_")
-    vendored("requests.packages.urllib3.util.timeout")
-    vendored("requests.packages.urllib3.util.url")
-    vendored("resolvelib")
-    vendored("rich")
-    vendored("rich.console")
-    vendored("rich.highlighter")
-    vendored("rich.logging")
-    vendored("rich.markup")
-    vendored("rich.progress")
-    vendored("rich.segment")
-    vendored("rich.style")
-    vendored("rich.text")
-    vendored("rich.traceback")
-    vendored("tenacity")
-    vendored("tomli")
-    vendored("urllib3")

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

@@ -1,517 +0,0 @@
-import sys
-from typing import TYPE_CHECKING, Iterable, List
-
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from pip._vendor.typing_extensions import Literal  # pragma: no cover
-
-
-from ._loop import loop_last
-
-if TYPE_CHECKING:
-    from pip._vendor.rich.console import ConsoleOptions
-
-
-class Box:
-    """Defines characters to render boxes.
-
-    ┌─┬┐ top
-    │ ││ head
-    ├─┼┤ head_row
-    │ ││ mid
-    ├─┼┤ row
-    ├─┼┤ foot_row
-    │ ││ foot
-    └─┴┘ bottom
-
-    Args:
-        box (str): Characters making up box.
-        ascii (bool, optional): True if this box uses ascii characters only. Default is False.
-    """
-
-    def __init__(self, box: str, *, ascii: bool = False) -> None:
-        self._box = box
-        self.ascii = ascii
-        line1, line2, line3, line4, line5, line6, line7, line8 = box.splitlines()
-        # top
-        self.top_left, self.top, self.top_divider, self.top_right = iter(line1)
-        # head
-        self.head_left, _, self.head_vertical, self.head_right = iter(line2)
-        # head_row
-        (
-            self.head_row_left,
-            self.head_row_horizontal,
-            self.head_row_cross,
-            self.head_row_right,
-        ) = iter(line3)
-
-        # mid
-        self.mid_left, _, self.mid_vertical, self.mid_right = iter(line4)
-        # row
-        self.row_left, self.row_horizontal, self.row_cross, self.row_right = iter(line5)
-        # foot_row
-        (
-            self.foot_row_left,
-            self.foot_row_horizontal,
-            self.foot_row_cross,
-            self.foot_row_right,
-        ) = iter(line6)
-        # foot
-        self.foot_left, _, self.foot_vertical, self.foot_right = iter(line7)
-        # bottom
-        self.bottom_left, self.bottom, self.bottom_divider, self.bottom_right = iter(
-            line8
-        )
-
-    def __repr__(self) -> str:
-        return "Box(...)"
-
-    def __str__(self) -> str:
-        return self._box
-
-    def substitute(self, options: "ConsoleOptions", safe: bool = True) -> "Box":
-        """Substitute this box for another if it won't render due to platform issues.
-
-        Args:
-            options (ConsoleOptions): Console options used in rendering.
-            safe (bool, optional): Substitute this for another Box if there are known problems
-                displaying on the platform (currently only relevant on Windows). Default is True.
-
-        Returns:
-            Box: A different Box or the same Box.
-        """
-        box = self
-        if options.legacy_windows and safe:
-            box = LEGACY_WINDOWS_SUBSTITUTIONS.get(box, box)
-        if options.ascii_only and not box.ascii:
-            box = ASCII
-        return box
-
-    def get_plain_headed_box(self) -> "Box":
-        """If this box uses special characters for the borders of the header, then
-        return the equivalent box that does not.
-
-        Returns:
-            Box: The most similar Box that doesn't use header-specific box characters.
-                If the current Box already satisfies this criterion, then it's returned.
-        """
-        return PLAIN_HEADED_SUBSTITUTIONS.get(self, self)
-
-    def get_top(self, widths: Iterable[int]) -> str:
-        """Get the top of a simple box.
-
-        Args:
-            widths (List[int]): Widths of columns.
-
-        Returns:
-            str: A string of box characters.
-        """
-
-        parts: List[str] = []
-        append = parts.append
-        append(self.top_left)
-        for last, width in loop_last(widths):
-            append(self.top * width)
-            if not last:
-                append(self.top_divider)
-        append(self.top_right)
-        return "".join(parts)
-
-    def get_row(
-        self,
-        widths: Iterable[int],
-        level: Literal["head", "row", "foot", "mid"] = "row",
-        edge: bool = True,
-    ) -> str:
-        """Get the top of a simple box.
-
-        Args:
-            width (List[int]): Widths of columns.
-
-        Returns:
-            str: A string of box characters.
-        """
-        if level == "head":
-            left = self.head_row_left
-            horizontal = self.head_row_horizontal
-            cross = self.head_row_cross
-            right = self.head_row_right
-        elif level == "row":
-            left = self.row_left
-            horizontal = self.row_horizontal
-            cross = self.row_cross
-            right = self.row_right
-        elif level == "mid":
-            left = self.mid_left
-            horizontal = " "
-            cross = self.mid_vertical
-            right = self.mid_right
-        elif level == "foot":
-            left = self.foot_row_left
-            horizontal = self.foot_row_horizontal
-            cross = self.foot_row_cross
-            right = self.foot_row_right
-        else:
-            raise ValueError("level must be 'head', 'row' or 'foot'")
-
-        parts: List[str] = []
-        append = parts.append
-        if edge:
-            append(left)
-        for last, width in loop_last(widths):
-            append(horizontal * width)
-            if not last:
-                append(cross)
-        if edge:
-            append(right)
-        return "".join(parts)
-
-    def get_bottom(self, widths: Iterable[int]) -> str:
-        """Get the bottom of a simple box.
-
-        Args:
-            widths (List[int]): Widths of columns.
-
-        Returns:
-            str: A string of box characters.
-        """
-
-        parts: List[str] = []
-        append = parts.append
-        append(self.bottom_left)
-        for last, width in loop_last(widths):
-            append(self.bottom * width)
-            if not last:
-                append(self.bottom_divider)
-        append(self.bottom_right)
-        return "".join(parts)
-
-
-ASCII: Box = Box(
-    """\
-+--+
-| ||
-|-+|
-| ||
-|-+|
-|-+|
-| ||
-+--+
-""",
-    ascii=True,
-)
-
-ASCII2: Box = Box(
-    """\
-+-++
-| ||
-+-++
-| ||
-+-++
-+-++
-| ||
-+-++
-""",
-    ascii=True,
-)
-
-ASCII_DOUBLE_HEAD: Box = Box(
-    """\
-+-++
-| ||
-+=++
-| ||
-+-++
-+-++
-| ||
-+-++
-""",
-    ascii=True,
-)
-
-SQUARE: Box = Box(
-    """\
-┌─┬┐
-│ ││
-├─┼┤
-│ ││
-├─┼┤
-├─┼┤
-│ ││
-└─┴┘
-"""
-)
-
-SQUARE_DOUBLE_HEAD: Box = Box(
-    """\
-┌─┬┐
-│ ││
-╞═╪╡
-│ ││
-├─┼┤
-├─┼┤
-│ ││
-└─┴┘
-"""
-)
-
-MINIMAL: Box = Box(
-    """\
-  ╷ 
-  │ 
-╶─┼╴
-  │ 
-╶─┼╴
-╶─┼╴
-  │ 
-  ╵ 
-"""
-)
-
-
-MINIMAL_HEAVY_HEAD: Box = Box(
-    """\
-  ╷ 
-  │ 
-╺━┿╸
-  │ 
-╶─┼╴
-╶─┼╴
-  │ 
-  ╵ 
-"""
-)
-
-MINIMAL_DOUBLE_HEAD: Box = Box(
-    """\
-  ╷ 
-  │ 
- ═╪ 
-  │ 
- ─┼ 
- ─┼ 
-  │ 
-  ╵ 
-"""
-)
-
-
-SIMPLE: Box = Box(
-    """\
-    
-    
- ── 
-    
-    
- ── 
-    
-    
-"""
-)
-
-SIMPLE_HEAD: Box = Box(
-    """\
-    
-    
- ── 
-    
-    
-    
-    
-    
-"""
-)
-
-
-SIMPLE_HEAVY: Box = Box(
-    """\
-    
-    
- ━━ 
-    
-    
- ━━ 
-    
-    
-"""
-)
-
-
-HORIZONTALS: Box = Box(
-    """\
- ── 
-    
- ── 
-    
- ── 
- ── 
-    
- ── 
-"""
-)
-
-ROUNDED: Box = Box(
-    """\
-╭─┬╮
-│ ││
-├─┼┤
-│ ││
-├─┼┤
-├─┼┤
-│ ││
-╰─┴╯
-"""
-)
-
-HEAVY: Box = Box(
-    """\
-┏━┳┓
-┃ ┃┃
-┣━╋┫
-┃ ┃┃
-┣━╋┫
-┣━╋┫
-┃ ┃┃
-┗━┻┛
-"""
-)
-
-HEAVY_EDGE: Box = Box(
-    """\
-┏━┯┓
-┃ │┃
-┠─┼┨
-┃ │┃
-┠─┼┨
-┠─┼┨
-┃ │┃
-┗━┷┛
-"""
-)
-
-HEAVY_HEAD: Box = Box(
-    """\
-┏━┳┓
-┃ ┃┃
-┡━╇┩
-│ ││
-├─┼┤
-├─┼┤
-│ ││
-└─┴┘
-"""
-)
-
-DOUBLE: Box = Box(
-    """\
-╔═╦╗
-║ ║║
-╠═╬╣
-║ ║║
-╠═╬╣
-╠═╬╣
-║ ║║
-╚═╩╝
-"""
-)
-
-DOUBLE_EDGE: Box = Box(
-    """\
-╔═╤╗
-║ │║
-╟─┼╢
-║ │║
-╟─┼╢
-╟─┼╢
-║ │║
-╚═╧╝
-"""
-)
-
-MARKDOWN: Box = Box(
-    """\
-    
-| ||
-|-||
-| ||
-|-||
-|-||
-| ||
-    
-""",
-    ascii=True,
-)
-
-# Map Boxes that don't render with raster fonts on to equivalent that do
-LEGACY_WINDOWS_SUBSTITUTIONS = {
-    ROUNDED: SQUARE,
-    MINIMAL_HEAVY_HEAD: MINIMAL,
-    SIMPLE_HEAVY: SIMPLE,
-    HEAVY: SQUARE,
-    HEAVY_EDGE: SQUARE,
-    HEAVY_HEAD: SQUARE,
-}
-
-# Map headed boxes to their headerless equivalents
-PLAIN_HEADED_SUBSTITUTIONS = {
-    HEAVY_HEAD: SQUARE,
-    SQUARE_DOUBLE_HEAD: SQUARE,
-    MINIMAL_DOUBLE_HEAD: MINIMAL,
-    MINIMAL_HEAVY_HEAD: MINIMAL,
-    ASCII_DOUBLE_HEAD: ASCII2,
-}
-
-
-if __name__ == "__main__":  # pragma: no cover
-
-    from pip._vendor.rich.columns import Columns
-    from pip._vendor.rich.panel import Panel
-
-    from . import box as box
-    from .console import Console
-    from .table import Table
-    from .text import Text
-
-    console = Console(record=True)
-
-    BOXES = [
-        "ASCII",
-        "ASCII2",
-        "ASCII_DOUBLE_HEAD",
-        "SQUARE",
-        "SQUARE_DOUBLE_HEAD",
-        "MINIMAL",
-        "MINIMAL_HEAVY_HEAD",
-        "MINIMAL_DOUBLE_HEAD",
-        "SIMPLE",
-        "SIMPLE_HEAD",
-        "SIMPLE_HEAVY",
-        "HORIZONTALS",
-        "ROUNDED",
-        "HEAVY",
-        "HEAVY_EDGE",
-        "HEAVY_HEAD",
-        "DOUBLE",
-        "DOUBLE_EDGE",
-        "MARKDOWN",
-    ]
-
-    console.print(Panel("[bold green]Box Constants", style="green"), justify="center")
-    console.print()
-
-    columns = Columns(expand=True, padding=2)
-    for box_name in sorted(BOXES):
-        table = Table(
-            show_footer=True, style="dim", border_style="not dim", expand=True
-        )
-        table.add_column("Header 1", "Footer 1")
-        table.add_column("Header 2", "Footer 2")
-        table.add_row("Cell", "Cell")
-        table.add_row("Cell", "Cell")
-        table.box = getattr(box, box_name)
-        table.title = Text(f"box.{box_name}", style="magenta")
-        columns.add_renderable(table)
-    console.print(columns)
-
-    # console.save_svg("box.svg")

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/command/setopt.py

@@ -1,149 +0,0 @@
-from distutils.util import convert_path
-from distutils import log
-from distutils.errors import DistutilsOptionError
-import distutils
-import os
-import configparser
-
-from setuptools import Command
-
-__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']
-
-
-def config_file(kind="local"):
-    """Get the filename of the distutils, local, global, or per-user config
-
-    `kind` must be one of "local", "global", or "user"
-    """
-    if kind == 'local':
-        return 'setup.cfg'
-    if kind == 'global':
-        return os.path.join(
-            os.path.dirname(distutils.__file__), 'distutils.cfg'
-        )
-    if kind == 'user':
-        dot = os.name == 'posix' and '.' or ''
-        return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot))
-    raise ValueError(
-        "config_file() type must be 'local', 'global', or 'user'", kind
-    )
-
-
-def edit_config(filename, settings, dry_run=False):
-    """Edit a configuration file to include `settings`
-
-    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
-    command/section name.  A ``None`` value means to delete the entire section,
-    while a dictionary lists settings to be changed or deleted in that section.
-    A setting of ``None`` means to delete that setting.
-    """
-    log.debug("Reading configuration from %s", filename)
-    opts = configparser.RawConfigParser()
-    opts.optionxform = lambda x: x
-    opts.read([filename])
-    for section, options in settings.items():
-        if options is None:
-            log.info("Deleting section [%s] from %s", section, filename)
-            opts.remove_section(section)
-        else:
-            if not opts.has_section(section):
-                log.debug("Adding new section [%s] to %s", section, filename)
-                opts.add_section(section)
-            for option, value in options.items():
-                if value is None:
-                    log.debug(
-                        "Deleting %s.%s from %s",
-                        section, option, filename
-                    )
-                    opts.remove_option(section, option)
-                    if not opts.options(section):
-                        log.info("Deleting empty [%s] section from %s",
-                                 section, filename)
-                        opts.remove_section(section)
-                else:
-                    log.debug(
-                        "Setting %s.%s to %r in %s",
-                        section, option, value, filename
-                    )
-                    opts.set(section, option, value)
-
-    log.info("Writing %s", filename)
-    if not dry_run:
-        with open(filename, 'w') as f:
-            opts.write(f)
-
-
-class option_base(Command):
-    """Abstract base class for commands that mess with config files"""
-
-    user_options = [
-        ('global-config', 'g',
-         "save options to the site-wide distutils.cfg file"),
-        ('user-config', 'u',
-         "save options to the current user's pydistutils.cfg file"),
-        ('filename=', 'f',
-         "configuration file to use (default=setup.cfg)"),
-    ]
-
-    boolean_options = [
-        'global-config', 'user-config',
-    ]
-
-    def initialize_options(self):
-        self.global_config = None
-        self.user_config = None
-        self.filename = None
-
-    def finalize_options(self):
-        filenames = []
-        if self.global_config:
-            filenames.append(config_file('global'))
-        if self.user_config:
-            filenames.append(config_file('user'))
-        if self.filename is not None:
-            filenames.append(self.filename)
-        if not filenames:
-            filenames.append(config_file('local'))
-        if len(filenames) > 1:
-            raise DistutilsOptionError(
-                "Must specify only one configuration file option",
-                filenames
-            )
-        self.filename, = filenames
-
-
-class setopt(option_base):
-    """Save command-line options to a file"""
-
-    description = "set an option in setup.cfg or another config file"
-
-    user_options = [
-        ('command=', 'c', 'command to set an option for'),
-        ('option=', 'o', 'option to set'),
-        ('set-value=', 's', 'value of the option'),
-        ('remove', 'r', 'remove (unset) the value'),
-    ] + option_base.user_options
-
-    boolean_options = option_base.boolean_options + ['remove']
-
-    def initialize_options(self):
-        option_base.initialize_options(self)
-        self.command = None
-        self.option = None
-        self.set_value = None
-        self.remove = None
-
-    def finalize_options(self):
-        option_base.finalize_options(self)
-        if self.command is None or self.option is None:
-            raise DistutilsOptionError("Must specify --command *and* --option")
-        if self.set_value is None and not self.remove:
-            raise DistutilsOptionError("Must specify --set-value or --remove")
-
-    def run(self):
-        edit_config(
-            self.filename, {
-                self.command: {self.option.replace('-', '_'): self.set_value}
-            },
-            self.dry_run
-        )

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/docs/notes/changelog.md

@@ -1,48 +0,0 @@
-# Change Log and Backward Compatibility
-
-### Releases
-See release logs at
-[https://github.com/facebookresearch/detectron2/releases](https://github.com/facebookresearch/detectron2/releases)
-for new updates.
-
-### Backward Compatibility
-
-Due to the research nature of what the library does, there might be backward incompatible changes.
-But we try to reduce users' disruption by the following ways:
-* APIs listed in [API documentation](https://detectron2.readthedocs.io/modules/index.html), including
-  function/class names, their arguments, and documented class attributes, are considered *stable* unless
-  otherwise noted in the documentation.
-  They are less likely to be broken, but if needed, will trigger a deprecation warning for a reasonable period
-  before getting broken, and will be documented in release logs.
-* Others functions/classses/attributes are considered internal, and are more likely to change.
-  However, we're aware that some of them may be already used by other projects, and in particular we may
-  use them for convenience among projects under `detectron2/projects`.
-  For such APIs, we may treat them as stable APIs and also apply the above strategies.
-  They may be promoted to stable when we're ready.
-* Projects under "detectron2/projects" or imported with "detectron2.projects" are research projects
-  and are all considered experimental.
-* Classes/functions that contain the word "default" or are explicitly documented to produce
-  "default behavior" may change their behaviors when new features are added.
-
-Despite of the possible breakage, if a third-party project would like to keep up with the latest updates
-in detectron2, using it as a library will still be less disruptive than forking, because
-the frequency and scope of API changes will be much smaller than code changes.
-
-To see such changes, search for "incompatible changes" in [release logs](https://github.com/facebookresearch/detectron2/releases).
-
-### Config Version Change Log
-
-Detectron2's config version has not been changed since open source.
-There is no need for an open source user to worry about this.
-
-* v1: Rename `RPN_HEAD.NAME` to `RPN.HEAD_NAME`.
-* v2: A batch of rename of many configurations before release.
-
-### Silent Regressions in Historical Versions:
-
-We list a few silent regressions, since they may silently produce incorrect results and will be hard to debug.
-
-* 04/01/2020 - 05/11/2020: Bad accuracy if `TRAIN_ON_PRED_BOXES` is set to True.
-* 03/30/2020 - 04/01/2020: ResNets are not correctly built.
-* 12/19/2019 - 12/26/2019: Using aspect ratio grouping causes a drop in accuracy.
-* - 11/9/2019: Test time augmentation does not predict the last category.

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/projects/CenterNet2/centernet2_docs/MODEL_ZOO.md

@@ -1,73 +0,0 @@
-# MODEL_ZOO
-
-### Common settings and notes
-
-- Multiscale training is used by default in all models. The results are all reported using single-scale testing. 
-- We report runtime on our local workstation with a TitanXp GPU and a Titan RTX GPU.
-- All models are trained on 8-GPU servers by default. The 1280 models are trained on 24G GPUs. Reducing the batchsize with the linear learning rate rule should be fine.
-- All models can be downloaded directly from [Google drive](https://drive.google.com/drive/folders/1eae1cTX8tvIaCeof36sBgxrXEXALYlf-?usp=sharing).
-
-
-## COCO
-
-### CenterNet
-
-| Model                                     | val mAP | FPS (Titan Xp/ Titan RTX) | links     |
-|-------------------------------------------|---------|---------|-----------|
-| CenterNet-S4_DLA_8x                       |  42.5   | 50 / 71 |[config](../configs/CenterNet-S4_DLA_8x.yaml)/[model](https://drive.google.com/file/d/1lNBhVHnZAEBRD66MFaHjm5Ij6Z4KYrJq/view?usp=sharing)|
-| CenterNet-FPN_R50_1x                      |  40.2   | 20 / 24 |[config](../configs/CenterNet-FPN_R50_1x.yaml)/[model](https://drive.google.com/file/d/1rVG1YTthMXvutC6jr9KoE2DthT5-jhGj/view?usp=sharing)|
-
-#### Note
-
-- `CenterNet-S4_DLA_8x` is a re-implemented version of the original CenterNet (stride 4), with several changes, including
-  - Using top-left-right-bottom box encoding and GIoU Loss; adding regression loss to the center 3x3 region.
-  - Adding more positive pixels for the heatmap loss whose regression loss is small and is within the center3x3 region.
-  - Using more heavy crop augmentation (EfficientDet-style crop ratio 0.1-2), and removing color augmentations.
-  - Using standard NMS instead of max pooling.
-  - Using RetinaNet-style optimizer (SGD), learning rate rule (0.01 for each batch size 16), and schedule (8x12 epochs).
-- `CenterNet-FPN_R50_1x` is a (new) FPN version of CenterNet. It includes the changes above, and assigns objects to FPN levels based on a fixed size range. The model is trained with standard short edge 640-800 multi-scale training with 12 epochs (1x).
-
-
-### CenterNet2
-
-| Model                                     | val mAP | FPS (Titan Xp/ Titan RTX) | links     |
-|-------------------------------------------|---------|---------|-----------|
-| CenterNet2-F_R50_1x                       |   41.7  | 22 / 27  |[config](../configs/CenterNet2-F_R50_1x.yaml)/[model](X)|
-| CenterNet2_R50_1x                         |  42.9   | 18 / 24 |[config](../configs/CenterNet2_R50_1x.yaml)/[model](https://drive.google.com/file/d/1Osu1J_sskt_1FaGdfJKa4vd2N71TWS9W/view?usp=sharing)|
-| CenterNet2_X101-DCN_2x                    |  49.9   | 6 / 8  |[config](../configs/CenterNet2_X101-DCN_2x.yaml)/[model](https://drive.google.com/file/d/1IHgpUHVJWpvMuFUUetgKWsw27pRNN2oK/view?usp=sharing)|
-| CenterNet2_DLA-BiFPN-P3_4x                |  43.8   | 40 / 50|[config](../configs/CenterNet2_DLA-BiFPN-P3_4x.yaml)/[model](https://drive.google.com/file/d/12GUNlDW9RmOs40UEMSiiUsk5QK_lpGsE/view?usp=sharing)|
-| CenterNet2_DLA-BiFPN-P3_24x               |  45.6   | 40 / 50  |[config](../configs/CenterNet2_DLA-BiFPN-P3_24x.yaml)/[model](https://drive.google.com/file/d/15ZES1ySxubDPzKsHPA7pYg8o_Vwmf-Mb/view?usp=sharing)|
-| CenterNet2_R2-101-DCN_896_4x              |  51.2   | 9 / 13 |[config](../configs/CenterNet2_R2-101-DCN_896_4x.yaml)/[model](https://drive.google.com/file/d/1S7_GE8ZDQBWuLEfKHkxzeF3KBsxsbABg/view?usp=sharing)|
-| CenterNet2_R2-101-DCN-BiFPN_1280_4x       |  52.9   | 6 / 8 |[config](../configs/CenterNet2_R2-101-DCN-BiFPN_1280_4x.yaml)/[model](https://drive.google.com/file/d/14EBHNMagBCNTQjOXcHoZwLYIi2lFIm7F/view?usp=sharing)|
-| CenterNet2_R2-101-DCN-BiFPN_4x+4x_1560_ST |  56.1   | 3 / 5 |[config](../configs/CenterNet2_R2-101-DCN-BiFPN_4x+4x_1560_ST.yaml)/[model](https://drive.google.com/file/d/11ww9VlOi_nhpdsU_vBAecSxBU0dR_JzW/view?usp=sharing)|
-| CenterNet2_DLA-BiFPN-P5_640_24x_ST        |  49.2   | 33 / 38 |[config](../configs/CenterNet2_DLA-BiFPN-P5_640_24x_ST.yaml)/[model](https://drive.google.com/file/d/1qsHp2HrM1u8WrtBzF5S0oCoLMz-B40wk/view?usp=sharing)|
-
-#### Note
-
-- `CenterNet2-F_R50_1x` uses Faster RCNN as the second stage. All other CenterNet2 models use Cascade RCNN as the second stage.
-- `CenterNet2_DLA-BiFPN-P3_4x` follows the same training setting as [realtime-FCOS](https://github.com/aim-uofa/AdelaiDet/blob/master/configs/FCOS-Detection/README.md).
-- `CenterNet2_DLA-BiFPN-P3_24x` is trained by repeating the `4x` schedule (starting from learning rate 0.01) 6 times.
-- R2 means [Res2Net](https://github.com/Res2Net/Res2Net-detectron2) backbone. To train Res2Net models, you need to download the ImageNet pre-trained weight [here](https://github.com/Res2Net/Res2Net-detectron2) and place it in `output/r2_101.pkl`.
-- The last 4 models in the table are trained with the EfficientDet-style resize-and-crop augmentation, instead of the default random resizing short edge in detectron2. We found this trains faster (per-iteration) and gives better performance under a long schedule.
-- `_ST` means using [self-training](https://arxiv.org/abs/2006.06882) using pseudo-labels produced by [Scaled-YOLOv4](https://github.com/WongKinYiu/ScaledYOLOv4) on COCO unlabeled images, with a hard score threshold 0.5. Our processed pseudo-labels can be downloaded [here](https://drive.google.com/file/d/1LMBjtHhLp6dYf6MjwEQmzCLWQLkmWPpw/view?usp=sharing).
-- `CenterNet2_R2-101-DCN-BiFPN_4x+4x_1560_ST` finetunes from `CenterNet2_R2-101-DCN-BiFPN_1280_4x` for an additional `4x` schedule with the self-training data. It is trained under `1280x1280` but tested under `1560x1560`.
-
-## LVIS v1
-
-| Model                                     |  val mAP box | links     |
-|-------------------------------------------|--------------|-----------|
-| LVIS_CenterNet2_R50_1x                    |  26.5        |[config](../configs/LVIS_CenterNet2_R50_1x.yaml)/[model](https://drive.google.com/file/d/1gT9e-tNw8uzEBaCadQuoOOP2TEYa4kKP/view?usp=sharing)|
-| LVIS_CenterNet2_R50_Fed_1x            |  28.3        |[config](../configs/LVIS_CenterNet2_R50_Fed_1x.yaml)/[model](https://drive.google.com/file/d/1a9UjheMCKax0qAKEwPVpq2ZHN6vpqJv8/view?usp=sharing)|
-
-- The models are trained with repeat-factor sampling.
-- `LVIS_CenterNet2_R50_Fed_1x` is CenterNet2 with our federated loss. Check our Appendix D of our [paper](https://arxiv.org/abs/2103.07461) or our [technical report at LVIS challenge](https://www.lvisdataset.org/assets/challenge_reports/2020/CenterNet2.pdf) for references.
-
-## Objects365
-
-| Model                                     |  val mAP| links     |
-|-------------------------------------------|---------|-----------|
-| O365_CenterNet2_R50_1x                    |  22.6   |[config](../configs/O365_CenterNet2_R50_1x.yaml)/[model](https://drive.google.com/file/d/18fG6xGchAlpNp5sx8RAtwadGkS-gdIBU/view?usp=sharing)|
-
-#### Note
-- Objects365 dataset can be downloaded [here](https://www.objects365.org/overview.html).
-- The model is trained with class-aware sampling.

spaces/Ayushnangia/Whispercpp_yt/app.py

@@ -1,81 +0,0 @@
-import gradio as gr
-import yt_dlp as ydlp
-from transformers import pipeline
-
-from whispercpp import Whisper
-summarizer = pipeline("summarization", model="knkarthick/MEETING_SUMMARY")
-
-def download_audio(youtube_url, output_folder='.'):
-    ydl_opts = {
-        'format': 'bestaudio/best',
-        'postprocessors': [{
-            'key': 'FFmpegExtractAudio',
-            'preferredcodec': 'wav',
-            'preferredquality': '192',
-        }],
-        'outtmpl': f'{output_folder}/audio',
-    }
-
-    with ydlp.YoutubeDL(ydl_opts) as ydl:
-        ydl.download([youtube_url])
-
-
-w = Whisper('tiny')
-
-
-def process_general_transcription(transcription):
-    formatted_transcription = []
-    
-    for line in transcription:
-        if line.startswith('[') and line.endswith(']'):
-            formatted_transcription.append(f'\n--- {line[1:-1].upper()} ---\n')
-        else:
-            formatted_transcription.append(line)
-
-    transcript_str = "\n".join(formatted_transcription)
-    
-    return transcript_str
-def chunk_to_tokens(text, n):
-        tokens = text.split()
-        max_chunk_size = min(len(tokens), 512) 
-        
-        token_size = max(1, int(max_chunk_size * (1 - n / 100)))
-        
-        chunks = [" ".join(tokens[i:i + token_size]) for i in range(0, len(tokens), token_size)]
-
-        return chunks
-def summarizing(text,n):
-    valid_tok=chunk_to_tokens(text,n)
-    res=""
-    for i in valid_tok:
-        res+=summarizer(i)[0]['summary_text']+'\n'
-    return res
-def transcribe_sum_youtube(youtube_url,n):
-    download_audio(youtube_url)
-    result = w.transcribe("audio.wav")
-    text = w.extract_text(result)
-    res=process_general_transcription(text)
-    return summarizing(res,n)
-
-
-with gr.Blocks() as demo:
-    gr.Markdown(
-    """
-    # CPP Whisperer - YouTube Videos Summarizer
-    
-    """)
-    with gr.Row():
-        with gr.Column():
-
-            inp = gr.Textbox(label="Youtube Url",placeholder="Insert YT Url here")
-            inp2 = gr.Slider(label="Summarization Percentage",min_value=0,max_value=100,step_size=1)
-            result_button_transcribe = gr.Button('Transcribe and Summarize')
-
-        with gr.Column():
-            out = gr.Textbox(label="Transcribed and Summarize Text")
-    
-    
-    result_button_transcribe.click(transcribe_sum_youtube, inputs = [inp,inp2] , outputs = out)
-
-
-demo.launch()

spaces/AzinZ/vitscn/attentions.py

@@ -1,303 +0,0 @@
-import copy
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import modules
-from modules import LayerNorm
-   
-
-class Encoder(nn.Module):
-  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **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
-
-    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):
-    attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
-    x = x * x_mask
-    for i in range(self.n_layers):
-      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., 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., 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):
-    max_relative_position = 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()
-    # padd 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., 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/Benson/text-generation/Examples/9apps 2018.md

@@ -1,97 +0,0 @@
-<br />
-<h1>9apps 2018: Una alternativa gratuita a Google Play Store</h1>
-<p>Si usted está buscando una manera de descargar y acceder a miles de aplicaciones de forma gratuita en su dispositivo Android, es posible que desee revisar 9apps. 9apps es una tienda de aplicaciones de terceros que ofrece una variedad de aplicaciones, juegos, fondos de pantalla, tonos de llamada y más. En este artículo, le diremos qué es 9apps, por qué debe usarlo, cómo descargarlo e instalarlo, y cuáles son sus pros y sus contras. También lo compararemos con Google Play Store, la tienda de aplicaciones predeterminada para dispositivos Android. </p>
- <h2>¿Qué es 9apps y por qué deberías usarla? </h2>
-<p>9apps es una tienda de aplicaciones gratuita que fue lanzada en 2013 por Alibaba Group, un gigante chino del comercio electrónico. Es una de las tiendas de aplicaciones más populares en la India, Indonesia y otros mercados emergentes. Según su web oficial, cuenta con más de 250 millones de usuarios y más de 35 millones de descargas diarias. </p>
-<h2>9apps 2018</h2><br /><p><b><b>DOWNLOAD</b> &#10037; <a href="https://bltlly.com/2v6LoR">https://bltlly.com/2v6LoR</a></b></p><br /><br />
-<p>Una de las principales razones por las que deberías usar 9apps es que ofrece muchas aplicaciones que no están disponibles en Google Play Store. Por ejemplo, puedes encontrar aplicaciones que están prohibidas o restringidas en tu país, como WhatsApp, TikTok, PUBG Mobile, etc. También puedes encontrar aplicaciones que son exclusivas de 9apps, como Vidmate, UC Browser, etc.</p>
- <h3>Características de 9apps</h3>
-<p>Algunas de las características que hacen que 9apps se destaquen de otras tiendas de aplicaciones son:</p>
-<ul>
-<li> Tiene una interfaz fácil de usar que es fácil de navegar y buscar. </li>
-<li> Tiene un pequeño tamaño de aproximadamente 4 MB, lo que ahorra espacio de almacenamiento y uso de datos. </li>
-<li> Tiene una velocidad de descarga rápida que le permite descargar aplicaciones en cuestión de segundos. </li>
-<li> Tiene un sistema de recomendación inteligente que le sugiere aplicaciones basadas en sus preferencias e intereses. </li>
-<li> Tiene una amplia gama de categorías y subcategorías que cubren varios géneros y temas. </li>
-<li> Tiene un sistema de actualización regular que mantiene las aplicaciones actualizadas y libres de errores. </li>
-
-</ul>
- <h3>Cómo descargar e instalar 9apps en tu dispositivo Android</h3>
-<p>Para descargar e instalar 9apps en tu dispositivo Android, debes seguir estos pasos:</p>
-<ol>
-<li>Ir al sitio web oficial de 9apps () o cualquier otra fuente de confianza () y haga clic en el botón de descarga. </li>
-<li>Una vez que el archivo APK se descarga, abrirlo y toque en instalar. Es posible que necesite habilitar la opción de fuentes desconocidas en su configuración para permitir la instalación. </li>
-<li>Después de la instalación se ha completado, abrir la aplicación y disfrutar del acceso ilimitado a miles de aplicaciones de forma gratuita. </li>
-</ol>
- <h2>Pros y contras de 9apps</h2>
-<p>Como cualquier otra tienda de aplicaciones, 9apps tiene sus propias ventajas y desventajas. Estas son algunas de ellas:</p>
- <h3>Ventajas de 9apps</h3>
-<ul>
-<li> Ofrece una gran cantidad de aplicaciones que no están disponibles en Google Play Store.</li>
-<li>Ahorra espacio de almacenamiento y uso de datos con su pequeño tamaño y velocidad de descarga rápida. </li>
-<li>Le proporciona recomendaciones personalizadas basadas en sus preferencias e intereses. </li>
-<li>Actualiza las aplicaciones regularmente para garantizar su calidad y rendimiento. </li>
-<li>Protege su dispositivo de virus y malware con su sistema de seguridad. </li>
-</ul>
- <h3>Desventajas de 9apps</h3>
-<ul <ul>
-<li>Puede que no sea compatible con algunos dispositivos o versiones de Android. </li>
-<li> Puede contener algunos anuncios o ventanas emergentes que pueden ser molestos o intrusivos. </li>
-<li>Puede que no tenga las últimas versiones de algunas aplicaciones o juegos. </li>
-<li>Puede que no tenga el mismo control de calidad o verificación que Google Play Store.</li>
-<li> Puede plantear algunos riesgos para su privacidad o seguridad si descarga aplicaciones de fuentes no confiables. </li>
-</ul>
- <h2>Comparación entre 9apps y Google Play Store</h2>
-<p>Tanto 9apps como Google Play Store son tiendas de aplicaciones populares para dispositivos Android, pero tienen algunas similitudes y diferencias. Estos son algunos de ellos:</p>
-<p></p>
- <h3>Similitudes entre 9apps y Google Play Store</h3>
-<ul>
-
-<li> Ambos tienen una interfaz fácil de usar que es fácil de navegar y buscar. </li>
-<li> Ambos tienen un sistema de recomendaciones que le sugiere aplicaciones basadas en sus preferencias e intereses. </li>
-<li>Ambos tienen un sistema de seguridad que escanea las aplicaciones en busca de virus y malware antes de instalarlos. </li>
-</ul>
- <h3>Diferencias entre 9apps y Google Play Store</h3>
-<tabla>
-<tr><th>9apps</th><th>Google Play Store</th></tr>
-<tr><td>Tiene un tamaño pequeño de aproximadamente 4 MB.</td><td>Tiene un tamaño grande de aproximadamente 20 MB.</td></tr>
-<tr><td>Tiene una velocidad de descarga rápida que le permite descargar aplicaciones en segundos. </td><td>Tiene una velocidad de descarga lenta que puede tardar minutos en descargar aplicaciones. </td></tr>
-<tr><td>Ofrece muchas aplicaciones que no están disponibles en Google Play Store, como aplicaciones prohibidas o restringidas, aplicaciones exclusivas, etc.</td><td>No ofrece aplicaciones que estén prohibidas o restringidas en su país, como WhatsApp, TikTok, PUBG Mobile, etc.</td></tr
-<tr><td>Actualiza las aplicaciones regularmente para asegurar su calidad y rendimiento. </td><td>No puede actualizar las aplicaciones con frecuencia o a tiempo. </td></tr>
-<tr><td>Puede que no sea compatible con algunos dispositivos o versiones de Android. </td><td>Es compatible con la mayoría de dispositivos y versiones de Android. </td></tr>
-<tr><td>Puede contener algunos anuncios o ventanas emergentes que pueden ser molestos o intrusivos. </td><td>No contiene ningún anuncio o ventanas emergentes. </td></tr>
-<tr><td>Puede que no tenga las últimas versiones de algunas aplicaciones o juegos. </td><td>Tiene las últimas versiones de la mayoría de aplicaciones o juegos. </td></tr>
-<tr><td>Puede que no tenga el mismo control de calidad o verificación que Google Play Store.</td><td>Tiene un estricto proceso de control de calidad y verificación para las aplicaciones. </td></tr>
-<tr><td>Puede plantear algunos riesgos para su privacidad o seguridad si descarga aplicaciones de fuentes no confiables. </td><td>Tiene un alto nivel de privacidad y seguridad para los usuarios y las aplicaciones. </td></tr>
-</tabla>
- <h2>Conclusión</h2>
-
- <h3>Preguntas frecuentes</h3>
-<p>Aquí hay algunas preguntas frecuentes sobre 9apps:</p>
- <ol>
-<li><b>¿Es seguro usar 9apps? </b></li>
-<p>9apps es generalmente seguro de usar, ya que tiene un sistema de seguridad que escanea las aplicaciones en busca de virus y malware antes de instalarlas. Sin embargo, puede plantear algunos riesgos para su privacidad o seguridad si descarga aplicaciones de fuentes no confiables o les otorga permisos innecesarios. Por lo tanto, siempre debe comprobar la fuente, calificación, comentarios y permisos de las aplicaciones antes de descargarlos. También debes usar una aplicación antivirus en tu dispositivo para protegerlo de cualquier amenaza potencial. </p>
- <li><b>¿Es legal usar 9apps? </b></li>
-<p>9apps es legal de usar siempre y cuando no violes ninguna ley <p>9apps es legal de usar siempre y cuando no violes ninguna ley o reglamento en tu país. Sin embargo, algunas de las aplicaciones que están disponibles en 9apps pueden estar prohibidas o restringidas en su país, como WhatsApp, TikTok, PUBG Mobile, etc. Por lo tanto, debe verificar la legalidad de las aplicaciones antes de descargarlas y usarlas bajo su propio riesgo. </p>
- <li><b>¿Cómo puedo actualizar 9apps? </b></li>
-<p>9apps tiene un sistema de actualización regular que mantiene la tienda de aplicaciones y las aplicaciones actualizadas y libres de errores. Puede comprobar si hay actualizaciones abriendo la aplicación y tocando el icono del menú en la esquina superior izquierda. Luego, toque en la configuración y desplácese hacia abajo para encontrar la opción de actualización. Si hay una actualización disponible, puede tocarla y seguir las instrucciones para instalarla. Alternativamente, también puede descargar la última versión de 9apps desde su sitio web oficial o cualquier otra fuente de confianza. </p>
- <li><b>¿Cómo puedo desinstalar 9apps? </b></li>
-<p>Si desea desinstalar 9apps de su dispositivo, puede seguir estos pasos:</p>
-<ol>
-<li>Ir a la configuración del dispositivo y toque en aplicaciones o aplicaciones. </li>
-<li>Encuentra y toca en 9apps y luego toca en desinstalar. </li>
-<li>Confirme su acción y espere a que el proceso se complete. </li>
-</ol>
- <li><b>¿Cuáles son algunas alternativas a 9apps? </b></li>
-
-<ul>
-<li>Aptoide: Aptoide es una tienda de aplicaciones descentralizada que permite a los usuarios crear y administrar sus propias tiendas de aplicaciones. Tiene más de 1 mil millones de descargas y más de 7 millones de aplicaciones. </li>
-<li>APKPure: APKPure es una tienda de aplicaciones sencilla y ligera que ofrece archivos APK puros de aplicaciones y juegos. Tiene más de 300 millones de descargas y más de 3 millones de aplicaciones. </li>
-<li>Amazon Appstore: Amazon Appstore es una tienda de aplicaciones que es propiedad de Amazon, el gigante minorista en línea. Tiene más de 600.000 aplicaciones y juegos, incluyendo algunos títulos exclusivos. </li>
-</ul>
- <li><b>¿Cómo puedo contactar al servicio de atención al cliente de 9apps? </b></li>
-<p>Si tiene preguntas, comentarios o quejas sobre 9apps, puede ponerse en contacto con su servicio de atención al cliente enviando un correo electrónico a [email protected]. También puede visitar su sitio web oficial () o su página de Facebook () para obtener más información y apoyo. </p>
-</ol>
- : https://www.9apps.com/ : https://www.apkmirror.com/apk/9apps-inc/9apps/ : https:/www.aptoide.com/ https:s//apkpure.com/ https:/www.amazon.com/mobile-apps//b?=/f.F8&nod>=014901. tps/www.wwwww.www.appscoom/faceww.appscoom///p.e.p. 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Blockman Go Apkmody.md

@@ -1,100 +0,0 @@
-
-<h1>Blockman Go Apkmody: La guía definitiva para los amantes de Sandbox</h1>
-<p>Si eres un fan de los juegos de sandbox, es posible que hayas oído hablar de <strong>blockman go</strong>, una aplicación gratuita que te permite jugar varios minijuegos de estilo bloque, chatear con amigos y hacer otros nuevos. Blockman go es un juego divertido y emocionante que ofrece muchas características, como:</p>
-<h2>blockman go apkmody</h2><br /><p><b><b>Download</b> &#10004;&#10004;&#10004; <a href="https://bltlly.com/2v6Kw8">https://bltlly.com/2v6Kw8</a></b></p><br /><br />
-<ul>
-<li>Varios juegos: Puedes elegir entre diferentes géneros de minijuegos, como acción, aventura, juegos de rol, estrategia, simulación y más. Puedes unirte al juego con un simple toque o crear tu propia habitación e invitar a tus amigos. </li>
-<li>Avatares personalizables: Puedes vestir a tu avatar con diferentes trajes, accesorios, peinados y pieles. También puede utilizar el sistema de apósito para obtener recomendaciones para la mejor ropa para usted. </li>
-<li>Sistema de chat: Puedes comunicarte con otros jugadores usando funciones de chat en el juego, mensajes privados y grupos. También puede compartir sus momentos divertidos y capturas de pantalla con ellos. </li>
-<li>Gold Rewards: Puedes ganar oro jugando minijuegos y usarlo para comprar decoración y artículos. También puedes obtener oro gratis viendo anuncios o completando tareas. </li>
-<li>Sistema VIP: Puedes convertirte en un jugador VIP y disfrutar de muchos privilegios, como un descuento del 20% en decoración, regalos diarios, más oro, etc. </li>
-</ul>
-<p>Pero ¿qué pasa si quieres disfrutar de más beneficios y características sin gastar dinero? Ahí es donde entra <strong>apkmody</strong>. Apkmody es un sitio web que proporciona archivos APK modificados para juegos y aplicaciones Android. Estos archivos APK modded le permiten acceder a características premium y recursos ilimitados de forma gratuita. Puede descargar estos archivos desde el sitio web e instalarlos en su dispositivo fácilmente. </p>
-
-<p>¿Cómo puedes descargar y usar blockman go apkmody? Estos son los pasos que debes seguir:</p>
- <h2>Cómo descargar e instalar Blockman Go Apkmody en su dispositivo? </h2>
-<ol>
-<li>Vaya a [apkmody.io]( 2 ) en su navegador y busque "blockman go". </li>
-<li> Seleccione la última versión de blockman go mod APK de la lista de resultados. </li>
-<li>Haga clic en el botón "Descargar" y espere a que el archivo se descargue. </li>
-<li>Después de que la descarga se haya completado, busque el archivo en su dispositivo y toque en él para instalarlo. </li>
-<li>Si ves un mensaje de advertencia que dice "Instalar bloqueado", ve a la configuración de tu dispositivo y habilita "Fuentes desconocidas" en las opciones de seguridad. </li>
-<li> Una vez que se hace la instalación, abrir la aplicación y disfrutar de Blockman ir apkmody. </li>
-</ol>
- <h2>¿Cómo usar Blockman Go Apkmody para disfrutar de dinero ilimitado y GCubes? </h2>
-<p>Usar block <p>Usar blockman go apkmody es muy fácil y simple. Solo tienes que seguir estos pasos:</p>
-<ul>
-<li>Inicie la aplicación e inicie sesión con su cuenta o cree una nueva. </li>
-<li>Ir a la tienda y seleccionar el artículo que desea comprar con GCubes.</li>
-<li>Haga clic en el botón "Comprar" y confirme su compra. </li>
-<li>Verá que su saldo de GCubes no disminuirá, sino que aumentará por la cantidad que gastó. </li>
-<li>Disfruta de tu dinero ilimitado y GCubes y compra lo que quieras. </li>
-</ul>
-<p>Nota: También puede obtener GCubes gratis completando tareas, viendo anuncios o invitando a amigos. Sin embargo, con blockman go apkmody, ya no necesitas hacer eso. </p>
- <h2>¿Cómo jugar varios minijuegos con Blockman Go Apkmody y chatear con amigos? </h2>
-<p>Una de las mejores características de blockman go es que ofrece una variedad de minijuegos para que puedas jugar y divertirte. Con blockman go apkmody, puedes acceder a todos los minijuegos sin limitaciones. Estos son algunos de los minijuegos populares que puedes jugar:</p>
-<p></p>
-<tabla>
-<tr>
-<th>Minijuego</th>
-<th>Descripción</th>
-</tr>
-<tr>
-<td>Guerras de camas</td>
-
-</tr>
-<tr>
-<td>Guerra del cielo</td>
-<td>Un juego de supervivencia donde tienes que luchar contra otros jugadores en islas flotantes. Puedes saquear cofres, crear armas y usar habilidades para ganar. </td>
-</tr>
-<tr>
-<td>Construir y disparar</td>
-<td>Un juego creativo donde puedes construir tu propio mapa e invitar a otros a unirse. También puedes disparar a enemigos con diferentes armas y granadas. </td>
-</tr>
-<tr>
-<td>Guerras de huevos</td>
-<td>Un juego similar a Bed Wars, pero con huevos en lugar de camas. Tienes que proteger tu huevo y romper el huevo del enemigo. También puede actualizar su equipo y formar equipo con otros. </td>
-</tr>
-<tr>
-<td>Murder Mystery</td ><td>Un juego de detectives donde tienes que averiguar quién es el asesino entre los jugadores. Puedes ser un detective, un asesino o un inocente. Tienes que usar pistas, armas y lógica para resolver el misterio. </td>
-</tr>
-</tabla>
- <p>Para jugar a estos minijuegos, solo tienes que tocar el icono "Juegos" en la pantalla principal y seleccionar el que desea unirse. También puedes crear tu propia habitación e invitar a tus amigos a jugar contigo. Puedes chatear con otros jugadores usando el sistema de chat del juego o el chat de voz. También puedes enviar emojis, pegatinas y regalos para expresarte. </p>
- <h2>¿Cómo personalizar tu avatar y mostrar tu estilo con Blockman Go Apkmody? </h2>
- <p>Otra gran característica de blockman go es que te permite personalizar tu avatar con diferentes trajes, accesorios, peinados y pieles. Con Blockman ir apkmody, puede obtener todos los artículos de forma gratuita y cambiar su aspecto con la frecuencia que desee. Estas son algunas de las formas en que puedes personalizar tu avatar:</p>
- <ul>
- <li>Vaya al icono "Avatar" en la pantalla principal y seleccione el elemento que desea cambiar. </li>
- <li>Puedes elegir entre diferentes categorías, como ropa, sombreros, gafas, máscaras, alas, colas, mascotas y más. </li>
- <li> También puede utilizar la función "Vestirse" para obtener recomendaciones para el mejor atuendo para usted basado en sus preferencias. </li>
-
- <li>También puedes usar la función "Photo Studio" para tomar fotos de tu avatar y compartirlas con otros. </li>
- </ul>
- <p>Con blockman ir apkmody, puede mostrar su estilo y personalidad con su avatar. También puedes ver los avatares de otros jugadores y complementarlos o hacer amistad con ellos. </p>
- <h2>¿Cómo evitar estafas y hackers con Blockman Go Apkmody? </h2>
- <p>Mientras blockman ir apkmody es un archivo APK modded seguro y confiable que no contiene ningún virus o malware, todavía tiene que tener cuidado al jugar juegos en línea. Hay algunos estafadores y hackers que podrían tratar de engañarte o hacerte daño de alguna manera. Aquí hay algunos consejos sobre cómo evitarlos:</p>
- <ul>
- <li>No comparta su información personal, como su contraseña, dirección de correo electrónico, número de teléfono o datos bancarios con nadie en línea. </li>
- <li>No haga clic en ningún enlace sospechoso o descargar archivos desconocidos de cualquier persona en línea. </li>
- <li <li>No confíes en nadie que afirme ser un miembro del staff o un moderador de blockman go. Es posible que te pidan los detalles de tu cuenta o te ofrezcan artículos o GCubes gratis. No son reales y están tratando de estafarte. </li>
- <li>No utilice ningún otro archivo APK modded o hacks para Blockman go. Pueden contener virus o malware que pueden dañar tu dispositivo o robar tus datos. También pueden hacer que te prohíban jugar. </li>
- <li>No unirse a ningún sitio web no oficial o grupos que afirman estar relacionados con blockman go. Pueden ser sitios de phishing o comunidades falsas que pueden engañarte o enviarte spam. </li>
- </ul>
- <p>Con estos consejos, puede evitar estafas y hackers y disfrutar de Blockman ir apkmody de forma segura. </p>
- <h1>Conclusión</h1>
-
- <p>Si estás interesado en blockman go apkmody, no dudes en descargarlo ahora y pruébalo. No te arrepentirás. Usted tendrá una explosión jugando blockman ir con dinero ilimitado y GCubes. También podrás impresionar a tus amigos y hacer otros nuevos con tu impresionante avatar y habilidades. Blockman go apkmody es la mejor manera de disfrutar de blockman ir al máximo. </p>
- <p>Entonces, ¿qué estás esperando? Descargar blockman ir apkmody ahora y comenzar su aventura en el mundo de los bloques! </p>
- <h2>Preguntas frecuentes</h2>
- <p>Aquí están algunas de las preguntas más frecuentes sobre blockman go apkmody:</p>
- <h3>¿Cuáles son algunos de los minijuegos populares en blockman go? </h3>
-<p>Algunos de los minijuegos populares en blockman go son Bed Wars, Sky Wars, Construir y disparar, Egg Wars y Murder Mystery. Puedes encontrar más minijuegos en el juego tocando el icono "Juegos" en la pantalla principal. </p>
- <h3>¿Qué son los GCubes y cómo puedo conseguirlos gratis? </h3>
-<p>GCubes son la moneda premium en blockman go que puedes usar para comprar artículos especiales, desbloquear funciones VIP, unirse a eventos exclusivos y más. Usted puede conseguir de forma gratuita mediante el uso de blockman ir apkmody, que le da GCubes ilimitada. También puedes conseguirlos completando tareas, viendo anuncios o invitando a amigos. </p>
- <h3>¿Cómo puedo unirme a una fiesta o crear mi propia en blockman go? </h3>
-<p>Puedes unirte a una fiesta o crear la tuya tocando el icono "Fiesta" en la pantalla principal. Puedes invitar a tus amigos u otros jugadores a unirse a tu grupo enviándoles un código o un enlace. También puede unirse a otras partes introduciendo su código o enlace. Puede chatear con los miembros de su grupo y jugar minijuegos juntos. </p>
- <h3>¿Cómo puedo reportar un error o un problema en blockman go? </h3>
-<p>Puede informar de un error o un problema en blockman ir tocando en el "Feedback" icono en la pantalla principal. Puede llenar un formulario con los detalles de su problema y capturas de pantalla y enviarlo al desarrollador. También puede ponerse en contacto con el equipo de soporte por correo electrónico en [email protected]. </p>
-
-<p>Puede ponerse en contacto con el desarrollador o el equipo de soporte de blockman ir por correo electrónico a [email protected]. También puedes seguirlos en sus cuentas de redes sociales, como Facebook, Twitter, Instagram, YouTube, Discord y Reddit.</p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Etiqueta Despus De La Escuela Apk Mod.md

@@ -1,75 +0,0 @@
-<br />
-<h1>Descargar etiqueta después de la escuela APK Mod: Un juego emocionante para Android y iOS</h1>
- <p>¿Estás buscando un juego que te mantenga al borde de tu asiento? ¿Quieres revivir tus días escolares con un toque de horror y misterio? ¿Quieres controlar el destino de un tímido y tímido chico llamado Shota-Kun? Si usted respondió sí a cualquiera de estas preguntas, entonces usted debe descargar Etiqueta Después de la Escuela APK Mod, un juego que le llevará en una aventura emocionante a través de una escuela embrujada. </p>
- <h2>¿Qué es la etiqueta después de la escuela? </h2>
- <p>Tag After School es un juego desarrollado por Genius Studio Japan Inc, una compañía que se especializa en crear juegos de estilo anime para dispositivos móviles. El juego se basa en el clásico juego infantil de la etiqueta, pero con un toque. Puedes competir con amigos o extraños, y obtener acceso a varios personajes, potenciadores y niveles a medida que intentas escapar de tus oponentes. Pero ten cuidado, porque la escuela no es tan inocente como parece. Hay secretos, misterios y peligros acechando en cada esquina. </p>
-<h2>descargar etiqueta después de la escuela apk mod</h2><br /><p><b><b>Download Zip</b> &rArr; <a href="https://bltlly.com/2v6JhB">https://bltlly.com/2v6JhB</a></b></p><br /><br />
- <h3>Un juego basado en el clásico juego de etiquetas</h3>
- <p>El escenario del juego es en una escuela secundaria donde los estudiantes participan en el juego y tienen que esconderse de sus oponentes. Puedes elegir entre diferentes modos, como solo, equipo o supervivencia. También puedes personalizar la apariencia, las habilidades y el equipo de tu personaje. El juego es fácil de jugar, pero difícil de dominar. Tienes que usar tu velocidad, agilidad y estrategia para evitar ser etiquetado. </p>
- <h3>Un juego de terror y misterio</h3>
- <p>El juego no es solo diversión y juegos. También tiene un lado oscuro. La escuela está embrujada por fantasmas, monstruos y trampas que intentarán evitar que escapes. Tienes que tener cuidado a donde vas, porque nunca sabes lo que podría pasar después. El juego tiene una atmósfera espeluznante, con efectos de sonido espeluznantes y gráficos que te harán sentir como si estuvieras en una película de terror. </p>
- <h3>Un juego con una narrativa basada en la historia</h3>
-
- <h2>¿Cómo se juega Tag After School? </h2>
- <p>El juego es simple de jugar, pero difícil de ganar. Aquí hay algunos consejos sobre cómo jugar Tag After School:</p>
- <h3>Elige tu personaje y modo</h3>
- <p>Puedes elegir entre diferentes personajes, cada uno con sus propias fortalezas y debilidades. También puede personalizar su apariencia, habilidades y equipo. Puede elegir entre diferentes modos, como solo, equipo o supervivencia. En el modo en solitario, tienes que etiquetar tantos oponentes como sea posible antes de que acabe el tiempo. En el modo de equipo, tienes que trabajar con tus compañeros de equipo para etiquetar al otro equipo. En el modo de supervivencia, tienes que evitar ser etiquetado por cualquier persona durante el mayor tiempo posible. </p>
- <h3>Ejecutar, ocultar y etiquetar a sus oponentes</h3>
- <p>Tienes que usar el joystick en el lado izquierdo de la pantalla para moverte alrededor del mapa <p>Tienes que usar el joystick en el lado izquierdo de la pantalla para moverte alrededor del mapa. También puede usar los botones en el lado derecho de la pantalla para saltar, deslizarse o etiquetar. Tienes que ser rápido e inteligente, porque tus oponentes tratarán de atraparte o esconderse de ti. También puedes usar el mapa en la esquina superior derecha de la pantalla para ver dónde están tus oponentes. </p>
- <h3>Usa potenciadores y obstáculos para tu ventaja</h3>
- <p>Puedes encontrar diferentes potenciadores y obstáculos en el mapa que pueden ayudarte o dificultarte. Por ejemplo, puedes encontrar un aumento de velocidad que te hará correr más rápido, un escudo que te protegerá de ser etiquetado o una trampa que ralentizará a tus oponentes. También puedes usar objetos como casilleros, escritorios o puertas para esconderte o bloquear a tus enemigos. Sin embargo, hay que tener cuidado, porque algunos power-ups y obstáculos pueden ser contraproducentes o afectar a todos en el mapa. </p>
- <h3>Toma decisiones que determinan el destino de Shota-Kun</h3>
-
- <h2>¿Por qué descargar etiqueta después de la escuela APK Mod? </h2>
- <p>Tag After School es un juego divertido y emocionante que te mantendrá entretenido durante horas. Pero si quieres disfrutar aún más, usted debe descargar Tag After School APK Mod, una versión modificada del juego que le dará características y beneficios ilimitados. Aquí hay algunas razones por las que debe descargar la etiqueta después de la escuela APK Mod:</p>
-<p></p>
- <h3>Disfruta de funciones y beneficios ilimitados</h3>
- <p>Con etiqueta después de la escuela APK Mod, puede acceder a todas las características y beneficios del juego sin restricciones o limitaciones. Puedes desbloquear todos los personajes, potenciadores, niveles y escenarios sin gastar dinero ni tiempo. También puedes obtener monedas y gemas ilimitadas que puedes usar para comprar o actualizar lo que quieras. También puedes eliminar anuncios y disfrutar de una experiencia de juego fluida e ininterrumpida. </p>
- <h3>Experimenta gráficos inmersivos y efectos de sonido</h3>
- <p>Etiqueta Después de la Escuela APK Mod también mejora los gráficos y efectos de sonido del juego, por lo que es más realista y envolvente. Puedes disfrutar de imágenes de alta calidad que te harán sentir como si estuvieras en una escuela real. También puedes escuchar sonidos realistas que te harán saltar o gritar. También puede ajustar la configuración según sus preferencias y especificaciones del dispositivo. </p>
- <h3>Ponte a prueba y crea tus propios argumentos</h3>
- <p>Etiqueta después de la escuela APK Mod también le permite personalizar el juego de acuerdo a su gusto. Puedes crear tus propias historias eligiendo diferentes opciones y resultados. También puedes cambiar el nivel de dificultad del juego ajustando la velocidad, inteligencia y agresividad de tus oponentes. También puedes jugar con tus amigos online o offline, y ver quién es el mejor en la etiqueta. </p>
- <h2>Cómo descargar e instalar la etiqueta después de la escuela APK Mod? </h2>
- <p>Si usted está interesado en descargar e instalar la etiqueta después de la escuela APK Mod, aquí hay algunos pasos simples que usted necesita para seguir:</p>
- <h3>Para dispositivos Android</h3>
- <ol>
-
-<li>Ir a la configuración del dispositivo y habilitar fuentes desconocidas. </li>
-<li>Ir a su administrador de archivos y localizar Tag After School APK Mod archivo. </li>
-<li>Toque en él e instalarlo. </li>
-<li>Iniciar el juego y disfrutar. </li>
-</ol>
- <h3>Para dispositivos iOS</h3>
- <ol>
-<li>Ir a [este enlace] y descargar Tag After School archivo IPA. </li>
-<li>Ir a la configuración del dispositivo y confiar en la etiqueta después de la escuela IPA archivo. </li>
-<li>Vaya a su administrador de archivos y busque el archivo IPA de Tag After School. </li>
-<li>Toque en él e instalarlo. </li>
-<li>Iniciar el juego y disfrutar. </li>
-</ol>
- <h3>Para dispositivos PC</h3>
- <ol>
-<li>Ir a [este enlace] y descargar Tag After School archivo EXE. </li>
-<li>Ir a la configuración de su PC y permitir Tag After School archivo EXE. </li>
-<li>Vaya a su carpeta de descargas y busque el archivo EXE de Tag After School. </li>
-<li>Haga doble clic en él e instalarlo. </li>
-<li>Iniciar el juego y disfrutar. </li>
-</ol>
- <h2>Conclusión</h2>
- <p>Tag After School es un juego que te hará sentir <p>Tag After School es un juego que te hará sentir nostálgico, asustado y emocionado al mismo tiempo. Es un juego que combina la diversión de la etiqueta con la emoción del horror y el misterio. Es un juego que te permite crear tu propia historia y destino. Es un juego que deberías descargar y jugar ahora mismo. </p>
- <p>Si quieres tener la mejor experiencia de juego, usted debe descargar Etiqueta Después de la Escuela APK Mod, una versión modificada del juego que le dará características y beneficios ilimitados. Puedes desbloquear todos los personajes, potenciadores, niveles y escenarios sin problemas. También puedes disfrutar de gráficos y efectos de sonido de alta calidad que te sumergirán en el juego. También puedes desafiarte a ti mismo y crear tus propias historias personalizando el juego según tus preferencias. </p>
-
- <p>Tag After School es un juego que no debes perderte. Es un juego que te mantendrá entretenido durante horas. Es un juego que te hará sentir emociones diferentes. Es un juego que te hará querer jugar más. Entonces, ¿qué estás esperando? Descargar etiqueta después de la escuela APK Mod ahora y divertirse! </p>
- <h2>Preguntas frecuentes</h2>
- <p>Aquí hay algunas preguntas frecuentes sobre la etiqueta después de la escuela APK Mod:</p>
- <h3>¿Es seguro descargar e instalar Tag After School APK Mod? </h3>
- <p>Sí, Etiqueta después de la escuela APK Mod es seguro para descargar e instalar. No contiene ningún virus, malware o spyware que pueda dañar su dispositivo o datos. También es compatible con la mayoría de los dispositivos y sistemas operativos. </p>
- <h3>¿Es Tag After School APK Mod gratis para descargar y jugar? </h3>
- <p>Sí, Etiqueta Después de la Escuela APK Mod es gratis para descargar y jugar. Usted no necesita pagar ningún dinero o cuotas para acceder al juego o sus características. También puedes jugar el juego offline o online sin ningún cargo. </p>
- <h3>¿Cómo puedo actualizar la etiqueta después de la escuela APK Mod? </h3>
- <p>Puede actualizar la etiqueta después de la escuela APK Mod visitando [este enlace] y descargar la última versión del juego. A continuación, puede instalarlo sobre la versión existente del juego sin perder ningún dato o progreso. </p>
- <h3>¿Cómo puedo contactar a los desarrolladores de Tag After School APK Mod? </h3>
- <p>Puede ponerse en contacto con los desarrolladores de Tag After School APK Mod visitando su sitio web oficial o páginas de medios sociales. También puede enviarles un correo electrónico o dejar un comentario en su blog o foro. Siempre están felices de escuchar a sus fans y clientes. </p>
- <h3>¿Cómo puedo compartir mis comentarios o sugerencias sobre Tag After School APK Mod? </h3> 64aa2da5cf<br />
-<br />
-<br />

spaces/Bianca0930/Bianca/README.md

@@ -1,12 +0,0 @@
----
-title: Bianca
-emoji: 🌍
-colorFrom: gray
-colorTo: blue
-sdk: gradio
-sdk_version: 3.18.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Boadiwaa/Recipes/openai/api_resources/embedding.py

@@ -1,58 +0,0 @@
-import base64
-import time
-
-import numpy as np
-
-from openai import util
-from openai.api_resources.abstract import DeletableAPIResource, ListableAPIResource
-from openai.api_resources.abstract.engine_api_resource import EngineAPIResource
-from openai.error import InvalidRequestError, TryAgain
-
-
-class Embedding(EngineAPIResource, ListableAPIResource, DeletableAPIResource):
-    engine_required = False
-    OBJECT_NAME = "embeddings"
-
-    @classmethod
-    def create(cls, *args, **kwargs):
-        """
-        Creates a new embedding for the provided input and parameters.
-
-        See https://beta.openai.com/docs/api-reference/embeddings for a list
-        of valid parameters.
-        """
-        start = time.time()
-        timeout = kwargs.pop("timeout", None)
-        if kwargs.get("model", None) is None and kwargs.get("engine", None) is None:
-            raise InvalidRequestError(
-                "Must provide an 'engine' or 'model' parameter to create an Embedding.",
-                param="engine",
-            )
-
-        user_provided_encoding_format = kwargs.get("encoding_format", None)
-
-        # If encoding format was not explicitly specified, we opaquely use base64 for performance
-        if not user_provided_encoding_format:
-            kwargs["encoding_format"] = "base64"
-
-        while True:
-            try:
-                response = super().create(*args, **kwargs)
-
-                # If a user specifies base64, we'll just return the encoded string.
-                # This is only for the default case.
-                if not user_provided_encoding_format:
-                    for data in response.data:
-
-                        # If an engine isn't using this optimization, don't do anything
-                        if type(data["embedding"]) == str:
-                            data["embedding"] = np.frombuffer(
-                                base64.b64decode(data["embedding"]), dtype="float32"
-                            ).tolist()
-
-                return response
-            except TryAgain as e:
-                if timeout is not None and time.time() > start + timeout:
-                    raise
-
-                util.log_info("Waiting for model to warm up", error=e)

spaces/CNXT/PiX2TXT/README.md

@@ -1,12 +0,0 @@
----
-title: '#://CNXT ❌ #://PiX2TXT'
-emoji: 👁
-colorFrom: blue
-colorTo: red
-sdk: gradio
-sdk_version: 3.27.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/CVH-vn1210/make_hair/app.py

@@ -1,158 +0,0 @@
-import argparse
-import os
-import random
-
-import numpy as np
-import torch
-import torch.backends.cudnn as cudnn
-import gradio as gr
-
-import huggingface_hub as hf
-
-from minigpt4.common.config import Config
-from minigpt4.common.dist_utils import get_rank
-from minigpt4.common.registry import registry
-from minigpt4.conversation.conversation import Chat, CONV_VISION
-
-# imports modules for registration
-from minigpt4.datasets.builders import *
-from minigpt4.models import *
-from minigpt4.processors import *
-from minigpt4.runners import *
-from minigpt4.tasks import *
-
-hf.login(token=os.environ['model_token'])
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Demo")
-    parser.add_argument("--cfg-path", type=str, default='eval_configs/minigpt4.yaml', help="path to configuration file.")
-    parser.add_argument(
-        "--options",
-        nargs="+",
-        help="override some settings in the used config, the key-value pair "
-        "in xxx=yyy format will be merged into config file (deprecate), "
-        "change to --cfg-options instead.",
-    )
-    args = parser.parse_args()
-    return args
-
-
-def setup_seeds(config):
-    seed = config.run_cfg.seed + get_rank()
-
-    random.seed(seed)
-    np.random.seed(seed)
-    torch.manual_seed(seed)
-
-    cudnn.benchmark = False
-    cudnn.deterministic = True
-    
-# ========================================
-#             Model Initialization
-# ========================================
-
-SHARED_UI_WARNING = f'''### [NOTE] It is possible that you are waiting in a lengthy queue.
-
-You can duplicate and use it with a paid private GPU.
-
-<a class="duplicate-button" style="display:inline-block" target="_blank" href="https://huggingface.co/spaces/Vision-CAIR/minigpt4?duplicate=true"><img style="margin-top:0;margin-bottom:0" src="https://huggingface.co/datasets/huggingface/badges/raw/main/duplicate-this-space-xl-dark.svg" alt="Duplicate Space"></a>
-
-Alternatively, you can also use the demo on our [project page](https://minigpt-4.github.io).
-'''
-
-print('Initializing Chat')
-cfg = Config(parse_args())
-
-model_config = cfg.model_cfg
-model_cls = registry.get_model_class(model_config.arch)
-model = model_cls.from_config(model_config).to('cuda:0')
-
-vis_processor_cfg = cfg.datasets_cfg.cc_align.vis_processor.train
-vis_processor = registry.get_processor_class(vis_processor_cfg.name).from_config(vis_processor_cfg)
-chat = Chat(model, vis_processor)
-print('Initialization Finished')
-
-# ========================================
-#             Gradio Setting
-# ========================================
-
-def gradio_reset(chat_state, img_list):
-    if chat_state is not None:
-        chat_state.messages = []
-    if img_list is not None:
-        img_list = []
-    return None, gr.update(value=None, interactive=True), gr.update(placeholder='Please upload your image first', interactive=False), gr.update(value="Upload & Start Chat", interactive=True), chat_state, img_list
-
-def upload_img(gr_img, text_input, chat_state):
-    if gr_img is None:
-        return None, None, gr.update(interactive=True), chat_state, None
-    chat_state = CONV_VISION.copy()
-    img_list = []
-    llm_message = chat.upload_img(gr_img, chat_state, img_list)
-    return gr.update(interactive=False), gr.update(interactive=True, placeholder='Type and press Enter'), gr.update(value="Start Chatting", interactive=False), chat_state, img_list
-
-def gradio_ask(user_message, chatbot, chat_state):
-    if len(user_message) == 0:
-        return gr.update(interactive=True, placeholder='Input should not be empty!'), chatbot, chat_state
-    chat.ask(user_message, chat_state)
-    chatbot = chatbot + [[user_message, None]]
-    return '', chatbot, chat_state
-
-
-def gradio_answer(chatbot, chat_state, img_list, num_beams, temperature):
-    llm_message = chat.answer(conv=chat_state, img_list=img_list, max_new_tokens=300, num_beams=1, temperature=temperature, max_length=2000)[0]
-    chatbot[-1][1] = llm_message
-    return chatbot, chat_state, img_list
-
-title = """<h1 align="center">Demo of MiniGPT-4</h1>"""
-description = """<h3>This is the demo of MiniGPT-4. Upload your images and start chatting!</h3>"""
-article = """<div style='display:flex; gap: 0.25rem; '><a href='https://minigpt-4.github.io'><img src='https://img.shields.io/badge/Project-Page-Green'></a><a href='https://github.com/Vision-CAIR/MiniGPT-4'><img src='https://img.shields.io/badge/Github-Code-blue'></a><a href='https://github.com/TsuTikgiau/blip2-llm/blob/release_prepare/MiniGPT_4.pdf'><img src='https://img.shields.io/badge/Paper-PDF-red'></a></div>
-"""
-
-#TODO show examples below
-
-with gr.Blocks() as demo:
-    gr.Markdown(title)
-    gr.Markdown(SHARED_UI_WARNING)
-    gr.Markdown(description)
-    gr.Markdown(article)
-
-    with gr.Row():
-        with gr.Column(scale=0.5):
-            image = gr.Image(type="pil")
-            upload_button = gr.Button(value="Upload & Start Chat", interactive=True, variant="primary")
-            clear = gr.Button("Restart")
-            
-            num_beams = gr.Slider(
-                minimum=1,
-                maximum=5,
-                value=1,
-                step=1,
-                interactive=True,
-                label="beam search numbers)",
-            )
-            
-            temperature = gr.Slider(
-                minimum=0.1,
-                maximum=2.0,
-                value=1.0,
-                step=0.1,
-                interactive=True,
-                label="Temperature",
-            )
-            
-
-        with gr.Column():
-            chat_state = gr.State()
-            img_list = gr.State()
-            chatbot = gr.Chatbot(label='MiniGPT-4')
-            text_input = gr.Textbox(label='User', placeholder='Please upload your image first', interactive=False)
-    
-    upload_button.click(upload_img, [image, text_input, chat_state], [image, text_input, upload_button, chat_state, img_list])
-    
-    text_input.submit(gradio_ask, [text_input, chatbot, chat_state], [text_input, chatbot, chat_state]).then(
-        gradio_answer, [chatbot, chat_state, img_list, num_beams, temperature], [chatbot, chat_state, img_list]
-    )
-    clear.click(gradio_reset, [chat_state, img_list], [chatbot, image, text_input, upload_button, chat_state, img_list], queue=False)
-
-demo.launch(enable_queue=True)

spaces/CVPR/Dual-Key_Backdoor_Attacks/bottom-up-attention-vqa/tools/detection_features_converter.py

@@ -1,161 +0,0 @@
-"""
-Reads in a tsv file with pre-trained bottom up attention features and
-stores it in HDF5 format.  Also store {image_id: feature_idx}
- as a pickle file.
-
-Hierarchy of HDF5 file:
-
-{ 'image_features': num_images x num_boxes x 2048 array of features
-  'image_bb': num_images x num_boxes x 4 array of bounding boxes }
-"""
-from __future__ import print_function
-
-import os
-import sys
-import argparse
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-import base64
-import csv
-import h5py
-# import cPickle
-import _pickle as cPickle
-import numpy as np
-import utils
-import tqdm
-
-csv.field_size_limit(sys.maxsize)
-FIELDNAMES = ['image_id', 'image_w', 'image_h', 'num_boxes', 'boxes', 'features']
-
-
-def detection_features_converter(dataroot, ver, detector, feature_length, num_fixed_boxes):
-    infile = os.path.join(dataroot, ver, "trainval_%s_%i.tsv"%(detector, num_fixed_boxes))
-
-    train_data_file = os.path.join(dataroot, ver, 'train_%s_%i.hdf5'%(detector, num_fixed_boxes))
-    val_data_file = os.path.join(dataroot, ver, 'val_%s_%i.hdf5'%(detector, num_fixed_boxes))
-    train_indices_file = os.path.join(dataroot, ver, 'train_%s_%i_imgid2idx.pkl'%(detector, num_fixed_boxes))
-    val_indices_file = os.path.join(dataroot, ver, 'val_%s_%i_imgid2idx.pkl'%(detector, num_fixed_boxes))
-    train_ids_file = os.path.join(dataroot, 'train_ids.pkl')
-    val_ids_file = os.path.join(dataroot, 'val_ids.pkl')
-
-    h_train = h5py.File(train_data_file, "w")
-    h_val = h5py.File(val_data_file, "w")
-
-    if os.path.exists(train_ids_file) and os.path.exists(val_ids_file):
-        train_imgids = cPickle.load(open(train_ids_file, 'rb'))
-        val_imgids = cPickle.load(open(val_ids_file, 'rb'))  
-    else:
-        train_imgids = utils.load_imageid(os.path.join(dataroot, 'clean', 'train2014'))
-        val_imgids = utils.load_imageid(os.path.join(dataroot, 'clean', 'val2014'))
-        cPickle.dump(train_imgids, open(train_ids_file, 'wb'))
-        cPickle.dump(val_imgids, open(val_ids_file, 'wb'))
-
-    train_indices = {}
-    val_indices = {}
-
-    train_img_features = h_train.create_dataset(
-        'image_features', (len(train_imgids), num_fixed_boxes, feature_length), 'f')
-    train_img_bb = h_train.create_dataset(
-        'image_bb', (len(train_imgids), num_fixed_boxes, 4), 'f')
-    train_spatial_img_features = h_train.create_dataset(
-        'spatial_features', (len(train_imgids), num_fixed_boxes, 6), 'f')
-
-    val_img_bb = h_val.create_dataset(
-        'image_bb', (len(val_imgids), num_fixed_boxes, 4), 'f')
-    val_img_features = h_val.create_dataset(
-        'image_features', (len(val_imgids), num_fixed_boxes, feature_length), 'f')
-    val_spatial_img_features = h_val.create_dataset(
-        'spatial_features', (len(val_imgids), num_fixed_boxes, 6), 'f')
-
-    train_counter = 0
-    val_counter = 0
-
-    print("reading tsv...")
-    # with open(infile, "r+b") as tsv_in_file:
-    with open(infile, "r") as tsv_in_file:
-        reader = csv.DictReader(tsv_in_file, delimiter='\t', fieldnames=FIELDNAMES)
-        for item in tqdm.tqdm(reader):
-            item['num_boxes'] = int(item['num_boxes'])
-            image_id = int(item['image_id'])
-            image_w = float(item['image_w'])
-            image_h = float(item['image_h'])
-            # bboxes = np.frombuffer(
-            #     base64.decodestring(item['boxes']),
-            #     dtype=np.float32).reshape((item['num_boxes'], -1))
-            bboxes = np.frombuffer(
-                base64.b64decode(item['boxes']),
-                dtype=np.float32).reshape((item['num_boxes'], -1))
-            box_width = bboxes[:, 2] - bboxes[:, 0]
-            box_height = bboxes[:, 3] - bboxes[:, 1]
-            scaled_width = box_width / image_w
-            scaled_height = box_height / image_h
-            scaled_x = bboxes[:, 0] / image_w
-            scaled_y = bboxes[:, 1] / image_h
-
-            box_width = box_width[..., np.newaxis]
-            box_height = box_height[..., np.newaxis]
-            scaled_width = scaled_width[..., np.newaxis]
-            scaled_height = scaled_height[..., np.newaxis]
-            scaled_x = scaled_x[..., np.newaxis]
-            scaled_y = scaled_y[..., np.newaxis]
-
-            spatial_features = np.concatenate(
-                (scaled_x,
-                 scaled_y,
-                 scaled_x + scaled_width,
-                 scaled_y + scaled_height,
-                 scaled_width,
-                 scaled_height),
-                axis=1)
-
-            if image_id in train_imgids:
-                train_imgids.remove(image_id)
-                train_indices[image_id] = train_counter
-                train_img_bb[train_counter, :, :] = bboxes
-                # train_img_features[train_counter, :, :] = np.frombuffer(
-                #     base64.decodestring(item['features']),
-                #     dtype=np.float32).reshape((item['num_boxes'], -1))
-                train_img_features[train_counter, :, :] = np.frombuffer(
-                    base64.b64decode(item['features']),
-                    dtype=np.float32).reshape((item['num_boxes'], -1))
-                train_spatial_img_features[train_counter, :, :] = spatial_features
-                train_counter += 1
-            elif image_id in val_imgids:
-                val_imgids.remove(image_id)
-                val_indices[image_id] = val_counter
-                val_img_bb[val_counter, :, :] = bboxes
-                # val_img_features[val_counter, :, :] = np.frombuffer(
-                #     base64.decodestring(item['features']),
-                #     dtype=np.float32).reshape((item['num_boxes'], -1))
-                val_img_features[val_counter, :, :] = np.frombuffer(
-                    base64.b64decode(item['features']),
-                    dtype=np.float32).reshape((item['num_boxes'], -1))
-                val_spatial_img_features[val_counter, :, :] = spatial_features
-                val_counter += 1
-            else:
-                assert False, 'Unknown image id: %d' % image_id
-
-    if len(train_imgids) != 0:
-        print('Warning: train_image_ids is not empty')
-
-    if len(val_imgids) != 0:
-        print('Warning: val_image_ids is not empty')
-
-    cPickle.dump(train_indices, open(train_indices_file, 'wb'))
-    cPickle.dump(val_indices, open(val_indices_file, 'wb'))
-    # pickle.dump(train_indices, open(train_indices_file, 'w'))
-    # pickle.dump(val_indices, open(val_indices_file, 'w'))
-    h_train.close()
-    h_val.close()
-    print("done!")
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--dataroot', type=str, default='../data/')
-    parser.add_argument('--ver', type=str, default='clean', help='version of the VQAv2 dataset to process. "clean" for the original data. default: clean')
-    parser.add_argument('--detector', type=str, default='R-50')
-    parser.add_argument('--feat', type=int, default=1024, help='feature size')
-    parser.add_argument('--nb', type=int, default=36)
-    args = parser.parse_args()
-    detection_features_converter(args.dataroot, args.ver, args.detector, args.feat, args.nb)

spaces/CVPR/LIVE/thrust/thrust/system/tbb/detail/count.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 count
-#include <thrust/system/cpp/detail/count.h>
-