Update parquet files (step 34 of 397)

spaces/101-5/gpt4free/g4f/Provider/Providers/DFEHub.py

@@ -1,44 +0,0 @@
-import os, requests
-from ...typing import sha256, Dict, get_type_hints
-import json
-
-url = "https://chat.dfehub.com/api/chat"
-model = ['gpt-3.5-turbo']
-supports_stream = False
-needs_auth = False
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
-    base = ''
-    for message in messages:
-        base += '%s: %s\n' % (message['role'], message['content'])
-    base += 'assistant:'
-
-    headers = {
-        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"
-    }
-    data = {
-        "model": {
-            "id": "gpt-3.5-turbo",
-            "name": "GPT-3.5",
-            "maxLength": 12000,
-            "tokenLimit": 4000
-        },
-        "messages": [
-            {
-                "role": "user",
-                "content": base
-            }
-        ],
-        "key": "",
-        "prompt": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
-        "temperature": 1
-    }
-    response = requests.post(url, headers=headers, data=json.dumps(data))
-    if response.status_code == 200:
-        yield response.text
-    else:
-        print(f"Error Occurred::{response.status_code}")
-        return None
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join([f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/123Kumar/vits-uma-genshin-honkai123/modules.py

@@ -1,388 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-import commons
-from commons import init_weights, get_padding
-from transforms import piecewise_rational_quadratic_transform
-
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
-  def __init__(self, channels, eps=1e-5):
-    super().__init__()
-    self.channels = channels
-    self.eps = eps
-
-    self.gamma = nn.Parameter(torch.ones(channels))
-    self.beta = nn.Parameter(torch.zeros(channels))
-
-  def forward(self, x):
-    x = x.transpose(1, -1)
-    x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
-    return x.transpose(1, -1)
-
- 
-class ConvReluNorm(nn.Module):
-  def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
-    super().__init__()
-    self.in_channels = in_channels
-    self.hidden_channels = hidden_channels
-    self.out_channels = out_channels
-    self.kernel_size = kernel_size
-    self.n_layers = n_layers
-    self.p_dropout = p_dropout
-    assert n_layers > 1, "Number of layers should be larger than 0."
-
-    self.conv_layers = nn.ModuleList()
-    self.norm_layers = nn.ModuleList()
-    self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2))
-    self.norm_layers.append(LayerNorm(hidden_channels))
-    self.relu_drop = nn.Sequential(
-        nn.ReLU(),
-        nn.Dropout(p_dropout))
-    for _ in range(n_layers-1):
-      self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2))
-      self.norm_layers.append(LayerNorm(hidden_channels))
-    self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
-    self.proj.weight.data.zero_()
-    self.proj.bias.data.zero_()
-
-  def forward(self, x, x_mask):
-    x_org = x
-    for i in range(self.n_layers):
-      x = self.conv_layers[i](x * x_mask)
-      x = self.norm_layers[i](x)
-      x = self.relu_drop(x)
-    x = x_org + self.proj(x)
-    return x * x_mask
-
-
-class DDSConv(nn.Module):
-  """
-  Dialted and Depth-Separable Convolution
-  """
-  def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
-    super().__init__()
-    self.channels = channels
-    self.kernel_size = kernel_size
-    self.n_layers = n_layers
-    self.p_dropout = p_dropout
-
-    self.drop = nn.Dropout(p_dropout)
-    self.convs_sep = nn.ModuleList()
-    self.convs_1x1 = nn.ModuleList()
-    self.norms_1 = nn.ModuleList()
-    self.norms_2 = nn.ModuleList()
-    for i in range(n_layers):
-      dilation = kernel_size ** i
-      padding = (kernel_size * dilation - dilation) // 2
-      self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size, 
-          groups=channels, dilation=dilation, padding=padding
-      ))
-      self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
-      self.norms_1.append(LayerNorm(channels))
-      self.norms_2.append(LayerNorm(channels))
-
-  def forward(self, x, x_mask, g=None):
-    if g is not None:
-      x = x + g
-    for i in range(self.n_layers):
-      y = self.convs_sep[i](x * x_mask)
-      y = self.norms_1[i](y)
-      y = F.gelu(y)
-      y = self.convs_1x1[i](y)
-      y = self.norms_2[i](y)
-      y = F.gelu(y)
-      y = self.drop(y)
-      x = x + y
-    return x * x_mask
-
-
-class WN(torch.nn.Module):
-  def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=0, p_dropout=0):
-    super(WN, self).__init__()
-    assert(kernel_size % 2 == 1)
-    self.hidden_channels =hidden_channels
-    self.kernel_size = kernel_size,
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.gin_channels = gin_channels
-    self.p_dropout = p_dropout
-
-    self.in_layers = torch.nn.ModuleList()
-    self.res_skip_layers = torch.nn.ModuleList()
-    self.drop = nn.Dropout(p_dropout)
-
-    if gin_channels != 0:
-      cond_layer = torch.nn.Conv1d(gin_channels, 2*hidden_channels*n_layers, 1)
-      self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
-
-    for i in range(n_layers):
-      dilation = dilation_rate ** i
-      padding = int((kernel_size * dilation - dilation) / 2)
-      in_layer = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, kernel_size,
-                                 dilation=dilation, padding=padding)
-      in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
-      self.in_layers.append(in_layer)
-
-      # last one is not necessary
-      if i < n_layers - 1:
-        res_skip_channels = 2 * hidden_channels
-      else:
-        res_skip_channels = hidden_channels
-
-      res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
-      res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
-      self.res_skip_layers.append(res_skip_layer)
-
-  def forward(self, x, x_mask, g=None, **kwargs):
-    output = torch.zeros_like(x)
-    n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
-    if g is not None:
-      g = self.cond_layer(g)
-
-    for i in range(self.n_layers):
-      x_in = self.in_layers[i](x)
-      if g is not None:
-        cond_offset = i * 2 * self.hidden_channels
-        g_l = g[:,cond_offset:cond_offset+2*self.hidden_channels,:]
-      else:
-        g_l = torch.zeros_like(x_in)
-
-      acts = commons.fused_add_tanh_sigmoid_multiply(
-          x_in,
-          g_l,
-          n_channels_tensor)
-      acts = self.drop(acts)
-
-      res_skip_acts = self.res_skip_layers[i](acts)
-      if i < self.n_layers - 1:
-        res_acts = res_skip_acts[:,:self.hidden_channels,:]
-        x = (x + res_acts) * x_mask
-        output = output + res_skip_acts[:,self.hidden_channels:,:]
-      else:
-        output = output + res_skip_acts
-    return output * x_mask
-
-  def remove_weight_norm(self):
-    if self.gin_channels != 0:
-      torch.nn.utils.remove_weight_norm(self.cond_layer)
-    for l in self.in_layers:
-      torch.nn.utils.remove_weight_norm(l)
-    for l in self.res_skip_layers:
-     torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
-        super(ResBlock1, self).__init__()
-        self.convs1 = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                               padding=get_padding(kernel_size, dilation[1]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
-                               padding=get_padding(kernel_size, dilation[2])))
-        ])
-        self.convs1.apply(init_weights)
-
-        self.convs2 = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1)))
-        ])
-        self.convs2.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c1, c2 in zip(self.convs1, self.convs2):
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c1(xt)
-            xt = F.leaky_relu(xt, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c2(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs1:
-            remove_weight_norm(l)
-        for l in self.convs2:
-            remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
-    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
-        super(ResBlock2, self).__init__()
-        self.convs = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                               padding=get_padding(kernel_size, dilation[1])))
-        ])
-        self.convs.apply(init_weights)
-
-    def forward(self, x, x_mask=None):
-        for c in self.convs:
-            xt = F.leaky_relu(x, LRELU_SLOPE)
-            if x_mask is not None:
-                xt = xt * x_mask
-            xt = c(xt)
-            x = xt + x
-        if x_mask is not None:
-            x = x * x_mask
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class Log(nn.Module):
-  def forward(self, x, x_mask, reverse=False, **kwargs):
-    if not reverse:
-      y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
-      logdet = torch.sum(-y, [1, 2])
-      return y, logdet
-    else:
-      x = torch.exp(x) * x_mask
-      return x
-    
-
-class Flip(nn.Module):
-  def forward(self, x, *args, reverse=False, **kwargs):
-    x = torch.flip(x, [1])
-    if not reverse:
-      logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
-      return x, logdet
-    else:
-      return x
-
-
-class ElementwiseAffine(nn.Module):
-  def __init__(self, channels):
-    super().__init__()
-    self.channels = channels
-    self.m = nn.Parameter(torch.zeros(channels,1))
-    self.logs = nn.Parameter(torch.zeros(channels,1))
-
-  def forward(self, x, x_mask, reverse=False, **kwargs):
-    if not reverse:
-      y = self.m + torch.exp(self.logs) * x
-      y = y * x_mask
-      logdet = torch.sum(self.logs * x_mask, [1,2])
-      return y, logdet
-    else:
-      x = (x - self.m) * torch.exp(-self.logs) * x_mask
-      return x
-
-
-class ResidualCouplingLayer(nn.Module):
-  def __init__(self,
-      channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      p_dropout=0,
-      gin_channels=0,
-      mean_only=False):
-    assert channels % 2 == 0, "channels should be divisible by 2"
-    super().__init__()
-    self.channels = channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.half_channels = channels // 2
-    self.mean_only = mean_only
-
-    self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
-    self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, gin_channels=gin_channels)
-    self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
-    self.post.weight.data.zero_()
-    self.post.bias.data.zero_()
-
-  def forward(self, x, x_mask, g=None, reverse=False):
-    x0, x1 = torch.split(x, [self.half_channels]*2, 1)
-    h = self.pre(x0) * x_mask
-    h = self.enc(h, x_mask, g=g)
-    stats = self.post(h) * x_mask
-    if not self.mean_only:
-      m, logs = torch.split(stats, [self.half_channels]*2, 1)
-    else:
-      m = stats
-      logs = torch.zeros_like(m)
-
-    if not reverse:
-      x1 = m + x1 * torch.exp(logs) * x_mask
-      x = torch.cat([x0, x1], 1)
-      logdet = torch.sum(logs, [1,2])
-      return x, logdet
-    else:
-      x1 = (x1 - m) * torch.exp(-logs) * x_mask
-      x = torch.cat([x0, x1], 1)
-      return x
-
-
-class ConvFlow(nn.Module):
-  def __init__(self, in_channels, filter_channels, kernel_size, n_layers, num_bins=10, tail_bound=5.0):
-    super().__init__()
-    self.in_channels = in_channels
-    self.filter_channels = filter_channels
-    self.kernel_size = kernel_size
-    self.n_layers = n_layers
-    self.num_bins = num_bins
-    self.tail_bound = tail_bound
-    self.half_channels = in_channels // 2
-
-    self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
-    self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.)
-    self.proj = nn.Conv1d(filter_channels, self.half_channels * (num_bins * 3 - 1), 1)
-    self.proj.weight.data.zero_()
-    self.proj.bias.data.zero_()
-
-  def forward(self, x, x_mask, g=None, reverse=False):
-    x0, x1 = torch.split(x, [self.half_channels]*2, 1)
-    h = self.pre(x0)
-    h = self.convs(h, x_mask, g=g)
-    h = self.proj(h) * x_mask
-
-    b, c, t = x0.shape
-    h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?]
-
-    unnormalized_widths = h[..., :self.num_bins] / math.sqrt(self.filter_channels)
-    unnormalized_heights = h[..., self.num_bins:2*self.num_bins] / math.sqrt(self.filter_channels)
-    unnormalized_derivatives = h[..., 2 * self.num_bins:]
-
-    x1, logabsdet = piecewise_rational_quadratic_transform(x1,
-        unnormalized_widths,
-        unnormalized_heights,
-        unnormalized_derivatives,
-        inverse=reverse,
-        tails='linear',
-        tail_bound=self.tail_bound
-    )
-
-    x = torch.cat([x0, x1], 1) * x_mask
-    logdet = torch.sum(logabsdet * x_mask, [1,2])
-    if not reverse:
-        return x, logdet
-    else:
-        return x

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download Film 4 and Enjoy Movies Offline Without Ads or Interruptions.md

@@ -1,31 +0,0 @@
-<br />
-<code>
-<h1>How to Download Film 4 and Watch Movies Online</h1>
-<p>If you are a movie lover, you may have heard of Film 4, a British free-to-air television channel that broadcasts a wide range of films, from classics to cults, from indie to mainstream. Film 4 is also available online, where you can stream or download movies on demand. In this article, we will show you how to download Film 4 and watch movies online.</p>
-<h2>What is Film 4?</h2>
-<p>Film 4 is a part of Channel 4, a public-service broadcaster in the UK. Film 4 was launched in 1982 as a subscription-based service, but became free-to-air in 2006. Film 4 is known for its diverse and quality programming, featuring films from various genres, countries, and eras. Film 4 also produces and co-produces original films, such as Slumdog Millionaire, The Favourite, and Three Billboards Outside Ebbing, Missouri.</p>
-<h2>download film 4</h2><br /><p><b><b>Download</b> >>> <a href="https://byltly.com/2uKwOc">https://byltly.com/2uKwOc</a></b></p><br /><br />
-<p>Film 4 has an online platform called All 4, where you can watch live TV or catch up on shows and movies that you missed. All 4 also has a section called Film 4 On Demand, where you can stream or download movies from the Film 4 library. You can access All 4 on various devices, such as computers, smartphones, tablets, smart TVs, game consoles, etc.</p>
-<h2>How to Download Film 4?</h2>
-<p>To download Film 4 and watch movies online, you need to follow these steps:</p>
-<ol>
-<li>Go to the All 4 website at https://www.channel4.com/ or download the All 4 app on your device.</li>
-<li>Sign up for a free account or log in if you already have one.</li>
-<li>Browse or search for the movie that you want to watch.</li>
-<li>Click on the movie and select the option to download it.</li>
-<li>Choose the quality and file size that suits your device and internet connection.</li>
-<li>Wait for the download to finish and enjoy your movie offline.</li>
-</ol>
-<p>Note that not all movies are available for download. You can check the availability by looking for the download icon next to the movie title. Also note that downloaded movies have an expiry date, which means you have to watch them within a certain period of time before they are deleted from your device.</p>
-<h2>What are the Benefits of Downloading Film 4?</h2>
-<p>Downloading Film 4 has many benefits, such as:</p>
-<ul>
-<li>You can watch movies offline without worrying about internet connection or data usage.</li>
-<li>You can watch movies anytime and anywhere without being tied to a TV schedule.</li>
-<li>You can choose the quality and file size that suits your device and storage space.</li>
-<li>You can avoid ads and interruptions that may occur when streaming online.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>In this article, we have shown you how to download Film 4 and watch movies online. Film 4 is a great source of entertainment for movie lovers, offering a wide range of films from various genres, countries, and eras. By downloading Film 4, you can enjoy your movies offline without any hassle. We hope you found this article helpful and informative. If you have any questions</p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Anya Dasha Crazy Holiday.md

@@ -1,6 +0,0 @@
-<h2>Anya Dasha Crazy Holiday</h2><br /><p><b><b>DOWNLOAD</b> &#9675;&#9675;&#9675; <a href="https://imgfil.com/2uy1Si">https://imgfil.com/2uy1Si</a></b></p><br /><br />
-
-Find crazy holiday stock images in HD and millions of other royalty-free stock photos, illustrations and vectors in the Shutterstock collection. Thousands of new ... 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Banjo Marathi Movie Download Dvdrip Movies REPACK.md

@@ -1,6 +0,0 @@
-<h2>Banjo Marathi Movie Download Dvdrip Movies</h2><br /><p><b><b>Download File</b> &#9889; <a href="https://imgfil.com/2uy1N8">https://imgfil.com/2uy1N8</a></b></p><br /><br />
-<br />
-Banjo is a 2016 Indian Hindi-language Action Drama film, directed by Ravi Jadhav and ... "Banjo Movie Review: Riteish Deshmukh's Film is a Pale Shadow of Rock On - NDTV Movies". NDTVMovies.com ... Download as PDF · Printable version ... 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Bloody Ultra Core 3 Keygen High Quality.md

@@ -1,6 +0,0 @@
-<h2>Bloody Ultra Core 3 Keygen</h2><br /><p><b><b>Download File</b> &rArr;&rArr;&rArr; <a href="https://imgfil.com/2uxYx6">https://imgfil.com/2uxYx6</a></b></p><br /><br />
-<br />
-CMJ RADIO 200 AIRPLAY 50 200 AIRPLAY RADIO 200 ADDS C = Core Station A. WHTESTRFES CATPOWER CURSIVE dYNGOiCXM BLACK KEYS CORAL ... SAHARA HOTNGHTS SOLEDAD BROTHERS T-MNUS BLAaEYES ULTRA ... 6S BLUE NOTE 33 1/3 WAFS IVTYfVORNNG JACKET IGUANAS JAYHAWKS ... 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Angry Birds Space 2 APK - Download Now and Start Your Space Adventure with the Angry Birds.md

@@ -1,175 +0,0 @@
-<br />
-<h1>Angry Birds Space 2 APK: A Review of the Latest Version of the Popular Mobile Game</h1>
-<p>Angry Birds Space 2 APK is a physics-based puzzle game and the third game in the Angry Birds series. It was developed and released by Rovio Entertainment Ltd. in March 2021. It follows the tale of an orbital bead, which was stolen by greedy investors. In order to earn back the lost beads, your angry bird has to fly through different space portals and finish all levels in each stage.</p>
-<h2>angry birds space 2 apk</h2><br /><p><b><b>DOWNLOAD</b> &#10002; &#10002; &#10002; <a href="https://urlin.us/2uT1sc">https://urlin.us/2uT1sc</a></b></p><br /><br />
-<p>Angry Birds Space 2 APK is an exciting and fun game that offers intergalactic fun at every turn. It has over 300 levels across 10 planets, including our own Solar System. It also has new playable characters, special abilities, zero-gravity space adventures, trick shots, hidden bonus levels, daily missions, and more. If you are a fan of Angry Birds or puzzle games in general, you should definitely download and play this game.</p>
-<p>In this article, we will review the features, gameplay, tips, comparison, rating, and pros and cons of Angry Birds Space 2 APK. We will also show you how to download and install the game on your Android device. By the end of this article, you will have a clear idea of whether this game is worth your time and money or not.</p>
- <h2>Features of Angry Birds Space 2 APK</h2>
-<p>Angry Birds Space 2 APK has many features that make it stand out from other puzzle games. Here are some of them:</p>
-<p>angry birds space 2 apk download<br />
-angry birds space 2 apk mod<br />
-angry birds space 2 apk free<br />
-angry birds space 2 apk full version<br />
-angry birds space 2 apk android<br />
-angry birds space 2 apk latest version<br />
-angry birds space 2 apk offline<br />
-angry birds space 2 apk unlimited money<br />
-angry birds space 2 apk obb<br />
-angry birds space 2 apk hack<br />
-angry birds space 2 apk for pc<br />
-angry birds space 2 apk revdl<br />
-angry birds space 2 apk uptodown<br />
-angry birds space 2 apk pure<br />
-angry birds space 2 apk mirror<br />
-angry birds space 2 apk rexdl<br />
-angry birds space 2 apk data<br />
-angry birds space 2 apk old version<br />
-angry birds space 2 apk no ads<br />
-angry birds space 2 apk cracked<br />
-angry birds space 2 apk game<br />
-angry birds space 2 apk file<br />
-angry birds space 2 apk mob.org<br />
-angry birds space 2 apk apkpure<br />
-angry birds space 2 apk appvn<br />
-angry birds space 2 apk mod menu<br />
-angry birds space 2 apk all levels unlocked<br />
-angry birds space 2 apk android oyun club<br />
-angry birds space 2 apk andropalace<br />
-angry birds space 2 apk aptoide<br />
-angry birds space 2 apk android republic<br />
-angry birds space 2 apk blackmod<br />
-angry birds space 2 apk bluestacks<br />
-angry birds space 2 apk by rovio entertainment corporation<br />
-angry birds space 2 apk cheat codes<br />
-angry birds space 2 apk coins hack<br />
-angry birds space 2 apk direct download link<br />
-angry birds space 2 apk download for android phoneky.com <br />
-angry birds space 2 apk download highly compressed <br />
-angry birds space 2 apk download mobomarket</p>
-<ul>
-<li><b>Over 300 interstellar levels across 10 planets</b>: You can play over 300 levels across different planets, such as Cold Cuts, Red Planet, Utopia, Solar System, etc. Each planet has its own theme, challenges, enemies, and surprises. You can also unlock new episodes as you progress through the game.</li>
-<li><b>New playable characters and unique special abilities for each bird</b>: You can use different birds to fling at the pigs, such as Red Bird, Bomb Bird, Ice Bird, Lazer Bird, etc. Each bird has its own special ability that can help you in different situations. For example, Lazer Bird can change direction in mid-air, Ice Bird can freeze objects, etc. You can also unlock new birds as you play.</li>
-<li><b>Zero-gravity space adventures and trick shots using planets' gravity</b>: One of the most interesting features of Angry Birds Space 2 APK is the zero-gravity space environment. You can use the gravity of the planets to make trick shots and hit the pigs in creative ways. You can also use the space debris, asteroids, and other objects to your advantage. The game physics are realistic and fun to experiment with.</li>
-<li><b>Hidden bonus levels and beautifully detailed backgrounds</b>: You can find hidden bonus levels in each planet by looking for golden eggs, stars, or other clues. These bonus levels offer extra challenges and rewards. You can also enjoy the stunning graphics and backgrounds of the game, which are colorful, detailed, and immersive.</li>
-<li><b>Daily missions and achievements</b>: You can complete daily missions to earn coins, power-ups, and other rewards. You can also unlock achievements by completing certain tasks or reaching certain milestones. These features add more replay value and motivation to the game.</li>
-</ul>
- <h2>How to Download and Install Angry Birds Space 2 APK</h2>
-<p>Angry Birds Space 2 APK is not available on the Google Play Store, so you will need to download it from a third-party source. Here are the steps on how to do that:</p>
-<ol>
-<li><b>Enable unknown sources on your device</b>: Go to Settings > Security > Unknown Sources and toggle it on. This will allow you to install apps from sources other than the Google Play Store.</li>
-<li><b>Download Angry Birds Space 2 APK file</b>: You can download the APK file from various websites, such as APKPure, APKMirror, etc. Make sure you download it from a trusted and reliable source. You can also scan the file with an antivirus app before installing it.</li>
-<li><b>Install Angry Birds Space 2 APK file</b>: Locate the downloaded file on your device and tap on it. Follow the instructions on the screen to install the app. It may take a few minutes depending on your device and internet speed.</li>
-<li><b>Launch Angry Birds Space 2 APK</b>: Once the installation is done, you can launch the app from your app drawer or home screen. Enjoy playing Angry Birds Space 2 APK!</li>
-</ol>
-<p>Tips on how to avoid malware and viruses when downloading APK files:</p>
-<ul>
-<li><b>Do some research before downloading</b>: Check the reviews, ratings, comments, and feedback of the app and the website you are downloading from. Look for any red flags or signs of malware or viruses.</li>
-<li><b>Use a VPN service</b>: A VPN service can protect your online privacy and security by encrypting your data and hiding your IP address. It can also help you bypass geo-restrictions and access blocked websites.</li>
-<li><b>Update your device and apps regularly</b>: Updating your device and apps can fix any bugs or vulnerabilities that may expose you to malware or viruses. It can also improve your device performance and stability.</li>
-</ul>
- <h2>Gameplay and Tips of Angry Birds Space 2 APK</h2>
-<p>Angry Birds Space 2 APK is a simple yet addictive game that anyone can play. Here are some basics on how to play the game and use the different birds and their abilities:</p>
-<ul>
-<li><b>How to play the game</b>: The game consists of different levels across different planets. In each level, you have to fling angry birds at the pigs using a slingshot. Your goal is to destroy all the pigs and their structures using as few birds as possible. You can also collect stars, coins, power-ups, and other items along the way.</li>
-<li><b>How to use the different birds and their abilities</b>: Each bird has its own color, shape, size, weight, and special ability. You can tap on the screen while flinging a bird to activate its ability. Here are some examples of the birds and their abilities:</li>
-<ul>
-<li><b>Red Bird</b>: The most basic bird that has no special ability. It is good for breaking wood and glass.</li>
-<li><b>Bomb Bird</b>: A black bird that explodes when tapped or after hitting something. It is good for breaking stone and metal.</li>
-<li><b>Ice Bird</b>: A blue bird that freezes objects when tapped or after hitting something. It is good for making objects brittle and easier to break.</li>
-<li><b>Lazer Bird</b>: A purple bird that changes direction in mid-air when tapped. It is good for hitting hard-to-reach targets or making curved shots.</li>
-<li><b>And more...</b>: There are many more birds that you can unlock and use in the game, such as Terence, Stella, Bubbles, Hal, etc. Each one has its own unique ability that can help you in different situations.</li>
-</ul>
-</ul>
-<p p>Tips and tricks on how to complete the levels and get three stars:</p>
-<ul>
-<li><b>Use the right bird for the right job</b>: Try to match the bird's ability with the type of material or structure you are aiming at. For example, use Bomb Bird for stone and metal, Ice Bird for wood and glass, etc.</li>
-<li><b>Use the gravity of the planets</b>: You can use the gravity of the planets to make curved shots or hit multiple targets with one bird. You can also use the space debris, asteroids, and other objects to bounce or ricochet your birds.</li>
-<li><b>Use power-ups wisely</b>: You can use power-ups to boost your birds' abilities or get extra birds. For example, you can use the King Sling to fling your birds faster and farther, the Sling Scope to aim more accurately, the Birdquake to shake the ground and make structures collapse, etc. However, power-ups are limited and cost coins, so use them sparingly and only when necessary.</li>
-<li><b>Replay levels to improve your score</b>: You can replay any level you have completed to try to get a better score or more stars. You can also try different strategies or birds to see what works best for you.</li>
-<li><b>Watch videos or read guides for help</b>: If you are stuck on a level or want to learn more tips and tricks, you can watch videos or read guides online. There are many websites and YouTube channels that offer walkthroughs, tutorials, and tips for Angry Birds Space 2 APK.</li>
-</ul>
- <h2>Comparison with Angry Birds Space</h2>
-<p>Angry Birds Space 2 APK is a sequel to Angry Birds Space, which was released in 2012. Angry Birds Space was the first game in the series that introduced the space theme and the zero-gravity physics. It was also a huge success and received positive reviews from critics and users alike.</p>
-<p>Angry Birds Space 2 APK is similar to Angry Birds Space in many ways, but it also has some differences. Here are some of them:</p>
-<table>
-<tr>
-<th>Angry Birds Space</th>
-<th>Angry Birds Space 2 APK</th>
-</tr>
-<tr>
-<td>- Has over 200 levels across 9 planets</td>
-<td>- Has over 300 levels across 10 planets</td>
-</tr>
-<tr>
-<td>- Has 8 playable characters with different abilities</td>
-<td>- Has 12 playable characters with different abilities</td>
-</tr>
-<tr>
-<td>- Has boss battles with King Pig, Fat Pig, etc.</td>
-<td>- Has boss battles with greedy investors, etc.</td>
-</tr>
-<tr>
-<td>- Has golden eggs and eggsteroids as hidden bonus levels</td>
-<td>- Has golden eggs and stars as hidden bonus levels</td>
-</tr>
-<tr>
-<td>- Has power-ups such as Super Seeds, Space Eagles, etc.</td>
-<td>- Has power-ups such as King Sling, Sling Scope, Birdquake, etc.</td>
-</tr>
-<tr <td>- Has a simple and cartoonish graphics style</td>
-<td>- Has a more detailed and realistic graphics style</td>
-</tr>
-<tr>
-<td>- Has a space-themed soundtrack and sound effects</td>
-<td>- Has a more varied and dynamic soundtrack and sound effects</td>
-</tr>
-</table>
-<p>Pros and cons of each version:</p>
-<table>
-<tr>
-<th>Angry Birds Space</th>
-<th>Angry Birds Space 2 APK</th>
-</tr>
-<tr>
-<td>- Pros: Original, innovative, fun, challenging, addictive, nostalgic</td>
-<td>- Pros: Improved, updated, expanded, diverse, engaging, rewarding</td>
-</tr>
-<tr>
-<td>- Cons: Repetitive, outdated, limited, easy, boring</td>
-<td>- Cons: Unoriginal, derivative, complex, hard, frustrating</td>
-</tr>
-</table>
-<p>Which one is better and why:</p>
-<p>Both Angry Birds Space and Angry Birds Space 2 APK are great games that offer hours of entertainment and enjoyment. However, if we have to choose one, we would say that Angry Birds Space 2 APK is better than Angry Birds Space. This is because Angry Birds Space 2 APK has more levels, characters, features, power-ups, graphics, and sounds than Angry Birds Space. It also has more variety, challenge, and replay value than Angry Birds Space. Therefore, we think that Angry Birds Space 2 APK is a superior game that deserves your attention and appreciation.</p>
- <h2>Rating and Review of Angry Birds Space 2 APK</h2>
-<p>Angry Birds Space 2 APK is a highly rated game by users and critics alike. It has an average rating of 4.5 out of 5 stars on various websites and platforms. It also has many positive reviews and feedback from users who praise the game for its gameplay, graphics, sound, features, etc.</p>
-<p>Here are some of the pros and cons of the game based on user feedback:</p>
-<ul>
-<li><b>Pros</b>: Fun, addictive, challenging, creative, beautiful, smooth, diverse, rewarding</li>
-<li><b>Cons</b>: Difficult, frustrating, buggy, laggy, expensive, ads, crashes</li>
-</ul>
-<p>Here are some of the strengths and weaknesses of the game based on gameplay, graphics , sound, etc.:</p>
-<ul>
-<li><b>Strengths</b>: The game has a unique and innovative gameplay that combines physics, puzzle, and strategy elements. It also has a stunning and realistic graphics style that creates a immersive and captivating space environment. The game also has a dynamic and varied soundtrack and sound effects that enhance the mood and atmosphere of the game.</li>
-<li><b>Weaknesses</b>: The game can be very difficult and frustrating at times, especially in the later levels. It can also have some bugs and glitches that affect the performance and stability of the game. The game also has some in-app purchases and ads that can be annoying and expensive.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>Angry Birds Space 2 APK is a fantastic game that offers a lot of fun and challenge for puzzle lovers and Angry Birds fans. It has over 300 levels across 10 planets, new playable characters, special abilities, zero-gravity space adventures, trick shots, hidden bonus levels, daily missions, and more. It also has a beautiful and realistic graphics style, a dynamic and varied soundtrack and sound effects, and a simple and intuitive user interface.</p>
-<p>However, the game can also be very difficult and frustrating at times, especially in the later levels. It can also have some bugs and glitches that affect the performance and stability of the game. The game also has some in-app purchases and ads that can be annoying and expensive.</p>
-<p>Therefore, we recommend that you download and play Angry Birds Space 2 APK if you are looking for a fun and challenging puzzle game that will keep you entertained for hours. However, be prepared to face some difficulties and frustrations along the way. You can also compare it with Angry Birds Space to see which one you like better.</p>
- <h3>FAQs</h3>
-<p>Here are some frequently asked questions about Angry Birds Space 2 APK:</p>
-<ul>
-<li><b>Q1: Is Angry Birds Space 2 APK free?</b></li>
-<li><b>A1: Yes, Angry Birds Space 2 APK is free to download and play. However, it has some in-app purchases and ads that can enhance your gaming experience or remove some limitations.</b></li>
-<li><b>Q2: Is Angry Birds Space 2 APK safe?</b></li>
-<li><b>A2: Yes, Angry Birds Space 2 APK is safe to download and play. However, you should always download it from a trusted and reliable source. You should also scan the file with an antivirus app before installing it. You should also enable unknown sources on your device only when necessary.</b></li>
-<li><b>Q3: Is Angry Birds Space 2 APK compatible with my device?</b></li>
-<li><b>A3: Angry Birds Space 2 APK is compatible with most Android devices that run on Android 4.4 or higher. However, some devices may have different specifications or features that may affect the performance or compatibility of the game. You can check the minimum requirements of the game on the website or platform you are downloading from.</b></li>
-<li><b>Q4: How can I update Angry Birds Space 2 APK?</b></li>
-<li><b>A4: You can update Angry Birds Space 2 APK by downloading and installing the latest version of the game from the same source you downloaded it from. You can also check for updates within the game settings or menu.</b></li>
-<li><b>Q5: How can I contact the developers of Angry Birds Space 2 APK?</b></li>
-<li><b>A5: You can contact the developers of Angry Birds Space 2 APK by visiting their official website or social media pages. You can also send them an email or leave them a feedback or review on the website or platform you downloaded the game from.</b></li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download CarX Drift Racing 2 Mod Apk Obb Data for Android.md

@@ -1,139 +0,0 @@
-<br />
-<h1>CarX Drift Racing 2 OBB: A Guide for Android Users</h1>
-<p>If you are a fan of drifting games, you might have heard of CarX Drift Racing 2, one of the most popular and realistic drift racing games on Android. But did you know that there is a way to enhance your gaming experience even more? In this article, we will show you what CarX Drift Racing 2 OBB is, why you need it, how to download and install it on your device, and what are its features and benefits. Let's get started!</p>
- <h2>What is CarX Drift Racing 2 OBB and why do you need it?</h2>
-<p>OBB stands for Opaque Binary Blob, which is a type of file that contains additional data for some Android apps. These files are usually large in size and are stored in a separate folder on your device. They work together with APK files, which are the main files that install apps on your device.</p>
-<h2>carx drift racing 2 obb</h2><br /><p><b><b>Download</b> &#10040; <a href="https://jinyurl.com/2uNSc2">https://jinyurl.com/2uNSc2</a></b></p><br /><br />
-<p>CarX Drift Racing 2 is a game that requires an OBB file to run properly. This is because the game has high-quality graphics, sound effects, and animations that cannot fit in a single APK file. The OBB file contains all the extra data that makes the game look and sound amazing.</p>
-<p>By using the OBB file for CarX Drift Racing 2, you can enjoy faster loading times, smoother performance, and more content in the game. You can access more tracks, cars, skins, and body parts that are not available in the APK file alone. You can also save space on your device by deleting the APK file after installing the OBB file.</p>
- <h2>How to download and install CarX Drift Racing 2 OBB on your Android device?</h2>
-<p>Downloading and installing CarX Drift Racing 2 OBB on your Android device is easy if you follow these steps:</p>
-<ol>
-<li>Download the APK file and the OBB file from a reliable source. You can find them on websites like [APKPure](^1^) or [GameGuardian](^2^). Make sure you download the latest version of both files.</li>
-<li>Install the APK file on your device by tapping on it. You might need to enable unknown sources in your settings to do this.</li>
-<li>Locate the OBB file on your device using a file manager app. It should be in a zip or rar format.</li>
-<li>Extract the O BB file to a folder on your device. The folder should be named com.carxtech.carxdr2 and should be located in Android/obb.</li>
-<li>Copy the OBB file to the com.carxtech.carxdr2 folder. The OBB file should have a name like main.1234.com.carxtech.carxdr2.obb, where 1234 is the version number.</li>
-<li>Launch the game and enjoy!</li>
-</ol>
-<p>If you have any problems with the installation, you can check the troubleshooting section below.</p>
- <h2>What are the features and benefits of CarX Drift Racing 2 OBB?</h2>
-<p>CarX Drift Racing 2 is a game that will satisfy your need for speed and adrenaline. It is a realistic and immersive drift racing game that lets you customize your cars, compete with other players, and master your drifting skills. Here are some of the features and benefits of CarX Drift Racing 2 OBB:</p>
-<ul>
-<li>Realistic physics: The game uses a sophisticated physics engine that simulates the behavior of real cars on different surfaces and conditions. You can feel the weight, traction, and inertia of your car as you drift around corners and curves.</li>
-<li>Customizable cars: You can choose from over 80 cars from different brands and models. You can also modify your cars with various body parts, skins, wheels, tires, suspension, engine, and more. You can create your own unique style and show it off to other players.</li>
-<li>Online multiplayer: You can join online races and tournaments with other players from around the world. You can challenge your friends or random opponents in different modes, such as tandem drifting, sprint racing, or capture the flag. You can also join clubs and teams to cooperate and compete with other players.</li>
-<li>Career mode: You can progress through a series of events and missions that will test your drifting skills and earn you rewards. You can unlock new cars, tracks, parts, and achievements as you advance in your career. You can also improve your reputation and rank among other drifters.</li>
-</ul>
-<p>By using the OBB file for CarX Drift Racing 2, you can access more content and features that are not available in the APK file alone. Here is a table that compares the game size and content with and without the OBB file:</p>
-<p>carx drift racing 2 apk obb download<br />
-carx drift racing 2 mod apk obb<br />
-carx drift racing 2 android game obb<br />
-carx drift racing 2 apk xapk obb<br />
-carx drift racing 2 apk combo obb<br />
-carx drift racing 2 apk data obb<br />
-carx drift racing 2 apk full obb<br />
-carx drift racing 2 apk latest version obb<br />
-carx drift racing 2 apk offline obb<br />
-carx drift racing 2 apk pure obb<br />
-carx drift racing 2 apk revdl obb<br />
-carx drift racing 2 apk unlimited money obb<br />
-carx drift racing 2 apk update obb<br />
-carx drift racing 2 game guardian obb<br />
-carx drift racing 2 game for android obb<br />
-carx drift racing 2 game for pc obb<br />
-carx drift racing 2 game free download obb<br />
-carx drift racing 2 game online obb<br />
-carx drift racing 2 game play store obb<br />
-carx drift racing 2 game review obb<br />
-carx drift racing 2 hack apk obb<br />
-carx drift racing 2 hack mod obb<br />
-carx drift racing 2 hack version obb<br />
-carx drift racing 2 install xapk obb<br />
-carx drift racing 2 mod menu obb<br />
-carx drift racing 2 mod money obb<br />
-carx drift racing 2 mod unlocked obb<br />
-carx drift racing 2 new update obb<br />
-carx drift racing 2 old version obb<br />
-carx drift racing 2 original apk obb<br />
-carx drift racing 2 premium apk obb<br />
-carx drift racing 2 pro apk obb<br />
-carx drift racing 2 rexdl apk obb<br />
-carx drift racing 2 sequel apk obb<br />
-carx drift racing 2 tips and tricks obb<br />
-carx drift racing 2 unlimited coins obb<br />
-carx drift racing 2 unlimited gold obb<br />
-carx drift racing 2 v1.1.0 apk obb<br />
-carx drift racing 2 v1.26.1 apk obb<br />
-how to download carx drift racing 2 with obb file <br />
-how to install carx drift racing 2 with obb file <br />
-how to play carx drift racing 2 with obb file <br />
-how to update carx drift racing 2 with obb file <br />
-what is the size of carx drift racing 2 with obb file <br />
-where to download carx drift racing 2 with obb file</p>
- <table>
-<tr>
-<th>Game size</th>
-<th>Tracks</th>
-<th>Cars</th>
-<th>Skins</th>
-<th>Body parts</th>
-</tr>
-<tr>
-<td>Without OBB file</td>
-<td>10</td>
-<td>20</td>
-<td>50</td>
-<td>100</td>
-</tr>
-<tr>
-<td>With OBB file</td>
-<td>30</td>
-<td>80</td>
-<td>200</td>
-<td>500</td>
-</tr>
-</table>
- <h3>Conclusion</h3>
-<p>In conclusion, CarX Drift Racing 2 OBB is a must-have for any drift racing fan who wants to enjoy the full potential of the game. By downloading and installing the OBB file on your Android device, you can experience faster loading times, smoother performance, and more content in the game. You can also save space on your device by deleting the APK file after installing the OBB file.</p>
- <p>If you are ready to take your drifting skills to the next level, download CarX Drift Racing 2 OBB today and join the millions of players who are already hooked on this amazing game. You will not regret it!</p>
- <h4>FAQs</h4>
- <p>Here are some frequently asked questions about CarX Drift Racing 2 OBB:</p>
- <ol>
-<li><b>How do I update CarX Drift Racing 2 OBB?</b></li>
-<p>To update CarX Drift Racing 2 OBB, you need to download the latest version of both the APK file and the OBB file from a reliable source. Then, you need to install the APK file on your device and copy the OBB file to the com.carxtech.carxdr2 folder on your device. You can overwrite the old files with the new ones.</p>
- <li><b>How do I fix errors or crashes with CarX Drift Racing 2 OBB?</b></li>
-<p>If you encounter any errors or crashes with CarX Drift Racing 2 OBB, you can try these solutions:</p>
-<ul>
-<li>Make sure you have enough storage space on your device.</li>
-<li>Make sure you have a stable internet connection.</li>
-<li>Make sure you have downloaded the correct version of both the APK file and the OBB file for your device.</li>
-<li>Make sure you have copied the OBB file to the correct folder on your device.</li>
-<li>Make sure you have granted the necessary permissions to the game, such as storage, network, and location.</li>
-<li>Clear the cache and data of the game from your settings.</li>
-<li>Restart your device and try again.</li>
-</ul>
-<p>If none of these solutions work, you can contact the developer of the game for further assistance.</p>
- <li><b>How do I uninstall CarX Drift Racing 2 OBB?</b></li>
-<p>To uninstall CarX Drift Racing 2 OBB, you need to delete both the APK file and the OBB file from your device. You can do this by following these steps:</p>
-<ol>
-<li>Go to your settings and find the app manager or application list.</li>
-<li>Find CarX Drift Racing 2 and tap on it.</li>
-<li>Tap on uninstall and confirm your choice.</li>
-<li>Go to your file manager app and find the Android/obb folder.</li>
-<li>Delete the com.carxtech.carxdr2 folder and its contents.</li>
-</ol>
-<p>You have successfully uninstalled CarX Drift Racing 2 OBB from your device.</p>
- <li><b>Is CarX Drift Racing 2 OBB safe to use?</b></li>
-<p>CarX Drift Racing 2 OBB is safe to use as long as you download it from a trusted source. You should avoid downloading it from unknown or suspicious websites that might contain malware or viruses. You should also scan the files with an antivirus app before installing them on your device. You should also be careful not to share your personal or financial information with any third-party apps or websites that claim to offer cheats or hacks for the game.</p>
- <li><b>What are some tips and tricks for CarX Drift Racing 2 OBB?</b></li>
-<p>Here are some tips and tricks that can help you improve your drifting skills and enjoy the game more:</p>
-<ul>
-<li>Practice on different tracks and cars to learn how they handle and react to different situations.</li>
-<li>Adjust your settings and controls to suit your preferences and comfort level.</li>
-<li>Use the tuning feature to optimize your car's performance and appearance.</li>
-<li>Watch replays and ghost races to learn from other players and improve your techniques.</li>
-<li>Join clubs and teams to chat, cooperate, and compete with other players.</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Euro Truck Simulator 3 Europa The Ultimate Truck Driving Game for Android.md

@@ -1,114 +0,0 @@
-<br />
-<h1>European Truck Simulator 3: A Review of the Best Truck Driving Game</h1>
- <p>Do you love driving trucks and delivering cargo across different countries? Do you want to experience the thrill and challenge of being a professional trucker? If yes, then you should try European Truck Simulator 3, the latest and most realistic truck simulation game ever made. In this article, we will review ETS3 and tell you why it is the best truck driving game you can play. We will also show you how to download and install ETS3 APK on your Android device, so you can enjoy this amazing game anytime, anywhere.</p>
-<h2>european truck simulator 3 apk download</h2><br /><p><b><b>Download</b> &#10022;&#10022;&#10022; <a href="https://jinyurl.com/2uNOeX">https://jinyurl.com/2uNOeX</a></b></p><br /><br />
- <h2>What is European Truck Simulator 3?</h2>
- <p>Euro Truck Simulator 3 (ETS3) is a video game developed by SCS Software, the same studio that created the popular Euro Truck Simulator 2 (ETS2). ETS3 is the third instalment in the Euro Truck Simulator series, which started in 2008. ETS3 is expected to be released in 2028 for PC, PS5, and Xbox consoles, according to some rumors and news sources . However, there is no official confirmation or announcement from the developers yet.</p>
- <h3>The gameplay and features of ETS3</h3>
- <p>ETS3 is a truck simulation game that lets you drive various trucks and trailers across Europe. You can choose from different truck models, chassis configurations, customizations, and cosmetics. You can also select your job and deliver your cargo to different destinations. You have to follow the traffic rules, manage your fuel, damage, fatigue, and other factors that affect your driving performance. You can also interact with other drivers, hire employees, buy garages, and expand your business.</p>
- <p>ETS3 features a realistic and immersive truck physics system that makes driving feel like real life. You can feel the weight, speed, acceleration, braking, steering, suspension, and other aspects of your truck. You can also hear the authentic engine sounds, horn sounds, tire sounds, and other sound effects that add to the atmosphere. You can also adjust the camera angles, mirrors, lights, indicators, wipers, cruise control, and other controls to suit your preference.</p>
- <p>ETS3 also features a vast and detailed map of Europe that covers dozens of cities and countries. You can travel across highways, country roads, urban roads, mountain roads, tunnels, bridges, tolls, ferries, and other types of roads. You can see the landmarks, buildings, landscapes, weather conditions, day and night cycle, seasons, and other elements that make each location unique. You can also encounter different types of traffic vehicles, pedestrians, animals, events, accidents, roadworks, police patrols, tolls, and other situations that make your journey more dynamic and unpredictable.</p>
- <h3>The system requirements and platforms of ETS3</h3>
- <p>ETS3 is expected to have higher system requirements than ETS2 due to its improved graphics and physics engine. According to some sources, these are the minimum and recommended system requirements for ETS3 on PC:</p>
-<p>Truckers of Europe 3 android game download<br />
-How to install european truck simulator 3 on mobile<br />
-Best truck driving simulator games for android<br />
-European truck simulator 3 apk mod unlimited money<br />
-Download european truck simulator 3 latest version<br />
-European truck simulator 3 gameplay and features<br />
-Free download european truck simulator 3 for android<br />
-European truck simulator 3 review and rating<br />
-European truck simulator 3 cheats and tips<br />
-European truck simulator 3 online multiplayer mode<br />
-European truck simulator 3 system requirements and compatibility<br />
-European truck simulator 3 update and patch notes<br />
-European truck simulator 3 trailer and screenshots<br />
-European truck simulator 3 support and feedback<br />
-European truck simulator 3 download link and file size<br />
-How to play european truck simulator 3 offline<br />
-European truck simulator 3 maps and routes<br />
-European truck simulator 3 customization and options<br />
-European truck simulator 3 realistic physics and graphics<br />
-European truck simulator 3 challenges and achievements<br />
-How to unlock all trucks in european truck simulator 3<br />
-European truck simulator 3 vs american truck simulator<br />
-How to backup and restore european truck simulator 3 data<br />
-European truck simulator 3 guide and tutorial<br />
-European truck simulator 3 best trucks and trailers<br />
-How to fix european truck simulator 3 errors and bugs<br />
-European truck simulator 3 mod apk download free<br />
-How to connect european truck simulator 3 with steering wheel<br />
-European truck simulator 3 sound effects and music<br />
-European truck simulator 3 traffic and weather conditions<br />
-How to speed up european truck simulator 3 performance<br />
-European truck simulator 3 skins and accessories<br />
-How to change language in european truck simulator 3<br />
-European truck simulator 3 forum and community<br />
-European truck simulator 3 news and updates<br />
-How to record and share european truck simulator 3 gameplay videos<br />
-European truck simulator 3 tips and tricks for beginners<br />
-How to get more money in european truck simulator 3<br />
-European truck simulator 3 comparison with other simulators<br />
-How to download european truck simulator 3 for pc<br />
-European truck simulator 3 controller support and settings<br />
-How to enable vr mode in european truck simulator 3<br />
-European truck simulator 3 best mods and addons<br />
-How to create your own mods for european truck simulator 3<br />
-European truck simulator 3 faq and troubleshooting<br />
-How to join a convoy in european truck simulator 3 online mode</p>
- <table>
-<tr>
-<th>Minimum</th>
-<th>Recommended</th>
-</tr>
-<tr>
-<td>OS: Windows XP or Windows Vista<br>CPU: Processor 2.4 GHz Intel Pentium 4 or equivalent<br>GPU: 128 MB video card: GeForce 4 (not MX!) or better, ATI Radeon 8500 or better<br>RAM: 512 MB RAM (1 GB on Windows Vista)<br>HDD: 600 MB of free hard drive space<br>DirectX: DirectX 9.0</td>
-<td>OS: Windows XP or Windows Vista<br>CPU: Processor 3.0 GHz Intel Pentium 4 or equivalent<br>GPU: 256 MB video card: GeForce 6 or better, ATI Radeon 9800 or better<br>RAM: 1 GB RAM (2 GB on Windows Vista)<br>HDD: 1.5 GB of free hard drive space<br>DirectX: DirectX 9.0c</td>
-</tr>
-</table>
- <p>ETS3 is also expected to be released for PS5 and Xbox consoles, according to some rumors and news sources . However, there is no official confirmation or announcement from the developers yet. The console versions of ETS3 may have different features and gameplay modes than the PC version, such as online multiplayer, controller support, achievements, and other options.</p>
- <h2>Why should you play European Truck Simulator 3?</h2>
- <p>If you are a fan of truck driving games, then you should definitely play ETS3. ETS3 is the best truck simulation game ever made, and it offers many reasons to play it. Here are some of the main reasons why you should play ETS3:</p>
- <h3>The realistic and immersive truck driving experience</h3>
- <p>ETS3 gives you the opportunity to experience what it is like to be a real truck driver. You can drive various trucks and trailers across Europe, following the traffic rules, managing your fuel, damage, fatigue, and other factors that affect your driving performance. You can also interact with other drivers, hire employees, buy garages, and expand your business. You can feel the realistic and immersive truck physics system that makes driving feel like real life. You can also hear the authentic engine sounds, horn sounds, tire sounds, and other sound effects that add to the atmosphere. You can also adjust the camera angles, mirrors, lights, indicators, wipers, cruise control, and other controls to suit your preference.</p>
- <h3>The variety and customization of trucks and trailers</h3>
- <p>ETS3 lets you choose from different truck models, chassis configurations, customizations, and cosmetics. You can select from over 50 licensed truck brands, such as Volvo, Scania, Mercedes-Benz, MAN, DAF, Renault, Iveco, and more. You can also customize your truck with different engines, transmissions, axles, suspensions, tires, colors, paint jobs, stickers, accessories, and more. You can also choose from different types of trailers, such as flatbeds, curtainsiders, refrigerated, tankers, low loaders, car carriers, and more. You can also customize your trailer with different cargoes, weights, lengths, widths, heights, colors, paint jobs, stickers, accessories, and more.</p>
- <h3>The exploration and discovery of Europe</h3>
- <p>ETS3 lets you explore and discover Europe in a way that no other game can. You can travel across highways, country roads, urban roads, mountain roads, tunnels, bridges, tolls, ferries, and other types of roads. You can see the landmarks, buildings, landscapes, weather conditions, day and night cycle, seasons, and other elements that make each location unique. You can also encounter different types of traffic vehicles, pedestrians, animals, events, accidents, roadworks, police patrols, tolls, and other situations that make your journey more dynamic and unpredictable. You can visit dozens of cities and countries in Europe, such as London, Paris, Berlin, Rome, Madrid, Amsterdam, Stockholm, Warsaw, Prague, Vienna, Zurich, Lisbon, Dublin, and more.</p>
- <h2>How to download and install European Truck Simulator 3 APK?</h2>
- <p>If you want to play ETS3 on your Android device, you will need to download and install ETS3 APK. ETS3 APK is a file that contains the game data and allows you to install it on your device without using the Google Play Store or any other app store. However, downloading and installing ETS3 APK is not as simple as it sounds. There are some risks and challenges involved in this process. Here are some of the steps and precautions you need to follow to download and install ETS3 APK safely and successfully:</p>
- <h3>The steps to download and install ETS3 APK on Android devices</h3>
- <ol>
-<li>Find a reliable and trustworthy source for ETS3 APK. There are many websites that claim to offer ETS3 APK for free download, but not all of them are safe and legitimate. Some of them may contain malware or viruses that can harm your device or steal your personal information. Some of them may also offer fake or outdated versions of ETS3 APK that may not work properly or at all. Therefore, you need to be careful and do some research before downloading ETS3 APK from any source.</li>
-<li>Download ETS3 APK file to your device. Once you have found a reliable and trustworthy source for ETS3 APK, you can download the file to your device. You may need to enable the option to download files from unknown sources in your device settings. You may also need to grant some permissions to the source website or app to access your device storage. You should also check the file size and name before downloading it, and make sure it matches the expected values.</li>
-<li>Install ETS3 APK on your device. After downloading ETS3 APK file to your device, you can install it by tapping on it. You may need to confirm the installation and grant some permissions to the game app to access your device features. You should also read the terms and conditions and privacy policy of the game app before installing it. You may also need to verify your device compatibility and security before installing it.</li>
-<li>Launch ETS3 APK on your device. After installing ETS3 APK on your device, you can launch it by tapping on its icon. You may need to sign in with your account or create a new one to access the game features. You may also need to download some additional data or updates for the game to run smoothly. You should also check the game settings and adjust them according to your preference and device performance.</li>
-</ol>
- <h3>The precautions and tips to avoid malware and viruses</h3>
- <p>Downloading and installing ETS3 APK on your Android device can be risky and challenging, as there are many potential threats and problems that can occur. Here are some of the precautions and tips you need to follow to avoid malware and viruses when downloading and installing ETS3 APK:</p>
- <ul>
-<li>Use a reputable antivirus or security app on your device. You should always have a reliable and updated antivirus or security app on your device that can scan and protect your device from malware and viruses. You should also run a full scan of your device before and after downloading and installing ETS3 APK, and delete any suspicious or harmful files or apps.</li>
-<li>Use a secure and stable internet connection. You should always use a secure and stable internet connection when downloading and installing ETS3 APK, as a weak or unstable connection can cause errors or interruptions in the process. You should also avoid using public or unsecured Wi-Fi networks, as they can expose your device to hackers or cyberattacks.</li>
-<li>Use a backup or recovery tool on your device. You should always have a backup or recovery tool on your device that can save and restore your data and settings in case of any damage or loss. You should also backup your data and settings before and after downloading and installing ETS3 APK, and restore them if needed.</li>
-<li>Use a trusted and verified source for ETS3 APK. You should always use a trusted and verified source for ETS3 APK, as an untrusted or unverified source can provide fake or infected files or apps that can harm your device or steal your personal information. You should also check the reviews, ratings, comments, feedback, and reputation of the source before downloading and installing ETS3 APK, and avoid any source that has negative or suspicious signs.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>Euro Truck Simulator 3 (ETS3) is a truck simulation game that lets you drive various trucks and trailers across Europe. It is the best truck driving game ever made, as it offers a realistic and immersive truck driving experience, a variety and customization of trucks and trailers, and an exploration and discovery of Europe. It is expected to be released in 2028 for PC, PS5, and Xbox consoles, according to some rumors and news sources . However, there is no official confirmation or announcement from the developers yet.</p>
- <p>If you want to play ETS3 on your Android device, you will need to download and install ETS3 APK. ETS3 APK is a file that contains the game data and allows you to install it on your device without using the Google Play Store or any other app store. However, downloading and installing ETS3 APK is not as simple as it sounds. There are some risks and challenges involved in this process. You will need to follow some steps and precautions to download and install ETS3 APK safely and successfully.</p>
- <p>We hope this article has helped you understand what ETS3 is, why you should play it, and how to download and install ETS3 APK on your Android device. If you have any questions, comments, or feedback, please feel free to share them with us. We would love to hear from you. Thank you for reading and happy trucking!</p>
- <h2>FAQs</h2>
- <p>Here are some of the frequently asked questions (FAQs) about ETS3 and ETS3 APK:</p>
- <ol>
-<li><b > What is the difference between ETS3 and ETS2?</b>
- <p>ETS3 and ETS2 are both truck simulation games developed by SCS Software, but they have some differences. ETS3 is the latest and most realistic truck simulation game ever made, while ETS2 is the previous and most popular truck simulation game in the series. ETS3 has improved graphics and physics engine, more truck models and customizations, more trailer types and cargoes, more cities and countries, more road types and situations, and more features and gameplay modes than ETS2. However, ETS3 is not yet released, while ETS2 is available for PC, Mac, Linux, PS4, and Xbox One.</p>
- <li><b>Is ETS3 APK safe and legal to download and install?</b></li>
- <p>ETS3 APK is not safe or legal to download and install on your Android device. ETS3 APK is a file that contains the game data and allows you to install it on your device without using the Google Play Store or any other app store. However, this file is not authorized or verified by the developers or the app stores, and it may contain malware or viruses that can harm your device or steal your personal information. It may also violate the terms and conditions and privacy policy of the game app and the app stores, and it may result in legal actions or penalties. Therefore, you should avoid downloading and installing ETS3 APK on your Android device.</p>
- <li><b>How much does ETS3 cost and where can I buy it?</b></li>
- <p>ETS3 is expected to cost around $40-$60 USD for PC, PS5, and Xbox consoles, according to some rumors and news sources . However, there is no official confirmation or announcement from the developers yet. You can buy ETS3 from the official website of SCS Software or from other online or offline retailers that sell video games. However, you will have to wait until ETS3 is released, which may take a few years.</p>
- <li><b>Can I play ETS3 online with other players?</b></li>
- <p>ETS3 may have an online multiplayer mode that allows you to play with other players around the world. You may be able to join or create a convoy of trucks, chat with other drivers, compete in races or challenges, cooperate in missions or deliveries, share your customizations or screenshots, and more. However, there is no official confirmation or announcement from the developers yet about the online multiplayer mode of ETS3.</p>
- <li><b>Can I mod ETS3 or use mods from ETS2?</b></li>
- <p>ETS3 may have a modding support that allows you to create or use mods for the game. Mods are modifications that change or add something to the game, such as new trucks, trailers, cargoes, maps, roads, traffic, weather, sounds, graphics, gameplay features, and more. However, there is no official confirmation or announcement from the developers yet about the modding support of ETS3. You may not be able to use mods from ETS2 for ETS3, as they may not be compatible or updated for the new game.</p>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/pipelines/alt_diffusion/pipeline_alt_diffusion_img2img.py

@@ -1,548 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-from typing import Callable, List, Optional, Union
-
-import numpy as np
-import paddle
-import PIL
-from packaging import version
-
-from paddlenlp.transformers import CLIPFeatureExtractor, XLMRobertaTokenizer
-
-from ...configuration_utils import FrozenDict
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...pipeline_utils import DiffusionPipeline
-from ...schedulers import (
-    DDIMScheduler,
-    DPMSolverMultistepScheduler,
-    EulerAncestralDiscreteScheduler,
-    EulerDiscreteScheduler,
-    LMSDiscreteScheduler,
-    PNDMScheduler,
-)
-from ...utils import PIL_INTERPOLATION, deprecate, logging
-from ..stable_diffusion.safety_checker import StableDiffusionSafetyChecker
-from . import AltDiffusionPipelineOutput, RobertaSeriesModelWithTransformation
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.preprocess
-def preprocess(image):
-    if isinstance(image, paddle.Tensor):
-        return image
-    elif isinstance(image, PIL.Image.Image):
-        image = [image]
-
-    if isinstance(image[0], PIL.Image.Image):
-        w, h = image[0].size
-        w, h = map(lambda x: x - x % 32, (w, h))  # resize to integer multiple of 32
-
-        image = [np.array(i.resize((w, h), resample=PIL_INTERPOLATION["lanczos"]))[None, :] for i in image]
-        image = np.concatenate(image, axis=0)
-        image = np.array(image).astype(np.float32) / 255.0
-        image = image.transpose(0, 3, 1, 2)
-        image = 2.0 * image - 1.0
-        image = paddle.to_tensor(image)
-    elif isinstance(image[0], paddle.Tensor):
-        image = paddle.concat(image, axis=0)
-    return image
-
-
-class AltDiffusionImg2ImgPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for text-guided image to image generation using Alt Diffusion.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving etc.)
-
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
-        text_encoder ([`RobertaSeriesModelWithTransformation`]):
-            Frozen text-encoder. Alt Diffusion uses the text portion of
-            [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.RobertaSeriesModelWithTransformation),
-            specifically the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
-        tokenizer (`XLMRobertaTokenizer`):
-            Tokenizer of class
-            [XLMRobertaTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.XLMRobertaTokenizer).
-        unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
-        safety_checker ([`StableDiffusionSafetyChecker`]):
-            Classification module that estimates whether generated images could be considered offensive or harmful.
-            Please, refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for details.
-        feature_extractor ([`CLIPFeatureExtractor`]):
-            Model that extracts features from generated images to be used as inputs for the `safety_checker`.
-    """
-    _optional_components = ["safety_checker", "feature_extractor"]
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: RobertaSeriesModelWithTransformation,
-        tokenizer: XLMRobertaTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: Union[
-            DDIMScheduler,
-            PNDMScheduler,
-            LMSDiscreteScheduler,
-            EulerDiscreteScheduler,
-            EulerAncestralDiscreteScheduler,
-            DPMSolverMultistepScheduler,
-        ],
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPFeatureExtractor,
-        requires_safety_checker: bool = True,
-    ):
-        super().__init__()
-
-        if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
-            deprecation_message = (
-                f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
-                f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
-                "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
-                " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
-                " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
-                " file"
-            )
-            deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(scheduler.config)
-            new_config["steps_offset"] = 1
-            scheduler._internal_dict = FrozenDict(new_config)
-
-        if hasattr(scheduler.config, "clip_sample") and scheduler.config.clip_sample is True:
-            deprecation_message = (
-                f"The configuration file of this scheduler: {scheduler} has not set the configuration `clip_sample`."
-                " `clip_sample` should be set to False in the configuration file. Please make sure to update the"
-                " config accordingly as not setting `clip_sample` in the config might lead to incorrect results in"
-                " future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very"
-                " nice if you could open a Pull request for the `scheduler/scheduler_config.json` file"
-            )
-            deprecate("clip_sample not set", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(scheduler.config)
-            new_config["clip_sample"] = False
-            scheduler._internal_dict = FrozenDict(new_config)
-
-        if safety_checker is None and requires_safety_checker:
-            logger.warning(
-                f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
-                " that you abide to the conditions of the Alt Diffusion license and do not expose unfiltered"
-                " results in services or applications open to the public. PaddleNLP team, diffusers team and Hugging Face"
-                " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
-                " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
-                " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
-            )
-        if safety_checker is not None and feature_extractor is None:
-            raise ValueError(
-                "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
-                " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
-            )
-
-        is_unet_version_less_0_9_0 = hasattr(unet.config, "_ppdiffusers_version") and version.parse(
-            version.parse(unet.config._ppdiffusers_version).base_version
-        ) < version.parse("0.9.0.dev0")
-        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
-        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
-            deprecation_message = (
-                "The configuration file of the unet has set the default `sample_size` to smaller than"
-                " 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
-                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
-                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
-                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
-                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
-                " in the config might lead to incorrect results in future versions. If you have downloaded this"
-                " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
-                " the `unet/config.json` file"
-            )
-            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(unet.config)
-            new_config["sample_size"] = 64
-            unet._internal_dict = FrozenDict(new_config)
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    def _encode_prompt(self, prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-            prompt (`str` or `list(int)`):
-                prompt to be encoded
-            num_images_per_prompt (`int`):
-                number of images that should be generated per prompt
-            do_classifier_free_guidance (`bool`):
-                whether to use classifier free guidance or not
-            negative_prompt (`str` or `List[str]`):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-        """
-        batch_size = len(prompt) if isinstance(prompt, list) else 1
-
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="pd",
-        )
-        text_input_ids = text_inputs.input_ids
-        untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pd").input_ids
-
-        if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not paddle.equal_all(
-            text_input_ids, untruncated_ids
-        ):
-            removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])
-            logger.warning(
-                "The following part of your input was truncated because XLM-Roberta can only handle sequences up to"
-                f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-            )
-
-        if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-            attention_mask = text_inputs.attention_mask
-        else:
-            attention_mask = None
-
-        text_embeddings = self.text_encoder(
-            text_input_ids,
-            attention_mask=attention_mask,
-        )
-        text_embeddings = text_embeddings[0]
-
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        bs_embed, seq_len, _ = text_embeddings.shape
-        text_embeddings = text_embeddings.tile([1, num_images_per_prompt, 1])
-        text_embeddings = text_embeddings.reshape([bs_embed * num_images_per_prompt, seq_len, -1])
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt]
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-
-            max_length = text_input_ids.shape[-1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pd",
-            )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = uncond_input.attention_mask
-            else:
-                attention_mask = None
-
-            uncond_embeddings = self.text_encoder(
-                uncond_input.input_ids,
-                attention_mask=attention_mask,
-            )
-            uncond_embeddings = uncond_embeddings[0]
-
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = uncond_embeddings.shape[1]
-            uncond_embeddings = uncond_embeddings.tile([1, num_images_per_prompt, 1])
-            uncond_embeddings = uncond_embeddings.reshape([batch_size * num_images_per_prompt, seq_len, -1])
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            text_embeddings = paddle.concat([uncond_embeddings, text_embeddings])
-
-        return text_embeddings
-
-    def run_safety_checker(self, image, dtype):
-        if self.safety_checker is not None:
-            safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pd")
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.cast(dtype)
-            )
-        else:
-            has_nsfw_concept = None
-        return image, has_nsfw_concept
-
-    def decode_latents(self, latents):
-        latents = 1 / 0.18215 * latents
-        image = self.vae.decode(latents).sample
-        image = (image / 2 + 0.5).clip(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
-        image = image.transpose([0, 2, 3, 1]).cast("float32").numpy()
-        return image
-
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-
-    def check_inputs(self, prompt, strength, callback_steps):
-        if not isinstance(prompt, str) and not isinstance(prompt, list):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if strength < 0 or strength > 1:
-            raise ValueError(f"The value of strength should in [1.0, 1.0] but is {strength}")
-
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-
-    def get_timesteps(self, num_inference_steps, strength):
-        # get the original timestep using init_timestep
-        init_timestep = min(int(num_inference_steps * strength), num_inference_steps)
-
-        t_start = max(num_inference_steps - init_timestep, 0)
-        timesteps = self.scheduler.timesteps[t_start:]
-
-        return timesteps, num_inference_steps - t_start
-
-    def prepare_latents(self, image, timestep, batch_size, num_images_per_prompt, dtype, generator=None):
-        image = image.cast(dtype=dtype)
-        batch_size = batch_size * num_images_per_prompt
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        if isinstance(generator, list):
-            init_latents = [
-                self.vae.encode(image[i : i + 1]).latent_dist.sample(generator[i]) for i in range(batch_size)
-            ]
-            init_latents = paddle.concat(init_latents, axis=0)
-        else:
-            init_latents = self.vae.encode(image).latent_dist.sample(generator)
-
-        init_latents = 0.18215 * init_latents
-
-        if batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] == 0:
-            # expand init_latents for batch_size
-            deprecation_message = (
-                f"You have passed {batch_size} text prompts (`prompt`), but only {init_latents.shape[0]} initial"
-                " images (`image`). Initial images are now duplicating to match the number of text prompts. Note"
-                " that this behavior is deprecated and will be removed in a version 1.0.0. Please make sure to update"
-                " your script to pass as many initial images as text prompts to suppress this warning."
-            )
-            deprecate("len(prompt) != len(image)", "1.0.0", deprecation_message, standard_warn=False)
-            additional_image_per_prompt = batch_size // init_latents.shape[0]
-            init_latents = paddle.concat([init_latents] * additional_image_per_prompt, axis=0)
-        elif batch_size > init_latents.shape[0] and batch_size % init_latents.shape[0] != 0:
-            raise ValueError(
-                f"Cannot duplicate `image` of batch size {init_latents.shape[0]} to {batch_size} text prompts."
-            )
-        else:
-            init_latents = paddle.concat([init_latents], axis=0)
-
-        shape = init_latents.shape
-        if isinstance(generator, list):
-            shape = [
-                1,
-            ] + shape[1:]
-            noise = [paddle.randn(shape, generator=generator[i], dtype=dtype) for i in range(batch_size)]
-            noise = paddle.concat(noise, axis=0)
-        else:
-            noise = paddle.randn(shape, generator=generator, dtype=dtype)
-
-        # get latents
-        init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
-        latents = init_latents
-
-        return latents
-
-    @paddle.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        image: Union[paddle.Tensor, PIL.Image.Image] = None,
-        strength: float = 0.8,
-        num_inference_steps: Optional[int] = 50,
-        guidance_scale: Optional[float] = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: Optional[float] = 0.0,
-        generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, paddle.Tensor], None]] = None,
-        callback_steps: Optional[int] = 1,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`):
-                The prompt or prompts to guide the image generation.
-            image (`paddle.Tensor` or `PIL.Image.Image`):
-                `Image`, or tensor representing an image batch, that will be used as the starting point for the
-                process.
-            strength (`float`, *optional*, defaults to 0.8):
-                Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1.
-                `image` will be used as a starting point, adding more noise to it the larger the `strength`. The
-                number of denoising steps depends on the amount of noise initially added. When `strength` is 1, added
-                noise will be maximum and the denoising process will run for the full number of iterations specified in
-                `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference. This parameter will be modulated by `strength`.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.0):
-                Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
-                [`schedulers.DDIMScheduler`], will be ignored for others.
-            generator (`paddle.Generator`, *optional*):
-                One or a list of paddle generator(s) to make generation deterministic.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.AltDiffusionPipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that will be called every `callback_steps` steps during inference. The function will be
-                called with the following arguments: `callback(step: int, timestep: int, latents: paddle.Tensor)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function will be called. If not specified, the callback will be
-                called at every step.
-
-        Returns:
-            [`~pipelines.stable_diffusion.AltDiffusionPipelineOutput`] or `tuple`:
-            [`~pipelines.stable_diffusion.AltDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
-            When returning a tuple, the first element is a list with the generated images, and the second element is a
-            list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
-            (nsfw) content, according to the `safety_checker`.
-        """
-        # 1. Check inputs
-        self.check_inputs(prompt, strength, callback_steps)
-
-        # 2. Define call parameters
-        batch_size = 1 if isinstance(prompt, str) else len(prompt)
-
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # 3. Encode input prompt
-        text_embeddings = self._encode_prompt(
-            prompt, num_images_per_prompt, do_classifier_free_guidance, negative_prompt
-        )
-
-        # 4. Preprocess image
-        image = preprocess(image)
-
-        # 5. set timesteps
-        self.scheduler.set_timesteps(num_inference_steps)
-        timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength)
-        latent_timestep = timesteps[:1].tile([batch_size * num_images_per_prompt])
-
-        # 6. Prepare latent variables
-        latents = self.prepare_latents(
-            image, latent_timestep, batch_size, num_images_per_prompt, text_embeddings.dtype, generator
-        )
-
-        # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
-        # 8. Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = paddle.concat([latents] * 2) if do_classifier_free_guidance else latents
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
-                # predict the noise residual
-                noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample
-
-                # perform guidance
-                if do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
-        # 9. Post-processing
-        image = self.decode_latents(latents)
-
-        # 10. Run safety checker
-        image, has_nsfw_concept = self.run_safety_checker(image, text_embeddings.dtype)
-
-        # 11. Convert to PIL
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        if not return_dict:
-            return (image, has_nsfw_concept)
-
-        return AltDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)

spaces/44ov41za8i/FreeVC/models.py

@@ -1,351 +0,0 @@
-import copy
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import modules
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from commons import init_weights, get_padding
-
-
-class ResidualCouplingBlock(nn.Module):
-  def __init__(self,
-      channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      n_flows=4,
-      gin_channels=0):
-    super().__init__()
-    self.channels = channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.n_flows = n_flows
-    self.gin_channels = gin_channels
-
-    self.flows = nn.ModuleList()
-    for i in range(n_flows):
-      self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
-      self.flows.append(modules.Flip())
-
-  def forward(self, x, x_mask, g=None, reverse=False):
-    if not reverse:
-      for flow in self.flows:
-        x, _ = flow(x, x_mask, g=g, reverse=reverse)
-    else:
-      for flow in reversed(self.flows):
-        x = flow(x, x_mask, g=g, reverse=reverse)
-    return x
-
-
-class Encoder(nn.Module):
-  def __init__(self,
-      in_channels,
-      out_channels,
-      hidden_channels,
-      kernel_size,
-      dilation_rate,
-      n_layers,
-      gin_channels=0):
-    super().__init__()
-    self.in_channels = in_channels
-    self.out_channels = out_channels
-    self.hidden_channels = hidden_channels
-    self.kernel_size = kernel_size
-    self.dilation_rate = dilation_rate
-    self.n_layers = n_layers
-    self.gin_channels = gin_channels
-
-    self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-    self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
-    self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-  def forward(self, x, x_lengths, g=None):
-    x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-    x = self.pre(x) * x_mask
-    x = self.enc(x, x_mask, g=g)
-    stats = self.proj(x) * x_mask
-    m, logs = torch.split(stats, self.out_channels, dim=1)
-    z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-    return z, m, logs, x_mask
-
-
-class Generator(torch.nn.Module):
-    def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=0):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
-        resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(weight_norm(
-                ConvTranspose1d(upsample_initial_channel//(2**i), upsample_initial_channel//(2**(i+1)),
-                                k, u, padding=(k-u)//2)))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel//(2**(i+1))
-            for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-          x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i*self.num_kernels+j](x)
-                else:
-                    xs += self.resblocks[i*self.num_kernels+j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        print('Removing weight norm...')
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList([
-            norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
-            norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
-        ])
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0: # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList([
-            norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-            norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-            norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-            norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-            norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-            norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-        ])
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2,3,5,7,11]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-        
-        
-class SpeakerEncoder(torch.nn.Module):
-    def __init__(self, mel_n_channels=80, model_num_layers=3, model_hidden_size=256, model_embedding_size=256):
-        super(SpeakerEncoder, self).__init__()
-        self.lstm = nn.LSTM(mel_n_channels, model_hidden_size, model_num_layers, batch_first=True)
-        self.linear = nn.Linear(model_hidden_size, model_embedding_size)
-        self.relu = nn.ReLU()
-
-    def forward(self, mels):
-        self.lstm.flatten_parameters()
-        _, (hidden, _) = self.lstm(mels)
-        embeds_raw = self.relu(self.linear(hidden[-1]))
-        return embeds_raw / torch.norm(embeds_raw, dim=1, keepdim=True)
-        
-    def compute_partial_slices(self, total_frames, partial_frames, partial_hop):
-        mel_slices = []
-        for i in range(0, total_frames-partial_frames, partial_hop):
-            mel_range = torch.arange(i, i+partial_frames)
-            mel_slices.append(mel_range)
-            
-        return mel_slices
-    
-    def embed_utterance(self, mel, partial_frames=128, partial_hop=64):
-        mel_len = mel.size(1)
-        last_mel = mel[:,-partial_frames:]
-        
-        if mel_len > partial_frames:
-            mel_slices = self.compute_partial_slices(mel_len, partial_frames, partial_hop)
-            mels = list(mel[:,s] for s in mel_slices)
-            mels.append(last_mel)
-            mels = torch.stack(tuple(mels), 0).squeeze(1)
-        
-            with torch.no_grad():
-                partial_embeds = self(mels)
-            embed = torch.mean(partial_embeds, axis=0).unsqueeze(0)
-            #embed = embed / torch.linalg.norm(embed, 2)
-        else:
-            with torch.no_grad():
-                embed = self(last_mel)
-        
-        return embed
-
-
-class SynthesizerTrn(nn.Module):
-  """
-  Synthesizer for Training
-  """
-
-  def __init__(self, 
-    spec_channels,
-    segment_size,
-    inter_channels,
-    hidden_channels,
-    filter_channels,
-    n_heads,
-    n_layers,
-    kernel_size,
-    p_dropout,
-    resblock, 
-    resblock_kernel_sizes, 
-    resblock_dilation_sizes, 
-    upsample_rates, 
-    upsample_initial_channel, 
-    upsample_kernel_sizes,
-    gin_channels,
-    ssl_dim,
-    use_spk,
-    **kwargs):
-
-    super().__init__()
-    self.spec_channels = spec_channels
-    self.inter_channels = inter_channels
-    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.resblock = resblock
-    self.resblock_kernel_sizes = resblock_kernel_sizes
-    self.resblock_dilation_sizes = resblock_dilation_sizes
-    self.upsample_rates = upsample_rates
-    self.upsample_initial_channel = upsample_initial_channel
-    self.upsample_kernel_sizes = upsample_kernel_sizes
-    self.segment_size = segment_size
-    self.gin_channels = gin_channels
-    self.ssl_dim = ssl_dim
-    self.use_spk = use_spk
-
-    self.enc_p = Encoder(ssl_dim, inter_channels, hidden_channels, 5, 1, 16)
-    self.dec = Generator(inter_channels, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=gin_channels)
-    self.enc_q = Encoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels) 
-    self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
-    
-    if not self.use_spk:
-      self.enc_spk = SpeakerEncoder(model_hidden_size=gin_channels, model_embedding_size=gin_channels)
-
-  def forward(self, c, spec, g=None, mel=None, c_lengths=None, spec_lengths=None):
-    if c_lengths == None:
-      c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
-    if spec_lengths == None:
-      spec_lengths = (torch.ones(spec.size(0)) * spec.size(-1)).to(spec.device)
-      
-    if not self.use_spk:
-      g = self.enc_spk(mel.transpose(1,2))
-    g = g.unsqueeze(-1)
-      
-    _, m_p, logs_p, _ = self.enc_p(c, c_lengths)
-    z, m_q, logs_q, spec_mask = self.enc_q(spec, spec_lengths, g=g) 
-    z_p = self.flow(z, spec_mask, g=g)
-
-    z_slice, ids_slice = commons.rand_slice_segments(z, spec_lengths, self.segment_size)
-    o = self.dec(z_slice, g=g)
-    
-    return o, ids_slice, spec_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-  def infer(self, c, g=None, mel=None, c_lengths=None):
-    if c_lengths == None:
-      c_lengths = (torch.ones(c.size(0)) * c.size(-1)).to(c.device)
-    if not self.use_spk:
-      g = self.enc_spk.embed_utterance(mel.transpose(1,2))
-    g = g.unsqueeze(-1)
-
-    z_p, m_p, logs_p, c_mask = self.enc_p(c, c_lengths)
-    z = self.flow(z_p, c_mask, g=g, reverse=True)
-    o = self.dec(z * c_mask, g=g)
-    
-    return o

spaces/4Taps/SadTalker/src/face3d/models/arcface_torch/partial_fc.py

@@ -1,222 +0,0 @@
-import logging
-import os
-
-import torch
-import torch.distributed as dist
-from torch.nn import Module
-from torch.nn.functional import normalize, linear
-from torch.nn.parameter import Parameter
-
-
-class PartialFC(Module):
-    """
-    Author: {Xiang An, Yang Xiao, XuHan Zhu} in DeepGlint,
-    Partial FC: Training 10 Million Identities on a Single Machine
-    See the original paper:
-    https://arxiv.org/abs/2010.05222
-    """
-
-    @torch.no_grad()
-    def __init__(self, rank, local_rank, world_size, batch_size, resume,
-                 margin_softmax, num_classes, sample_rate=1.0, embedding_size=512, prefix="./"):
-        """
-        rank: int
-            Unique process(GPU) ID from 0 to world_size - 1.
-        local_rank: int
-            Unique process(GPU) ID within the server from 0 to 7.
-        world_size: int
-            Number of GPU.
-        batch_size: int
-            Batch size on current rank(GPU).
-        resume: bool
-            Select whether to restore the weight of softmax.
-        margin_softmax: callable
-            A function of margin softmax, eg: cosface, arcface.
-        num_classes: int
-            The number of class center storage in current rank(CPU/GPU), usually is total_classes // world_size,
-            required.
-        sample_rate: float
-            The partial fc sampling rate, when the number of classes increases to more than 2 millions, Sampling
-            can greatly speed up training, and reduce a lot of GPU memory, default is 1.0.
-        embedding_size: int
-            The feature dimension, default is 512.
-        prefix: str
-            Path for save checkpoint, default is './'.
-        """
-        super(PartialFC, self).__init__()
-        #
-        self.num_classes: int = num_classes
-        self.rank: int = rank
-        self.local_rank: int = local_rank
-        self.device: torch.device = torch.device("cuda:{}".format(self.local_rank))
-        self.world_size: int = world_size
-        self.batch_size: int = batch_size
-        self.margin_softmax: callable = margin_softmax
-        self.sample_rate: float = sample_rate
-        self.embedding_size: int = embedding_size
-        self.prefix: str = prefix
-        self.num_local: int = num_classes // world_size + int(rank < num_classes % world_size)
-        self.class_start: int = num_classes // world_size * rank + min(rank, num_classes % world_size)
-        self.num_sample: int = int(self.sample_rate * self.num_local)
-
-        self.weight_name = os.path.join(self.prefix, "rank_{}_softmax_weight.pt".format(self.rank))
-        self.weight_mom_name = os.path.join(self.prefix, "rank_{}_softmax_weight_mom.pt".format(self.rank))
-
-        if resume:
-            try:
-                self.weight: torch.Tensor = torch.load(self.weight_name)
-                self.weight_mom: torch.Tensor = torch.load(self.weight_mom_name)
-                if self.weight.shape[0] != self.num_local or self.weight_mom.shape[0] != self.num_local:
-                    raise IndexError
-                logging.info("softmax weight resume successfully!")
-                logging.info("softmax weight mom resume successfully!")
-            except (FileNotFoundError, KeyError, IndexError):
-                self.weight = torch.normal(0, 0.01, (self.num_local, self.embedding_size), device=self.device)
-                self.weight_mom: torch.Tensor = torch.zeros_like(self.weight)
-                logging.info("softmax weight init!")
-                logging.info("softmax weight mom init!")
-        else:
-            self.weight = torch.normal(0, 0.01, (self.num_local, self.embedding_size), device=self.device)
-            self.weight_mom: torch.Tensor = torch.zeros_like(self.weight)
-            logging.info("softmax weight init successfully!")
-            logging.info("softmax weight mom init successfully!")
-        self.stream: torch.cuda.Stream = torch.cuda.Stream(local_rank)
-
-        self.index = None
-        if int(self.sample_rate) == 1:
-            self.update = lambda: 0
-            self.sub_weight = Parameter(self.weight)
-            self.sub_weight_mom = self.weight_mom
-        else:
-            self.sub_weight = Parameter(torch.empty((0, 0)).cuda(local_rank))
-
-    def save_params(self):
-        """ Save softmax weight for each rank on prefix
-        """
-        torch.save(self.weight.data, self.weight_name)
-        torch.save(self.weight_mom, self.weight_mom_name)
-
-    @torch.no_grad()
-    def sample(self, total_label):
-        """
-        Sample all positive class centers in each rank, and random select neg class centers to filling a fixed
-        `num_sample`.
-
-        total_label: tensor
-            Label after all gather, which cross all GPUs.
-        """
-        index_positive = (self.class_start <= total_label) & (total_label < self.class_start + self.num_local)
-        total_label[~index_positive] = -1
-        total_label[index_positive] -= self.class_start
-        if int(self.sample_rate) != 1:
-            positive = torch.unique(total_label[index_positive], sorted=True)
-            if self.num_sample - positive.size(0) >= 0:
-                perm = torch.rand(size=[self.num_local], device=self.device)
-                perm[positive] = 2.0
-                index = torch.topk(perm, k=self.num_sample)[1]
-                index = index.sort()[0]
-            else:
-                index = positive
-            self.index = index
-            total_label[index_positive] = torch.searchsorted(index, total_label[index_positive])
-            self.sub_weight = Parameter(self.weight[index])
-            self.sub_weight_mom = self.weight_mom[index]
-
-    def forward(self, total_features, norm_weight):
-        """ Partial fc forward, `logits = X * sample(W)`
-        """
-        torch.cuda.current_stream().wait_stream(self.stream)
-        logits = linear(total_features, norm_weight)
-        return logits
-
-    @torch.no_grad()
-    def update(self):
-        """ Set updated weight and weight_mom to memory bank.
-        """
-        self.weight_mom[self.index] = self.sub_weight_mom
-        self.weight[self.index] = self.sub_weight
-
-    def prepare(self, label, optimizer):
-        """
-        get sampled class centers for cal softmax.
-
-        label: tensor
-            Label tensor on each rank.
-        optimizer: opt
-            Optimizer for partial fc, which need to get weight mom.
-        """
-        with torch.cuda.stream(self.stream):
-            total_label = torch.zeros(
-                size=[self.batch_size * self.world_size], device=self.device, dtype=torch.long)
-            dist.all_gather(list(total_label.chunk(self.world_size, dim=0)), label)
-            self.sample(total_label)
-            optimizer.state.pop(optimizer.param_groups[-1]['params'][0], None)
-            optimizer.param_groups[-1]['params'][0] = self.sub_weight
-            optimizer.state[self.sub_weight]['momentum_buffer'] = self.sub_weight_mom
-            norm_weight = normalize(self.sub_weight)
-            return total_label, norm_weight
-
-    def forward_backward(self, label, features, optimizer):
-        """
-        Partial fc forward and backward with model parallel
-
-        label: tensor
-            Label tensor on each rank(GPU)
-        features: tensor
-            Features tensor on each rank(GPU)
-        optimizer: optimizer
-            Optimizer for partial fc
-
-        Returns:
-        --------
-        x_grad: tensor
-            The gradient of features.
-        loss_v: tensor
-            Loss value for cross entropy.
-        """
-        total_label, norm_weight = self.prepare(label, optimizer)
-        total_features = torch.zeros(
-            size=[self.batch_size * self.world_size, self.embedding_size], device=self.device)
-        dist.all_gather(list(total_features.chunk(self.world_size, dim=0)), features.data)
-        total_features.requires_grad = True
-
-        logits = self.forward(total_features, norm_weight)
-        logits = self.margin_softmax(logits, total_label)
-
-        with torch.no_grad():
-            max_fc = torch.max(logits, dim=1, keepdim=True)[0]
-            dist.all_reduce(max_fc, dist.ReduceOp.MAX)
-
-            # calculate exp(logits) and all-reduce
-            logits_exp = torch.exp(logits - max_fc)
-            logits_sum_exp = logits_exp.sum(dim=1, keepdims=True)
-            dist.all_reduce(logits_sum_exp, dist.ReduceOp.SUM)
-
-            # calculate prob
-            logits_exp.div_(logits_sum_exp)
-
-            # get one-hot
-            grad = logits_exp
-            index = torch.where(total_label != -1)[0]
-            one_hot = torch.zeros(size=[index.size()[0], grad.size()[1]], device=grad.device)
-            one_hot.scatter_(1, total_label[index, None], 1)
-
-            # calculate loss
-            loss = torch.zeros(grad.size()[0], 1, device=grad.device)
-            loss[index] = grad[index].gather(1, total_label[index, None])
-            dist.all_reduce(loss, dist.ReduceOp.SUM)
-            loss_v = loss.clamp_min_(1e-30).log_().mean() * (-1)
-
-            # calculate grad
-            grad[index] -= one_hot
-            grad.div_(self.batch_size * self.world_size)
-
-        logits.backward(grad)
-        if total_features.grad is not None:
-            total_features.grad.detach_()
-        x_grad: torch.Tensor = torch.zeros_like(features, requires_grad=True)
-        # feature gradient all-reduce
-        dist.reduce_scatter(x_grad, list(total_features.grad.chunk(self.world_size, dim=0)))
-        x_grad = x_grad * self.world_size
-        # backward backbone
-        return x_grad, loss_v

spaces/AIatUIUC/CodeLATS/lats/lats.py

@@ -1,233 +0,0 @@
-from utils import enumerate_resume, make_printv, write_jsonl, resume_success_count
-from executors import executor_factory
-from generators import generator_factory, model_factory
-from typing import List, Dict, Any
-import math
-from typing import Tuple
-import sys
-import random
-
-sys.set_int_max_str_digits(100000)  # Increase the limit to 10000 digits
-
-react_prompt_header = "Here are some previous solutions and the corresponding test results.\n"
-react_prompt_starter = "\n\nYour solution:\n"
-extra_header = "\n\nName the function answer()"
-
-class Node:
-    def __init__(self, solution: str, parent=None, context="", depth=0):
-        self.solution = solution
-        self.parent = parent
-        self.children = []
-        self.value = 0
-        self.visits = 0
-        self.context = ""
-        self.depth = depth
-        self.reflection = ""
-        self.test_feedback = ""
-
-    def uct(self, exploration_weight=1.0):
-        if self.visits == 0:
-            #return float('inf')
-            return self.value
-        return (self.value / self.visits) + exploration_weight * math.sqrt(math.log(self.parent.visits) / self.visits)
-
-    def best_child(self):
-        if not self.children:  # Check if children list is empty
-            return None
-        return max(self.children, key=lambda child: child.uct())
-
-    def best_child_value(self):
-        if not self.children:  # Check if children list is empty
-            return None
-        return max(self.children, key=lambda child: child.value)
-
-    def update(self, reward: float):
-        self.visits += 1
-        self.value += reward
-    
-
-def prune_context_blocks(context: str, max_length: int) -> str:
-    """Prune the context to fit within the specified max_length by removing entire blocks of content using 'trial' as a delimiter."""
-    if len(context) <= max_length:
-        return context
-    
-    # Split by the block delimiter "trial".
-    blocks = context.split('Previous Trial')
-    
-    # Remove the earliest blocks until the context fits within max_length.
-    while len('trial'.join(blocks)) > max_length and blocks:
-        blocks.pop(0)
-    
-    return 'trial'.join(blocks)
-
-def gather_context_from_tree(node: Node) -> Tuple[List[str], List[str]]:
-    """
-    Given a node, walk up its tree and gather the feedback and reflections 
-    from each parent node until the root is reached.
-
-    Args:
-        node (Node): The node to start gathering context from.
-
-    Returns:
-        Tuple[List[str], List[str]]: Two lists containing the accumulated feedback and reflections.
-    """
-    accumulated_feedback = []
-    accumulated_reflection = []
-    num_nodes = 0
-
-    while node and num_nodes < 2:
-        num_nodes += 1
-        if node.test_feedback:
-            accumulated_feedback.append(node.test_feedback)
-        if node.reflection:
-            accumulated_reflection.append(node.reflection)
-        node = node.parent
-
-    # Reverse the lists so that the context from the earliest nodes is first
-    return accumulated_feedback[::-1], accumulated_reflection[::-1]
-
-def sample_n_random(items: List[str], n: int) -> List[str]:
-    """Sample min(n, len(items)) random items from a list"""
-    assert n >= 0
-    if n >= len(items):
-        return items
-    return random.sample(items, n)
-
-def run_lats(
-    model_name: str,
-    language: str,
-    max_iters: int,
-    verbose: bool,
-    instruction: str = "Write some code to print Hello World in Python",
-    n_samples: int = 3,
-    depth: int = 5,
-) -> None:
-    exe = executor_factory(language)
-    gen = generator_factory(language)
-    model = model_factory(model_name)
-
-
-    num_success = 0  # Counter for successful solutions
-    cur_func_impl = None
-
-    item = {}
-
-    #for idx, item in enumerate(dataset):
-    
-    tests = gen.internal_tests(instruction + extra_header, model, 1)
-    tests_i = sample_n_random(tests, 1)
-
-    while cur_func_impl is None:
-        cur_func_impl = gen.func_impl(instruction + extra_header, model, "simple")
-    root = Node(cur_func_impl) # initial solution (for pass@1 metric)
-    
-    # Lists for logging
-    reflections = []
-    implementations = []
-    test_feedback = []
-    is_solved = False
-
-    # first attempt
-    
-    implementations.append(cur_func_impl)
-    assert isinstance(cur_func_impl, str)
-    is_passing, feedback, _ = exe.execute(cur_func_impl, tests_i)
-    test_feedback.append(feedback)
-
-    # if solved, exit early
-    if is_passing:
-        num_success += 1
-        return cur_func_impl # GET SOLUTION
-    
-    reflection = gen.self_reflection(cur_func_impl, feedback, model)
-    reflections += [reflection]
-    root.test_feedback = feedback
-    root.reflection = reflection
-    max_iters = int(max_iters)
-    for cur_iter in range(max_iters):
-        # Selection
-        tests_i = sample_n_random(tests, 1)
-
-        node = root
-        trajectory = {
-            'solutions': [],
-            'feedbacks': []
-        }
-
-        while node.children:
-            node = node.best_child()
-            trajectory['solutions'].append(node.solution)
-        
-        # Expansion
-        for _ in range(n_samples):
-            new_solution = None
-            strategy = "mcts"
-            prev_func_impl = node.solution
-            feedback = node.test_feedback
-            reflection = node.reflection
-            acc_feedback, acc_reflection = gather_context_from_tree(node)
-            
-            while new_solution is None:
-                new_solution = gen.func_impl(
-                    func_sig=instruction+extra_header,
-                    model=model,
-                    strategy=strategy,
-                    prev_func_impl=prev_func_impl,
-                    feedback=feedback,
-                    self_reflection=reflection,
-                    acc_feedback = acc_feedback,
-                    acc_reflection = acc_reflection
-                )
-
-            combined_context = "\nPrevious Trial\n\n" + new_solution
-
-            child = Node(new_solution, parent=node, context=combined_context, depth=node.depth + 1)
-            node.children.append(child)
-
-            # Simulation
-            reward_real = 0
-            for child in node.children:
-                is_passing_internal, feedback_internal, _ = exe.execute(child.solution, tests_i)
-                if not is_passing_internal:
-                    reflection = gen.self_reflection(child.solution, feedback_internal, model)
-                    reflections.append(reflection)
-                    child.reflection = reflection
-                    child.test_feedback = feedback_internal
-                    child.context += "\n\nPrevious Trial\n\n" + child.solution + "\n\nTest results: \n" + feedback_internal + "\n\nSelf-reflection: " + reflection
-                else:
-                    child.context += "\n\nPrevious Trial\n\n" + child.solution + "\n\nTest results: \n" + feedback_internal
-                    child.reflection = ""
-                    child.test_feedback = feedback_internal
-
-                if "Tested passed:" in feedback_internal:
-                    # Split at "Tests failed:" and get the part before it (which contains the passed tests)
-                    passed_section = feedback_internal.split("Tests failed:")[0]
-                    # Split at "Tested passed:" and get the part after it, then count the non-empty lines
-                    reward_internal = len([line for line in passed_section.split("Tested passed:")[1].splitlines() if line.strip() != ''])
-                    reward_internal = reward_internal / len(tests_i)
-                else:
-                    reward_internal = 0
-                if is_passing_internal or cur_iter == max_iters - 1:
-                    item["solution"] = child.solution
-                    break
-
-            if is_solved:
-                break
-            
-            reward = reward_internal + reward_real
-            child.update(reward)
-
-            # Backpropagation
-            temp = child
-            while temp.parent:
-                temp = temp.parent
-                temp.update(reward)
-    
-    # Choose the best solution after all iterations
-    if is_solved:
-        best_solution = item["solution"]
-    else:
-        best_solution = root.best_child_value().solution
-        item["solution"] = best_solution
-
-    return best_solution

spaces/AONYLMR/White-box-Cartoonization/app.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import annotations
-import argparse
-import functools
-import os
-import pathlib
-import sys
-from typing import Callable
-import uuid
-
-import gradio as gr
-import huggingface_hub
-import numpy as np
-import PIL.Image
-
-from io import BytesIO
-from wbc.cartoonize import Cartoonize
-
-ORIGINAL_REPO_URL = 'https://github.com/SystemErrorWang/White-box-Cartoonization'
-TITLE = 'SystemErrorWang/White-box-Cartoonization'
-DESCRIPTION = f"""This is a demo for {ORIGINAL_REPO_URL}.
-
-"""
-ARTICLE = """
-
-"""
-
-SAFEHASH = [x for x in "0123456789-abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
-def compress_UUID():
-    '''
-    根据http://www.ietf.org/rfc/rfc1738.txt,由uuid编码扩bai大字符域生成du串
-    包括:[0-9a-zA-Z\-_]共64个
-    长度:(32-2)/3*2=20
-    备注:可在地球上人zhi人都用,使用100年不重复(2^120)
-    :return:String
-    '''
-    row = str(uuid.uuid4()).replace('-', '')
-    safe_code = ''
-    for i in range(10):
-        enbin = "%012d" % int(bin(int(row[i * 3] + row[i * 3 + 1] + row[i * 3 + 2], 16))[2:], 10)
-        safe_code += (SAFEHASH[int(enbin[0:6], 2)] + SAFEHASH[int(enbin[6:12], 2)])
-    safe_code = safe_code.replace('-', '')
-    return safe_code
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--device', type=str, default='cpu')
-    parser.add_argument('--theme', type=str)
-    parser.add_argument('--live', action='store_true')
-    parser.add_argument('--share', action='store_true')
-    parser.add_argument('--port', type=int)
-    parser.add_argument('--disable-queue',
-                        dest='enable_queue',
-                        action='store_false')
-    parser.add_argument('--allow-flagging', type=str, default='never')
-    parser.add_argument('--allow-screenshot', action='store_true')
-    return parser.parse_args()
-
-def run(
-        image,
-        cartoonize : Cartoonize
-) -> tuple[PIL.Image.Image]:
-
-    out_path = compress_UUID()+'.png'
-    cartoonize.run_sigle(image.name, out_path)
-
-    return PIL.Image.open(out_path)
-
-
-def main():
-    gr.close_all()
-
-    args = parse_args()
-
-    cartoonize = Cartoonize(os.path.join(os.path.dirname(os.path.abspath(__file__)),'wbc/saved_models/'))
-
-    func = functools.partial(run, cartoonize=cartoonize)
-    func = functools.update_wrapper(func, run)
-
-    gr.Interface(
-        func,
-        [
-            gr.inputs.Image(type='file', label='Input Image'),
-        ],
-        [
-            gr.outputs.Image(
-                type='pil',
-                label='Result'),
-        ],
-        # examples=examples,
-        theme=args.theme,
-        title=TITLE,
-        description=DESCRIPTION,
-        article=ARTICLE,
-        allow_screenshot=args.allow_screenshot,
-        allow_flagging=args.allow_flagging,
-        live=args.live,
-    ).launch(
-        enable_queue=args.enable_queue,
-        server_port=args.port,
-        share=args.share,
-    )
-
-
-if __name__ == '__main__':
-    main()

spaces/Adapter/CoAdapter/ldm/util.py

@@ -1,200 +0,0 @@
-import importlib
-import math
-
-import cv2
-import torch
-import numpy as np
-
-import os
-from safetensors.torch import load_file
-
-from inspect import isfunction
-from PIL import Image, ImageDraw, ImageFont
-
-
-def log_txt_as_img(wh, xc, size=10):
-    # wh a tuple of (width, height)
-    # xc a list of captions to plot
-    b = len(xc)
-    txts = list()
-    for bi in range(b):
-        txt = Image.new("RGB", wh, color="white")
-        draw = ImageDraw.Draw(txt)
-        font = ImageFont.truetype('assets/DejaVuSans.ttf', size=size)
-        nc = int(40 * (wh[0] / 256))
-        lines = "\n".join(xc[bi][start:start + nc] for start in range(0, len(xc[bi]), nc))
-
-        try:
-            draw.text((0, 0), lines, fill="black", font=font)
-        except UnicodeEncodeError:
-            print("Cant encode string for logging. Skipping.")
-
-        txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0
-        txts.append(txt)
-    txts = np.stack(txts)
-    txts = torch.tensor(txts)
-    return txts
-
-
-def ismap(x):
-    if not isinstance(x, torch.Tensor):
-        return False
-    return (len(x.shape) == 4) and (x.shape[1] > 3)
-
-
-def isimage(x):
-    if not isinstance(x, torch.Tensor):
-        return False
-    return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1)
-
-
-def exists(x):
-    return x is not None
-
-
-def default(val, d):
-    if exists(val):
-        return val
-    return d() if isfunction(d) else d
-
-
-def mean_flat(tensor):
-    """
-    https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/nn.py#L86
-    Take the mean over all non-batch dimensions.
-    """
-    return tensor.mean(dim=list(range(1, len(tensor.shape))))
-
-
-def count_params(model, verbose=False):
-    total_params = sum(p.numel() for p in model.parameters())
-    if verbose:
-        print(f"{model.__class__.__name__} has {total_params * 1.e-6:.2f} M params.")
-    return total_params
-
-
-def instantiate_from_config(config):
-    if not "target" in config:
-        if config == '__is_first_stage__':
-            return None
-        elif config == "__is_unconditional__":
-            return None
-        raise KeyError("Expected key `target` to instantiate.")
-    return get_obj_from_str(config["target"])(**config.get("params", dict()))
-
-
-def get_obj_from_str(string, reload=False):
-    module, cls = string.rsplit(".", 1)
-    if reload:
-        module_imp = importlib.import_module(module)
-        importlib.reload(module_imp)
-    return getattr(importlib.import_module(module, package=None), cls)
-
-
-checkpoint_dict_replacements = {
-    'cond_stage_model.transformer.text_model.embeddings.': 'cond_stage_model.transformer.embeddings.',
-    'cond_stage_model.transformer.text_model.encoder.': 'cond_stage_model.transformer.encoder.',
-    'cond_stage_model.transformer.text_model.final_layer_norm.': 'cond_stage_model.transformer.final_layer_norm.',
-}
-
-
-def transform_checkpoint_dict_key(k):
-    for text, replacement in checkpoint_dict_replacements.items():
-        if k.startswith(text):
-            k = replacement + k[len(text):]
-
-    return k
-
-
-def get_state_dict_from_checkpoint(pl_sd):
-    pl_sd = pl_sd.pop("state_dict", pl_sd)
-    pl_sd.pop("state_dict", None)
-
-    sd = {}
-    for k, v in pl_sd.items():
-        new_key = transform_checkpoint_dict_key(k)
-
-        if new_key is not None:
-            sd[new_key] = v
-
-    pl_sd.clear()
-    pl_sd.update(sd)
-
-    return pl_sd
-
-
-def read_state_dict(checkpoint_file, print_global_state=False):
-    _, extension = os.path.splitext(checkpoint_file)
-    if extension.lower() == ".safetensors":
-        pl_sd = load_file(checkpoint_file, device='cpu')
-    else:
-        pl_sd = torch.load(checkpoint_file, map_location='cpu')
-
-    if print_global_state and "global_step" in pl_sd:
-        print(f"Global Step: {pl_sd['global_step']}")
-
-    sd = get_state_dict_from_checkpoint(pl_sd)
-    return sd
-
-
-def load_model_from_config(config, ckpt, vae_ckpt=None, verbose=False):
-    print(f"Loading model from {ckpt}")
-    sd = read_state_dict(ckpt)
-    model = instantiate_from_config(config.model)
-    m, u = model.load_state_dict(sd, strict=False)
-    if len(m) > 0 and verbose:
-        print("missing keys:")
-        print(m)
-    if len(u) > 0 and verbose:
-        print("unexpected keys:")
-        print(u)
-
-    if 'anything' in ckpt.lower() and vae_ckpt is None:
-        vae_ckpt = 'models/anything-v4.0.vae.pt'
-
-    if vae_ckpt is not None and vae_ckpt != 'None':
-        print(f"Loading vae model from {vae_ckpt}")
-        vae_sd = torch.load(vae_ckpt, map_location="cpu")
-        if "global_step" in vae_sd:
-            print(f"Global Step: {vae_sd['global_step']}")
-        sd = vae_sd["state_dict"]
-        m, u = model.first_stage_model.load_state_dict(sd, strict=False)
-        if len(m) > 0 and verbose:
-            print("missing keys:")
-            print(m)
-        if len(u) > 0 and verbose:
-            print("unexpected keys:")
-            print(u)
-
-    model.cuda()
-    model.eval()
-    return model
-
-
-def resize_numpy_image(image, max_resolution=512 * 512, resize_short_edge=None):
-    h, w = image.shape[:2]
-    if resize_short_edge is not None:
-        k = resize_short_edge / min(h, w)
-    else:
-        k = max_resolution / (h * w)
-        k = k**0.5
-    h = int(np.round(h * k / 64)) * 64
-    w = int(np.round(w * k / 64)) * 64
-    image = cv2.resize(image, (w, h), interpolation=cv2.INTER_LANCZOS4)
-    return image
-
-
-# make uc and prompt shapes match via padding for long prompts
-null_cond = None
-
-def fix_cond_shapes(model, prompt_condition, uc):
-    if uc is None:
-        return prompt_condition, uc
-    global null_cond
-    if null_cond is None:
-        null_cond = model.get_learned_conditioning([""])
-    while prompt_condition.shape[1] > uc.shape[1]:
-        uc = torch.cat((uc, null_cond.repeat((uc.shape[0], 1, 1))), axis=1)
-    while prompt_condition.shape[1] < uc.shape[1]:
-        prompt_condition = torch.cat((prompt_condition, null_cond.repeat((prompt_condition.shape[0], 1, 1))), axis=1)
-    return prompt_condition, uc

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/texttranslation.js

@@ -1,2 +0,0 @@
-import TextTranslation from './behaviors/texttranslation/TextTranslation.js';
-export default TextTranslation;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/colorinput/colorinputbase/ColorInputBase.js

@@ -1,145 +0,0 @@
-import Sizer from '../../sizer/Sizer.js';
-import CreateSwatch from './methods/CreateSwatch.js';
-import CreateInputText from '../../utils/build/CreateInputText.js';
-import ColorStringToInteger from '../../../../plugins/utils/color/ColorStringToInteger.js';
-import GetHexColorString from '../../../../plugins/utils/color/GetHexColorString.js';
-import SetSwatchColor from './methods/SetSwatchColor.js';
-import ResizeGameObject from '../../../../plugins/utils/size/ResizeGameObject.js';
-
-const GetValue = Phaser.Utils.Objects.GetValue;
-const IsPlainObject = Phaser.Utils.Objects.IsPlainObject;
-const Clamp = Phaser.Math.Clamp;
-
-class ColorInput extends Sizer {
-    constructor(scene, config) {
-        if (config === undefined) {
-            config = {};
-        }
-        config.orientation = 0;
-        super(scene, config);
-        this.type = 'rexColorInputLite';
-
-        // Add elements
-        var background = GetValue(config, 'background', undefined);
-
-        var swatchConfig = GetValue(config, 'swatch');
-        var swatchSize;
-        if (IsPlainObject(swatchConfig)) {
-            swatchSize = GetValue(swatchConfig, 'size');
-        }
-        var swatch = CreateSwatch(scene, GetValue(config, 'swatch'));
-
-        var inputTextConfig = GetValue(config, 'inputText', true);
-        var inputText;
-        if (inputTextConfig) {
-            inputText = CreateInputText(scene, inputTextConfig);
-        }
-
-        if (background) {
-            this.addBackground(background);
-        }
-
-        if (swatch) {
-            swatchSize = GetValue(config, 'swatchSize', swatchSize);
-            var squareExpandSwatch;
-            if (swatchSize !== undefined) {
-                ResizeGameObject(swatch, swatchSize, swatchSize);
-                squareExpandSwatch = false;
-            } else {
-                squareExpandSwatch = GetValue(config, 'squareExpandSwatch', true);
-            }
-
-            var fitRatio = (squareExpandSwatch) ? 1 : 0;
-            this.add(
-                swatch,
-                { proportion: 0, expand: false, fitRatio: fitRatio }
-            );
-        }
-
-        if (inputText) {
-            var proportion = (GetValue(inputTextConfig, 'width') === undefined) ? 1 : 0;
-            var expand = (GetValue(inputTextConfig, 'height') === undefined) ? true : false;
-            this.add(
-                inputText,
-                { proportion: proportion, expand: expand }
-            )
-        }
-
-        this.addChildrenMap('background', background);
-        this.addChildrenMap('swatch', swatch);
-        this.addChildrenMap('inputText', inputText);
-
-
-        if (inputText) {
-            inputText.on('close', function () {
-                this.setValue(inputText.value);
-            }, this);
-        }
-
-        var callback = GetValue(config, 'valuechangeCallback', null);
-        if (callback !== null) {
-            var scope = GetValue(config, 'valuechangeCallbackScope', undefined);
-            this.on('valuechange', callback, scope);
-        }
-
-        this.setValue(GetValue(config, 'value', 0x0));
-    }
-
-    get value() {
-        return this._value;
-    }
-
-    set value(value) {
-        if (typeof (value) === 'string') {
-            value = ColorStringToInteger(value);
-            if (value == null) {
-                var inputText = this.childrenMap.inputText;
-                if (inputText) {
-                    inputText.setText(GetHexColorString(this._value));
-                }
-                return;
-            }
-        } else {
-            value = Clamp(Math.floor(value), 0, 0xffffff);
-        }
-
-        if (this._value === value) {
-            return;
-        }
-
-        this._value = value;
-
-        var swatch = this.childrenMap.swatch;
-        if (swatch) {
-            SetSwatchColor(swatch, value);
-        }
-
-        var inputText = this.childrenMap.inputText;
-        if (inputText) {
-            inputText.setText(GetHexColorString(value));
-        }
-
-        this.emit('valuechange', this._value);
-    }
-
-    setValue(value) {
-        this.value = value;
-        return this;
-    }
-
-    get color() {
-        return this._value;
-    }
-
-    set color(color) {
-        this.value = color;
-    }
-
-    setColor(color) {
-        this.color = color;
-        return this;
-    }
-
-}
-
-export default ColorInput;

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

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

spaces/AlexWang/lama/models/ade20k/segm_lib/nn/modules/replicate.py

@@ -1,94 +0,0 @@
-# -*- coding: utf-8 -*-
-# File   : replicate.py
-# Author : Jiayuan Mao
-# Email  : [email protected]
-# Date   : 27/01/2018
-# 
-# This file is part of Synchronized-BatchNorm-PyTorch.
-# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch
-# Distributed under MIT License.
-
-import functools
-
-from torch.nn.parallel.data_parallel import DataParallel
-
-__all__ = [
-    'CallbackContext',
-    'execute_replication_callbacks',
-    'DataParallelWithCallback',
-    'patch_replication_callback'
-]
-
-
-class CallbackContext(object):
-    pass
-
-
-def execute_replication_callbacks(modules):
-    """
-    Execute an replication callback `__data_parallel_replicate__` on each module created by original replication.
-
-    The callback will be invoked with arguments `__data_parallel_replicate__(ctx, copy_id)`
-
-    Note that, as all modules are isomorphism, we assign each sub-module with a context
-    (shared among multiple copies of this module on different devices).
-    Through this context, different copies can share some information.
-
-    We guarantee that the callback on the master copy (the first copy) will be called ahead of calling the callback
-    of any slave copies.
-    """
-    master_copy = modules[0]
-    nr_modules = len(list(master_copy.modules()))
-    ctxs = [CallbackContext() for _ in range(nr_modules)]
-
-    for i, module in enumerate(modules):
-        for j, m in enumerate(module.modules()):
-            if hasattr(m, '__data_parallel_replicate__'):
-                m.__data_parallel_replicate__(ctxs[j], i)
-
-
-class DataParallelWithCallback(DataParallel):
-    """
-    Data Parallel with a replication callback.
-
-    An replication callback `__data_parallel_replicate__` of each module will be invoked after being created by
-    original `replicate` function.
-    The callback will be invoked with arguments `__data_parallel_replicate__(ctx, copy_id)`
-
-    Examples:
-        > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)
-        > sync_bn = DataParallelWithCallback(sync_bn, device_ids=[0, 1])
-        # sync_bn.__data_parallel_replicate__ will be invoked.
-    """
-
-    def replicate(self, module, device_ids):
-        modules = super(DataParallelWithCallback, self).replicate(module, device_ids)
-        execute_replication_callbacks(modules)
-        return modules
-
-
-def patch_replication_callback(data_parallel):
-    """
-    Monkey-patch an existing `DataParallel` object. Add the replication callback.
-    Useful when you have customized `DataParallel` implementation.
-
-    Examples:
-        > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)
-        > sync_bn = DataParallel(sync_bn, device_ids=[0, 1])
-        > patch_replication_callback(sync_bn)
-        # this is equivalent to
-        > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)
-        > sync_bn = DataParallelWithCallback(sync_bn, device_ids=[0, 1])
-    """
-
-    assert isinstance(data_parallel, DataParallel)
-
-    old_replicate = data_parallel.replicate
-
-    @functools.wraps(old_replicate)
-    def new_replicate(module, device_ids):
-        modules = old_replicate(module, device_ids)
-        execute_replication_callbacks(modules)
-        return modules
-
-    data_parallel.replicate = new_replicate

spaces/Alpaca233/SadTalker/src/face3d/models/arcface_torch/torch2onnx.py

@@ -1,59 +0,0 @@
-import numpy as np
-import onnx
-import torch
-
-
-def convert_onnx(net, path_module, output, opset=11, simplify=False):
-    assert isinstance(net, torch.nn.Module)
-    img = np.random.randint(0, 255, size=(112, 112, 3), dtype=np.int32)
-    img = img.astype(np.float)
-    img = (img / 255. - 0.5) / 0.5  # torch style norm
-    img = img.transpose((2, 0, 1))
-    img = torch.from_numpy(img).unsqueeze(0).float()
-
-    weight = torch.load(path_module)
-    net.load_state_dict(weight)
-    net.eval()
-    torch.onnx.export(net, img, output, keep_initializers_as_inputs=False, verbose=False, opset_version=opset)
-    model = onnx.load(output)
-    graph = model.graph
-    graph.input[0].type.tensor_type.shape.dim[0].dim_param = 'None'
-    if simplify:
-        from onnxsim import simplify
-        model, check = simplify(model)
-        assert check, "Simplified ONNX model could not be validated"
-    onnx.save(model, output)
-
-    
-if __name__ == '__main__':
-    import os
-    import argparse
-    from backbones import get_model
-
-    parser = argparse.ArgumentParser(description='ArcFace PyTorch to onnx')
-    parser.add_argument('input', type=str, help='input backbone.pth file or path')
-    parser.add_argument('--output', type=str, default=None, help='output onnx path')
-    parser.add_argument('--network', type=str, default=None, help='backbone network')
-    parser.add_argument('--simplify', type=bool, default=False, help='onnx simplify')
-    args = parser.parse_args()
-    input_file = args.input
-    if os.path.isdir(input_file):
-        input_file = os.path.join(input_file, "backbone.pth")
-    assert os.path.exists(input_file)
-    model_name = os.path.basename(os.path.dirname(input_file)).lower()
-    params = model_name.split("_")
-    if len(params) >= 3 and params[1] in ('arcface', 'cosface'):
-        if args.network is None:
-            args.network = params[2]
-    assert args.network is not None
-    print(args)
-    backbone_onnx = get_model(args.network, dropout=0)
-
-    output_path = args.output
-    if output_path is None:
-        output_path = os.path.join(os.path.dirname(__file__), 'onnx')
-    if not os.path.exists(output_path):
-        os.makedirs(output_path)
-    assert os.path.isdir(output_path)
-    output_file = os.path.join(output_path, "%s.onnx" % model_name)
-    convert_onnx(backbone_onnx, input_file, output_file, simplify=args.simplify)

spaces/Alpaca233/SadTalker/src/utils/text2speech.py

@@ -1,20 +0,0 @@
-import os
-import tempfile
-from TTS.api import TTS
-
-
-class TTSTalker():
-    def __init__(self) -> None:
-        model_name = TTS.list_models()[0]
-        self.tts = TTS(model_name)
-
-    def test(self, text, language='en'):
-
-        tempf  = tempfile.NamedTemporaryFile(
-                delete = False,
-                suffix = ('.'+'wav'),
-            )
-
-        self.tts.tts_to_file(text, speaker=self.tts.speakers[0], language=language, file_path=tempf.name)
-
-        return tempf.name

spaces/Ameaou/academic-chatgpt3.1/theme.py

@@ -1,231 +0,0 @@
-import gradio as gr
-from toolbox import get_conf
-CODE_HIGHLIGHT, = get_conf('CODE_HIGHLIGHT')
-# gradio可用颜色列表
-# gr.themes.utils.colors.slate (石板色)
-# gr.themes.utils.colors.gray (灰色)
-# gr.themes.utils.colors.zinc (锌色)
-# gr.themes.utils.colors.neutral (中性色)
-# gr.themes.utils.colors.stone (石头色)
-# gr.themes.utils.colors.red (红色)
-# gr.themes.utils.colors.orange (橙色)
-# gr.themes.utils.colors.amber (琥珀色)
-# gr.themes.utils.colors.yellow (黄色)
-# gr.themes.utils.colors.lime (酸橙色)
-# gr.themes.utils.colors.green (绿色)
-# gr.themes.utils.colors.emerald (祖母绿)
-# gr.themes.utils.colors.teal (青蓝色)
-# gr.themes.utils.colors.cyan (青色)
-# gr.themes.utils.colors.sky (天蓝色)
-# gr.themes.utils.colors.blue (蓝色)
-# gr.themes.utils.colors.indigo (靛蓝色)
-# gr.themes.utils.colors.violet (紫罗兰色)
-# gr.themes.utils.colors.purple (紫色)
-# gr.themes.utils.colors.fuchsia (洋红色)
-# gr.themes.utils.colors.pink (粉红色)
-# gr.themes.utils.colors.rose (玫瑰色)
-
-
-def adjust_theme():
-    try:
-        color_er = gr.themes.utils.colors.fuchsia
-        set_theme = gr.themes.Default(
-            primary_hue=gr.themes.utils.colors.orange,
-            neutral_hue=gr.themes.utils.colors.gray,
-            font=["sans-serif", "Microsoft YaHei", "ui-sans-serif", "system-ui",
-                  "sans-serif", gr.themes.utils.fonts.GoogleFont("Source Sans Pro")],
-            font_mono=["ui-monospace", "Consolas", "monospace", gr.themes.utils.fonts.GoogleFont("IBM Plex Mono")])
-        set_theme.set(
-            # Colors
-            input_background_fill_dark="*neutral_800",
-            # Transition
-            button_transition="none",
-            # Shadows
-            button_shadow="*shadow_drop",
-            button_shadow_hover="*shadow_drop_lg",
-            button_shadow_active="*shadow_inset",
-            input_shadow="0 0 0 *shadow_spread transparent, *shadow_inset",
-            input_shadow_focus="0 0 0 *shadow_spread *secondary_50, *shadow_inset",
-            input_shadow_focus_dark="0 0 0 *shadow_spread *neutral_700, *shadow_inset",
-            checkbox_label_shadow="*shadow_drop",
-            block_shadow="*shadow_drop",
-            form_gap_width="1px",
-            # Button borders
-            input_border_width="1px",
-            input_background_fill="white",
-            # Gradients
-            stat_background_fill="linear-gradient(to right, *primary_400, *primary_200)",
-            stat_background_fill_dark="linear-gradient(to right, *primary_400, *primary_600)",
-            error_background_fill=f"linear-gradient(to right, {color_er.c100}, *background_fill_secondary)",
-            error_background_fill_dark="*background_fill_primary",
-            checkbox_label_background_fill="linear-gradient(to top, *neutral_50, white)",
-            checkbox_label_background_fill_dark="linear-gradient(to top, *neutral_900, *neutral_800)",
-            checkbox_label_background_fill_hover="linear-gradient(to top, *neutral_100, white)",
-            checkbox_label_background_fill_hover_dark="linear-gradient(to top, *neutral_900, *neutral_800)",
-            button_primary_background_fill="linear-gradient(to bottom right, *primary_100, *primary_300)",
-            button_primary_background_fill_dark="linear-gradient(to bottom right, *primary_500, *primary_600)",
-            button_primary_background_fill_hover="linear-gradient(to bottom right, *primary_100, *primary_200)",
-            button_primary_background_fill_hover_dark="linear-gradient(to bottom right, *primary_500, *primary_500)",
-            button_primary_border_color_dark="*primary_500",
-            button_secondary_background_fill="linear-gradient(to bottom right, *neutral_100, *neutral_200)",
-            button_secondary_background_fill_dark="linear-gradient(to bottom right, *neutral_600, *neutral_700)",
-            button_secondary_background_fill_hover="linear-gradient(to bottom right, *neutral_100, *neutral_100)",
-            button_secondary_background_fill_hover_dark="linear-gradient(to bottom right, *neutral_600, *neutral_600)",
-            button_cancel_background_fill=f"linear-gradient(to bottom right, {color_er.c100}, {color_er.c200})",
-            button_cancel_background_fill_dark=f"linear-gradient(to bottom right, {color_er.c600}, {color_er.c700})",
-            button_cancel_background_fill_hover=f"linear-gradient(to bottom right, {color_er.c100}, {color_er.c100})",
-            button_cancel_background_fill_hover_dark=f"linear-gradient(to bottom right, {color_er.c600}, {color_er.c600})",
-            button_cancel_border_color=color_er.c200,
-            button_cancel_border_color_dark=color_er.c600,
-            button_cancel_text_color=color_er.c600,
-            button_cancel_text_color_dark="white",
-        )
-    except:
-        set_theme = None
-        print('gradio版本较旧, 不能自定义字体和颜色')
-    return set_theme
-
-
-advanced_css = """
-/* 设置表格的外边距为1em，内部单元���之间边框合并，空单元格显示. */
-.markdown-body table {
-    margin: 1em 0;
-    border-collapse: collapse;
-    empty-cells: show;
-}
-
-/* 设置表格单元格的内边距为5px，边框粗细为1.2px，颜色为--border-color-primary. */
-.markdown-body th, .markdown-body td {
-    border: 1.2px solid var(--border-color-primary);
-    padding: 5px;
-}
-
-/* 设置表头背景颜色为rgba(175,184,193,0.2)，透明度为0.2. */
-.markdown-body thead {
-    background-color: rgba(175,184,193,0.2);
-}
-
-/* 设置表头单元格的内边距为0.5em和0.2em. */
-.markdown-body thead th {
-    padding: .5em .2em;
-}
-
-/* 去掉列表前缀的默认间距，使其与文本线对齐. */
-.markdown-body ol, .markdown-body ul {
-    padding-inline-start: 2em !important;
-}
-
-/* 设定聊天气泡的样式，包括圆角、最大宽度和阴影等. */
-[class *= "message"] {
-    border-radius: var(--radius-xl) !important;
-    /* padding: var(--spacing-xl) !important; */
-    /* font-size: var(--text-md) !important; */
-    /* line-height: var(--line-md) !important; */
-    /* min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl)); */
-    /* min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl)); */
-}
-[data-testid = "bot"] {
-    max-width: 95%;
-    /* width: auto !important; */
-    border-bottom-left-radius: 0 !important;
-}
-[data-testid = "user"] {
-    max-width: 100%;
-    /* width: auto !important; */
-    border-bottom-right-radius: 0 !important;
-}
-
-/* 行内代码的背景设为淡灰色，设定圆角和间距. */
-.markdown-body code {
-    display: inline;
-    white-space: break-spaces;
-    border-radius: 6px;
-    margin: 0 2px 0 2px;
-    padding: .2em .4em .1em .4em;
-    background-color: rgba(175,184,193,0.2);
-}
-/* 设定代码块的样式，包括背景颜色、内、外边距、圆角。 */
-.markdown-body pre code {
-    display: block;
-    overflow: auto;
-    white-space: pre;
-    background-color: rgba(175,184,193,0.2);
-    border-radius: 10px;
-    padding: 1em;
-    margin: 1em 2em 1em 0.5em;
-}
-
-"""
-
-if CODE_HIGHLIGHT:
-    advanced_css += """
-
-.hll { background-color: #ffffcc }
-.c { color: #3D7B7B; font-style: italic } /* Comment */
-.err { border: 1px solid #FF0000 } /* Error */
-.k { color: hsl(197, 94%, 51%); font-weight: bold } /* Keyword */
-.o { color: #666666 } /* Operator */
-.ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */
-.cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */
-.cp { color: #9C6500 } /* Comment.Preproc */
-.cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */
-.c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */
-.cs { color: #3D7B7B; font-style: italic } /* Comment.Special */
-.gd { color: #A00000 } /* Generic.Deleted */
-.ge { font-style: italic } /* Generic.Emph */
-.gr { color: #E40000 } /* Generic.Error */
-.gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.gi { color: #008400 } /* Generic.Inserted */
-.go { color: #717171 } /* Generic.Output */
-.gp { color: #000080; font-weight: bold } /* Generic.Prompt */
-.gs { font-weight: bold } /* Generic.Strong */
-.gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.gt { color: #a9dd00 } /* Generic.Traceback */
-.kc { color: #008000; font-weight: bold } /* Keyword.Constant */
-.kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
-.kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
-.kp { color: #008000 } /* Keyword.Pseudo */
-.kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
-.kt { color: #B00040 } /* Keyword.Type */
-.m { color: #666666 } /* Literal.Number */
-.s { color: #BA2121 } /* Literal.String */
-.na { color: #687822 } /* Name.Attribute */
-.nb { color: #e5f8c3 } /* Name.Builtin */
-.nc { color: #ffad65; font-weight: bold } /* Name.Class */
-.no { color: #880000 } /* Name.Constant */
-.nd { color: #AA22FF } /* Name.Decorator */
-.ni { color: #717171; font-weight: bold } /* Name.Entity */
-.ne { color: #CB3F38; font-weight: bold } /* Name.Exception */
-.nf { color: #f9f978 } /* Name.Function */
-.nl { color: #767600 } /* Name.Label */
-.nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
-.nt { color: #008000; font-weight: bold } /* Name.Tag */
-.nv { color: #19177C } /* Name.Variable */
-.ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
-.w { color: #bbbbbb } /* Text.Whitespace */
-.mb { color: #666666 } /* Literal.Number.Bin */
-.mf { color: #666666 } /* Literal.Number.Float */
-.mh { color: #666666 } /* Literal.Number.Hex */
-.mi { color: #666666 } /* Literal.Number.Integer */
-.mo { color: #666666 } /* Literal.Number.Oct */
-.sa { color: #BA2121 } /* Literal.String.Affix */
-.sb { color: #BA2121 } /* Literal.String.Backtick */
-.sc { color: #BA2121 } /* Literal.String.Char */
-.dl { color: #BA2121 } /* Literal.String.Delimiter */
-.sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
-.s2 { color: #2bf840 } /* Literal.String.Double */
-.se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */
-.sh { color: #BA2121 } /* Literal.String.Heredoc */
-.si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */
-.sx { color: #008000 } /* Literal.String.Other */
-.sr { color: #A45A77 } /* Literal.String.Regex */
-.s1 { color: #BA2121 } /* Literal.String.Single */
-.ss { color: #19177C } /* Literal.String.Symbol */
-.bp { color: #008000 } /* Name.Builtin.Pseudo */
-.fm { color: #0000FF } /* Name.Function.Magic */
-.vc { color: #19177C } /* Name.Variable.Class */
-.vg { color: #19177C } /* Name.Variable.Global */
-.vi { color: #19177C } /* Name.Variable.Instance */
-.vm { color: #19177C } /* Name.Variable.Magic */
-.il { color: #666666 } /* Literal.Number.Integer.Long */
-"""

spaces/Amrrs/DragGan-Inversion/stylegan_human/torch_utils/ops/filtered_lrelu.py

@@ -1,315 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import os
-import numpy as np
-import torch
-import warnings
-
-from .. import custom_ops
-from .. import misc
-from . import upfirdn2d
-from . import bias_act
-
-# ----------------------------------------------------------------------------
-
-_plugin = None
-
-
-def _init():
-    global _plugin
-    if _plugin is None:
-
-        # sources=['filtered_lrelu.h', 'filtered_lrelu.cu', 'filtered_lrelu.cpp', 'filtered_lrelu_wr.cu', 'filtered_lrelu_rd.cu', 'filtered_lrelu_ns.cu']
-        # sources = [os.path.join(os.path.dirname(__file__), s) for s in sources]
-        # try:
-        #     _plugin = custom_ops.get_plugin('filtered_lrelu_plugin', sources=sources, extra_cuda_cflags=['--use_fast_math', '--allow-unsupported-compiler'])
-        # except:
-        #     warnings.warn('Failed to build CUDA kernels for filtered_lrelu_plugin. Falling back to slow reference implementation. Details:\n\n' + traceback.format_exc())
-
-        _plugin = custom_ops.get_plugin_v3(
-            module_name='filtered_lrelu_plugin',
-            sources=['filtered_lrelu.cpp', 'filtered_lrelu_wr.cu',
-                     'filtered_lrelu_rd.cu', 'filtered_lrelu_ns.cu'],
-            headers=['filtered_lrelu.h', 'filtered_lrelu.cu'],
-            source_dir=os.path.dirname(__file__),
-            extra_cuda_cflags=['--use_fast_math',
-                               '--allow-unsupported-compiler'],
-        )
-    return True
-
-
-def _get_filter_size(f):
-    if f is None:
-        return 1, 1
-    assert isinstance(f, torch.Tensor)
-    assert 1 <= f.ndim <= 2
-    return f.shape[-1], f.shape[0]  # width, height
-
-
-def _parse_padding(padding):
-    if isinstance(padding, int):
-        padding = [padding, padding]
-    assert isinstance(padding, (list, tuple))
-    assert all(isinstance(x, (int, np.integer)) for x in padding)
-    padding = [int(x) for x in padding]
-    if len(padding) == 2:
-        px, py = padding
-        padding = [px, px, py, py]
-    px0, px1, py0, py1 = padding
-    return px0, px1, py0, py1
-
-# ----------------------------------------------------------------------------
-
-
-def filtered_lrelu(x, fu=None, fd=None, b=None, up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False, impl='cuda'):
-    r"""Filtered leaky ReLU for a batch of 2D images.
-
-    Performs the following sequence of operations for each channel:
-
-    1. Add channel-specific bias if provided (`b`).
-
-    2. Upsample the image by inserting N-1 zeros after each pixel (`up`).
-
-    3. Pad the image with the specified number of zeros on each side (`padding`).
-       Negative padding corresponds to cropping the image.
-
-    4. Convolve the image with the specified upsampling FIR filter (`fu`), shrinking it
-       so that the footprint of all output pixels lies within the input image.
-
-    5. Multiply each value by the provided gain factor (`gain`).
-
-    6. Apply leaky ReLU activation function to each value.
-
-    7. Clamp each value between -clamp and +clamp, if `clamp` parameter is provided.
-
-    8. Convolve the image with the specified downsampling FIR filter (`fd`), shrinking
-       it so that the footprint of all output pixels lies within the input image.
-
-    9. Downsample the image by keeping every Nth pixel (`down`).
-
-    The fused op is considerably more efficient than performing the same calculation
-    using standard PyTorch ops. It supports gradients of arbitrary order.
-
-    Args:
-        x:           Float32/float16/float64 input tensor of the shape
-                     `[batch_size, num_channels, in_height, in_width]`.
-        fu:          Float32 upsampling FIR filter of the shape
-                     `[filter_height, filter_width]` (non-separable),
-                     `[filter_taps]` (separable), or
-                     `None` (identity).
-        fd:          Float32 downsampling FIR filter of the shape
-                     `[filter_height, filter_width]` (non-separable),
-                     `[filter_taps]` (separable), or
-                     `None` (identity).
-        b:           Bias vector, or `None` to disable. Must be a 1D tensor of the same type
-                     as `x`. The length of vector must must match the channel dimension of `x`.
-        up:          Integer upsampling factor (default: 1).
-        down:        Integer downsampling factor. (default: 1).
-        padding:     Padding with respect to the upsampled image. Can be a single number
-                     or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]`
-                     (default: 0).
-        gain:        Overall scaling factor for signal magnitude (default: sqrt(2)).
-        slope:       Slope on the negative side of leaky ReLU (default: 0.2).
-        clamp:       Maximum magnitude for leaky ReLU output (default: None).
-        flip_filter: False = convolution, True = correlation (default: False).
-        impl:        Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`).
-
-    Returns:
-        Tensor of the shape `[batch_size, num_channels, out_height, out_width]`.
-    """
-    assert isinstance(x, torch.Tensor)
-    assert impl in ['ref', 'cuda']
-    if impl == 'cuda' and x.device.type == 'cuda' and _init():
-        return _filtered_lrelu_cuda(up=up, down=down, padding=padding, gain=gain, slope=slope, clamp=clamp, flip_filter=flip_filter).apply(x, fu, fd, b, None, 0, 0)
-    return _filtered_lrelu_ref(x, fu=fu, fd=fd, b=b, up=up, down=down, padding=padding, gain=gain, slope=slope, clamp=clamp, flip_filter=flip_filter)
-
-# ----------------------------------------------------------------------------
-
-
-@misc.profiled_function
-def _filtered_lrelu_ref(x, fu=None, fd=None, b=None, up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False):
-    """Slow and memory-inefficient reference implementation of `filtered_lrelu()` using
-    existing `upfirdn2n()` and `bias_act()` ops.
-    """
-    assert isinstance(x, torch.Tensor) and x.ndim == 4
-    fu_w, fu_h = _get_filter_size(fu)
-    fd_w, fd_h = _get_filter_size(fd)
-    if b is not None:
-        assert isinstance(b, torch.Tensor) and b.dtype == x.dtype
-        misc.assert_shape(b, [x.shape[1]])
-    assert isinstance(up, int) and up >= 1
-    assert isinstance(down, int) and down >= 1
-    px0, px1, py0, py1 = _parse_padding(padding)
-    assert gain == float(gain) and gain > 0
-    assert slope == float(slope) and slope >= 0
-    assert clamp is None or (clamp == float(clamp) and clamp >= 0)
-
-    # Calculate output size.
-    batch_size, channels, in_h, in_w = x.shape
-    in_dtype = x.dtype
-    out_w = (in_w * up + (px0 + px1) - (fu_w - 1) -
-             (fd_w - 1) + (down - 1)) // down
-    out_h = (in_h * up + (py0 + py1) - (fu_h - 1) -
-             (fd_h - 1) + (down - 1)) // down
-
-    # Compute using existing ops.
-    x = bias_act.bias_act(x=x, b=b)  # Apply bias.
-    # Upsample.
-    x = upfirdn2d.upfirdn2d(x=x, f=fu, up=up, padding=[
-                            px0, px1, py0, py1], gain=up**2, flip_filter=flip_filter)
-    # Bias, leaky ReLU, clamp.
-    x = bias_act.bias_act(x=x, act='lrelu', alpha=slope,
-                          gain=gain, clamp=clamp)
-    # Downsample.
-    x = upfirdn2d.upfirdn2d(x=x, f=fd, down=down, flip_filter=flip_filter)
-
-    # Check output shape & dtype.
-    misc.assert_shape(x, [batch_size, channels, out_h, out_w])
-    assert x.dtype == in_dtype
-    return x
-
-# ----------------------------------------------------------------------------
-
-
-_filtered_lrelu_cuda_cache = dict()
-
-
-def _filtered_lrelu_cuda(up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False):
-    """Fast CUDA implementation of `filtered_lrelu()` using custom ops.
-    """
-    assert isinstance(up, int) and up >= 1
-    assert isinstance(down, int) and down >= 1
-    px0, px1, py0, py1 = _parse_padding(padding)
-    assert gain == float(gain) and gain > 0
-    gain = float(gain)
-    assert slope == float(slope) and slope >= 0
-    slope = float(slope)
-    assert clamp is None or (clamp == float(clamp) and clamp >= 0)
-    clamp = float(clamp if clamp is not None else 'inf')
-
-    # Lookup from cache.
-    key = (up, down, px0, px1, py0, py1, gain, slope, clamp, flip_filter)
-    if key in _filtered_lrelu_cuda_cache:
-        return _filtered_lrelu_cuda_cache[key]
-
-    # Forward op.
-    class FilteredLReluCuda(torch.autograd.Function):
-        @staticmethod
-        def forward(ctx, x, fu, fd, b, si, sx, sy):  # pylint: disable=arguments-differ
-            assert isinstance(x, torch.Tensor) and x.ndim == 4
-
-            # Replace empty up/downsample kernels with full 1x1 kernels (faster than separable).
-            if fu is None:
-                fu = torch.ones([1, 1], dtype=torch.float32, device=x.device)
-            if fd is None:
-                fd = torch.ones([1, 1], dtype=torch.float32, device=x.device)
-            assert 1 <= fu.ndim <= 2
-            assert 1 <= fd.ndim <= 2
-
-            # Replace separable 1x1 kernels with full 1x1 kernels when scale factor is 1.
-            if up == 1 and fu.ndim == 1 and fu.shape[0] == 1:
-                fu = fu.square()[None]
-            if down == 1 and fd.ndim == 1 and fd.shape[0] == 1:
-                fd = fd.square()[None]
-
-            # Missing sign input tensor.
-            if si is None:
-                si = torch.empty([0])
-
-            # Missing bias tensor.
-            if b is None:
-                b = torch.zeros([x.shape[1]], dtype=x.dtype, device=x.device)
-
-            # Construct internal sign tensor only if gradients are needed.
-            write_signs = (si.numel() == 0) and (
-                x.requires_grad or b.requires_grad)
-
-            # Warn if input storage strides are not in decreasing order due to e.g. channels-last layout.
-            strides = [x.stride(i) for i in range(x.ndim) if x.size(i) > 1]
-            if any(a < b for a, b in zip(strides[:-1], strides[1:])):
-                warnings.warn(
-                    "low-performance memory layout detected in filtered_lrelu input", RuntimeWarning)
-
-            # Call C++/Cuda plugin if datatype is supported.
-            if x.dtype in [torch.float16, torch.float32]:
-                if torch.cuda.current_stream(x.device) != torch.cuda.default_stream(x.device):
-                    warnings.warn(
-                        "filtered_lrelu called with non-default cuda stream but concurrent execution is not supported", RuntimeWarning)
-                y, so, return_code = _plugin.filtered_lrelu(
-                    x, fu, fd, b, si, up, down, px0, px1, py0, py1, sx, sy, gain, slope, clamp, flip_filter, write_signs)
-            else:
-                return_code = -1
-
-            # No Cuda kernel found? Fall back to generic implementation. Still more memory efficient than the reference implementation because
-            # only the bit-packed sign tensor is retained for gradient computation.
-            if return_code < 0:
-                warnings.warn(
-                    "filtered_lrelu called with parameters that have no optimized CUDA kernel, using generic fallback", RuntimeWarning)
-
-                y = x.add(b.unsqueeze(-1).unsqueeze(-1))  # Add bias.
-                # Upsample.
-                y = upfirdn2d.upfirdn2d(x=y, f=fu, up=up, padding=[
-                                        px0, px1, py0, py1], gain=up**2, flip_filter=flip_filter)
-                # Activation function and sign handling. Modifies y in-place.
-                so = _plugin.filtered_lrelu_act_(
-                    y, si, sx, sy, gain, slope, clamp, write_signs)
-                # Downsample.
-                y = upfirdn2d.upfirdn2d(
-                    x=y, f=fd, down=down, flip_filter=flip_filter)
-
-            # Prepare for gradient computation.
-            ctx.save_for_backward(fu, fd, (si if si.numel() else so))
-            ctx.x_shape = x.shape
-            ctx.y_shape = y.shape
-            ctx.s_ofs = sx, sy
-            return y
-
-        @staticmethod
-        def backward(ctx, dy):  # pylint: disable=arguments-differ
-            fu, fd, si = ctx.saved_tensors
-            _, _, xh, xw = ctx.x_shape
-            _, _, yh, yw = ctx.y_shape
-            sx, sy = ctx.s_ofs
-            dx = None  # 0
-            dfu = None
-            assert not ctx.needs_input_grad[1]
-            dfd = None
-            assert not ctx.needs_input_grad[2]
-            db = None  # 3
-            dsi = None
-            assert not ctx.needs_input_grad[4]
-            dsx = None
-            assert not ctx.needs_input_grad[5]
-            dsy = None
-            assert not ctx.needs_input_grad[6]
-
-            if ctx.needs_input_grad[0] or ctx.needs_input_grad[3]:
-                pp = [
-                    (fu.shape[-1] - 1) + (fd.shape[-1] - 1) - px0,
-                    xw * up - yw * down + px0 - (up - 1),
-                    (fu.shape[0] - 1) + (fd.shape[0] - 1) - py0,
-                    xh * up - yh * down + py0 - (up - 1),
-                ]
-                gg = gain * (up ** 2) / (down ** 2)
-                ff = (not flip_filter)
-                sx = sx - (fu.shape[-1] - 1) + px0
-                sy = sy - (fu.shape[0] - 1) + py0
-                dx = _filtered_lrelu_cuda(up=down, down=up, padding=pp, gain=gg, slope=slope,
-                                          clamp=None, flip_filter=ff).apply(dy, fd, fu, None, si, sx, sy)
-
-            if ctx.needs_input_grad[3]:
-                db = dx.sum([0, 2, 3])
-
-            return dx, dfu, dfd, db, dsi, dsx, dsy
-
-    # Add to cache.
-    _filtered_lrelu_cuda_cache[key] = FilteredLReluCuda
-    return FilteredLReluCuda
-
-# ----------------------------------------------------------------------------

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/schedulers/scheduling_heun_discrete.py

@@ -1,426 +0,0 @@
-# Copyright 2023 Katherine Crowson, The HuggingFace Team and hlky. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-from collections import defaultdict
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import torch
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
-
-
-# Copied from diffusers.schedulers.scheduling_ddpm.betas_for_alpha_bar
-def betas_for_alpha_bar(
-    num_diffusion_timesteps,
-    max_beta=0.999,
-    alpha_transform_type="cosine",
-):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
-    (1-beta) over time from t = [0,1].
-
-    Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
-    to that part of the diffusion process.
-
-
-    Args:
-        num_diffusion_timesteps (`int`): the number of betas to produce.
-        max_beta (`float`): the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-        alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar.
-                     Choose from `cosine` or `exp`
-
-    Returns:
-        betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
-    """
-    if alpha_transform_type == "cosine":
-
-        def alpha_bar_fn(t):
-            return math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2
-
-    elif alpha_transform_type == "exp":
-
-        def alpha_bar_fn(t):
-            return math.exp(t * -12.0)
-
-    else:
-        raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}")
-
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar_fn(t2) / alpha_bar_fn(t1), max_beta))
-    return torch.tensor(betas, dtype=torch.float32)
-
-
-class HeunDiscreteScheduler(SchedulerMixin, ConfigMixin):
-    """
-    Implements Algorithm 2 (Heun steps) from Karras et al. (2022). for discrete beta schedules. Based on the original
-    k-diffusion implementation by Katherine Crowson:
-    https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L90
-
-    [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
-    function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
-    [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
-    [`~SchedulerMixin.from_pretrained`] functions.
-
-    Args:
-        num_train_timesteps (`int`): number of diffusion steps used to train the model. beta_start (`float`): the
-        starting `beta` value of inference. beta_end (`float`): the final `beta` value. beta_schedule (`str`):
-            the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
-            `linear` or `scaled_linear`.
-        trained_betas (`np.ndarray`, optional):
-            option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc.
-        prediction_type (`str`, default `epsilon`, optional):
-            prediction type of the scheduler function, one of `epsilon` (predicting the noise of the diffusion
-            process), `sample` (directly predicting the noisy sample`) or `v_prediction` (see section 2.4
-            https://imagen.research.google/video/paper.pdf).
-        clip_sample (`bool`, default `True`):
-            option to clip predicted sample for numerical stability.
-        clip_sample_range (`float`, default `1.0`):
-            the maximum magnitude for sample clipping. Valid only when `clip_sample=True`.
-        use_karras_sigmas (`bool`, *optional*, defaults to `False`):
-             This parameter controls whether to use Karras sigmas (Karras et al. (2022) scheme) for step sizes in the
-             noise schedule during the sampling process. If True, the sigmas will be determined according to a sequence
-             of noise levels {σi} as defined in Equation (5) of the paper https://arxiv.org/pdf/2206.00364.pdf.
-        timestep_spacing (`str`, default `"linspace"`):
-            The way the timesteps should be scaled. Refer to Table 2. of [Common Diffusion Noise Schedules and Sample
-            Steps are Flawed](https://arxiv.org/abs/2305.08891) for more information.
-        steps_offset (`int`, default `0`):
-            an offset added to the inference steps. You can use a combination of `offset=1` and
-            `set_alpha_to_one=False`, to make the last step use step 0 for the previous alpha product, as done in
-            stable diffusion.
-    """
-
-    _compatibles = [e.name for e in KarrasDiffusionSchedulers]
-    order = 2
-
-    @register_to_config
-    def __init__(
-        self,
-        num_train_timesteps: int = 1000,
-        beta_start: float = 0.00085,  # sensible defaults
-        beta_end: float = 0.012,
-        beta_schedule: str = "linear",
-        trained_betas: Optional[Union[np.ndarray, List[float]]] = None,
-        prediction_type: str = "epsilon",
-        use_karras_sigmas: Optional[bool] = False,
-        clip_sample: Optional[bool] = False,
-        clip_sample_range: float = 1.0,
-        timestep_spacing: str = "linspace",
-        steps_offset: int = 0,
-    ):
-        if trained_betas is not None:
-            self.betas = torch.tensor(trained_betas, dtype=torch.float32)
-        elif beta_schedule == "linear":
-            self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)
-        elif beta_schedule == "scaled_linear":
-            # this schedule is very specific to the latent diffusion model.
-            self.betas = (
-                torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2
-            )
-        elif beta_schedule == "squaredcos_cap_v2":
-            # Glide cosine schedule
-            self.betas = betas_for_alpha_bar(num_train_timesteps, alpha_transform_type="cosine")
-        elif beta_schedule == "exp":
-            self.betas = betas_for_alpha_bar(num_train_timesteps, alpha_transform_type="exp")
-        else:
-            raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
-
-        self.alphas = 1.0 - self.betas
-        self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
-
-        #  set all values
-        self.set_timesteps(num_train_timesteps, None, num_train_timesteps)
-        self.use_karras_sigmas = use_karras_sigmas
-
-    def index_for_timestep(self, timestep, schedule_timesteps=None):
-        if schedule_timesteps is None:
-            schedule_timesteps = self.timesteps
-
-        indices = (schedule_timesteps == timestep).nonzero()
-
-        # The sigma index that is taken for the **very** first `step`
-        # is always the second index (or the last index if there is only 1)
-        # This way we can ensure we don't accidentally skip a sigma in
-        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
-        if len(self._index_counter) == 0:
-            pos = 1 if len(indices) > 1 else 0
-        else:
-            timestep_int = timestep.cpu().item() if torch.is_tensor(timestep) else timestep
-            pos = self._index_counter[timestep_int]
-
-        return indices[pos].item()
-
-    @property
-    def init_noise_sigma(self):
-        # standard deviation of the initial noise distribution
-        if self.config.timestep_spacing in ["linspace", "trailing"]:
-            return self.sigmas.max()
-
-        return (self.sigmas.max() ** 2 + 1) ** 0.5
-
-    def scale_model_input(
-        self,
-        sample: torch.FloatTensor,
-        timestep: Union[float, torch.FloatTensor],
-    ) -> torch.FloatTensor:
-        """
-        Args:
-        Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
-        current timestep.
-            sample (`torch.FloatTensor`): input sample timestep (`int`, optional): current timestep
-        Returns:
-            `torch.FloatTensor`: scaled input sample
-        """
-        step_index = self.index_for_timestep(timestep)
-
-        sigma = self.sigmas[step_index]
-        sample = sample / ((sigma**2 + 1) ** 0.5)
-        return sample
-
-    def set_timesteps(
-        self,
-        num_inference_steps: int,
-        device: Union[str, torch.device] = None,
-        num_train_timesteps: Optional[int] = None,
-    ):
-        """
-        Sets the timesteps used for the diffusion chain. Supporting function to be run before inference.
-
-        Args:
-            num_inference_steps (`int`):
-                the number of diffusion steps used when generating samples with a pre-trained model.
-            device (`str` or `torch.device`, optional):
-                the device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
-        """
-        self.num_inference_steps = num_inference_steps
-
-        num_train_timesteps = num_train_timesteps or self.config.num_train_timesteps
-
-        # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
-        if self.config.timestep_spacing == "linspace":
-            timesteps = np.linspace(0, num_train_timesteps - 1, num_inference_steps, dtype=float)[::-1].copy()
-        elif self.config.timestep_spacing == "leading":
-            step_ratio = num_train_timesteps // self.num_inference_steps
-            # creates integer timesteps by multiplying by ratio
-            # casting to int to avoid issues when num_inference_step is power of 3
-            timesteps = (np.arange(0, num_inference_steps) * step_ratio).round()[::-1].copy().astype(float)
-            timesteps += self.config.steps_offset
-        elif self.config.timestep_spacing == "trailing":
-            step_ratio = num_train_timesteps / self.num_inference_steps
-            # creates integer timesteps by multiplying by ratio
-            # casting to int to avoid issues when num_inference_step is power of 3
-            timesteps = (np.arange(num_train_timesteps, 0, -step_ratio)).round().copy().astype(float)
-            timesteps -= 1
-        else:
-            raise ValueError(
-                f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."
-            )
-
-        sigmas = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5)
-        log_sigmas = np.log(sigmas)
-        sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas)
-
-        if self.config.use_karras_sigmas:
-            sigmas = self._convert_to_karras(in_sigmas=sigmas, num_inference_steps=self.num_inference_steps)
-            timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas])
-
-        sigmas = np.concatenate([sigmas, [0.0]]).astype(np.float32)
-        sigmas = torch.from_numpy(sigmas).to(device=device)
-        self.sigmas = torch.cat([sigmas[:1], sigmas[1:-1].repeat_interleave(2), sigmas[-1:]])
-
-        timesteps = torch.from_numpy(timesteps)
-        timesteps = torch.cat([timesteps[:1], timesteps[1:].repeat_interleave(2)])
-
-        if str(device).startswith("mps"):
-            # mps does not support float64
-            self.timesteps = timesteps.to(device, dtype=torch.float32)
-        else:
-            self.timesteps = timesteps.to(device=device)
-
-        # empty dt and derivative
-        self.prev_derivative = None
-        self.dt = None
-
-        # for exp beta schedules, such as the one for `pipeline_shap_e.py`
-        # we need an index counter
-        self._index_counter = defaultdict(int)
-
-    # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._sigma_to_t
-    def _sigma_to_t(self, sigma, log_sigmas):
-        # get log sigma
-        log_sigma = np.log(sigma)
-
-        # get distribution
-        dists = log_sigma - log_sigmas[:, np.newaxis]
-
-        # get sigmas range
-        low_idx = np.cumsum((dists >= 0), axis=0).argmax(axis=0).clip(max=log_sigmas.shape[0] - 2)
-        high_idx = low_idx + 1
-
-        low = log_sigmas[low_idx]
-        high = log_sigmas[high_idx]
-
-        # interpolate sigmas
-        w = (low - log_sigma) / (low - high)
-        w = np.clip(w, 0, 1)
-
-        # transform interpolation to time range
-        t = (1 - w) * low_idx + w * high_idx
-        t = t.reshape(sigma.shape)
-        return t
-
-    # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_karras
-    def _convert_to_karras(self, in_sigmas: torch.FloatTensor, num_inference_steps) -> torch.FloatTensor:
-        """Constructs the noise schedule of Karras et al. (2022)."""
-
-        sigma_min: float = in_sigmas[-1].item()
-        sigma_max: float = in_sigmas[0].item()
-
-        rho = 7.0  # 7.0 is the value used in the paper
-        ramp = np.linspace(0, 1, num_inference_steps)
-        min_inv_rho = sigma_min ** (1 / rho)
-        max_inv_rho = sigma_max ** (1 / rho)
-        sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
-        return sigmas
-
-    @property
-    def state_in_first_order(self):
-        return self.dt is None
-
-    def step(
-        self,
-        model_output: Union[torch.FloatTensor, np.ndarray],
-        timestep: Union[float, torch.FloatTensor],
-        sample: Union[torch.FloatTensor, np.ndarray],
-        return_dict: bool = True,
-    ) -> Union[SchedulerOutput, Tuple]:
-        """
-        Args:
-        Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
-        process from the learned model outputs (most often the predicted noise).
-            model_output (`torch.FloatTensor` or `np.ndarray`): direct output from learned diffusion model. timestep
-            (`int`): current discrete timestep in the diffusion chain. sample (`torch.FloatTensor` or `np.ndarray`):
-                current instance of sample being created by diffusion process.
-            return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-        Returns:
-            [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`:
-            [`~schedulers.scheduling_utils.SchedulerOutput`] if `return_dict` is True, otherwise a `tuple`. When
-            returning a tuple, the first element is the sample tensor.
-        """
-        step_index = self.index_for_timestep(timestep)
-
-        # advance index counter by 1
-        timestep_int = timestep.cpu().item() if torch.is_tensor(timestep) else timestep
-        self._index_counter[timestep_int] += 1
-
-        if self.state_in_first_order:
-            sigma = self.sigmas[step_index]
-            sigma_next = self.sigmas[step_index + 1]
-        else:
-            # 2nd order / Heun's method
-            sigma = self.sigmas[step_index - 1]
-            sigma_next = self.sigmas[step_index]
-
-        # currently only gamma=0 is supported. This usually works best anyways.
-        # We can support gamma in the future but then need to scale the timestep before
-        # passing it to the model which requires a change in API
-        gamma = 0
-        sigma_hat = sigma * (gamma + 1)  # Note: sigma_hat == sigma for now
-
-        # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
-        if self.config.prediction_type == "epsilon":
-            sigma_input = sigma_hat if self.state_in_first_order else sigma_next
-            pred_original_sample = sample - sigma_input * model_output
-        elif self.config.prediction_type == "v_prediction":
-            sigma_input = sigma_hat if self.state_in_first_order else sigma_next
-            pred_original_sample = model_output * (-sigma_input / (sigma_input**2 + 1) ** 0.5) + (
-                sample / (sigma_input**2 + 1)
-            )
-        elif self.config.prediction_type == "sample":
-            pred_original_sample = model_output
-        else:
-            raise ValueError(
-                f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`"
-            )
-
-        if self.config.clip_sample:
-            pred_original_sample = pred_original_sample.clamp(
-                -self.config.clip_sample_range, self.config.clip_sample_range
-            )
-
-        if self.state_in_first_order:
-            # 2. Convert to an ODE derivative for 1st order
-            derivative = (sample - pred_original_sample) / sigma_hat
-            # 3. delta timestep
-            dt = sigma_next - sigma_hat
-
-            # store for 2nd order step
-            self.prev_derivative = derivative
-            self.dt = dt
-            self.sample = sample
-        else:
-            # 2. 2nd order / Heun's method
-            derivative = (sample - pred_original_sample) / sigma_next
-            derivative = (self.prev_derivative + derivative) / 2
-
-            # 3. take prev timestep & sample
-            dt = self.dt
-            sample = self.sample
-
-            # free dt and derivative
-            # Note, this puts the scheduler in "first order mode"
-            self.prev_derivative = None
-            self.dt = None
-            self.sample = None
-
-        prev_sample = sample + derivative * dt
-
-        if not return_dict:
-            return (prev_sample,)
-
-        return SchedulerOutput(prev_sample=prev_sample)
-
-    def add_noise(
-        self,
-        original_samples: torch.FloatTensor,
-        noise: torch.FloatTensor,
-        timesteps: torch.FloatTensor,
-    ) -> torch.FloatTensor:
-        # Make sure sigmas and timesteps have the same device and dtype as original_samples
-        sigmas = self.sigmas.to(device=original_samples.device, dtype=original_samples.dtype)
-        if original_samples.device.type == "mps" and torch.is_floating_point(timesteps):
-            # mps does not support float64
-            schedule_timesteps = self.timesteps.to(original_samples.device, dtype=torch.float32)
-            timesteps = timesteps.to(original_samples.device, dtype=torch.float32)
-        else:
-            schedule_timesteps = self.timesteps.to(original_samples.device)
-            timesteps = timesteps.to(original_samples.device)
-
-        step_indices = [self.index_for_timestep(t, schedule_timesteps) for t in timesteps]
-
-        sigma = sigmas[step_indices].flatten()
-        while len(sigma.shape) < len(original_samples.shape):
-            sigma = sigma.unsqueeze(-1)
-
-        noisy_samples = original_samples + noise * sigma
-        return noisy_samples
-
-    def __len__(self):
-        return self.config.num_train_timesteps

spaces/Andy1621/uniformer_image_detection/configs/hrnet/fcos_hrnetv2p_w18_gn-head_mstrain_640-800_4x4_2x_coco.py

@@ -1,9 +0,0 @@
-_base_ = './fcos_hrnetv2p_w32_gn-head_mstrain_640-800_4x4_2x_coco.py'
-model = dict(
-    pretrained='open-mmlab://msra/hrnetv2_w18',
-    backbone=dict(
-        extra=dict(
-            stage2=dict(num_channels=(18, 36)),
-            stage3=dict(num_channels=(18, 36, 72)),
-            stage4=dict(num_channels=(18, 36, 72, 144)))),
-    neck=dict(type='HRFPN', in_channels=[18, 36, 72, 144], out_channels=256))

spaces/Andy1621/uniformer_image_detection/configs/sabl/sabl_retinanet_r101_fpn_1x_coco.py

@@ -1,52 +0,0 @@
-_base_ = [
-    '../_base_/models/retinanet_r50_fpn.py',
-    '../_base_/datasets/coco_detection.py',
-    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
-]
-# model settings
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(depth=101),
-    bbox_head=dict(
-        _delete_=True,
-        type='SABLRetinaHead',
-        num_classes=80,
-        in_channels=256,
-        stacked_convs=4,
-        feat_channels=256,
-        approx_anchor_generator=dict(
-            type='AnchorGenerator',
-            octave_base_scale=4,
-            scales_per_octave=3,
-            ratios=[0.5, 1.0, 2.0],
-            strides=[8, 16, 32, 64, 128]),
-        square_anchor_generator=dict(
-            type='AnchorGenerator',
-            ratios=[1.0],
-            scales=[4],
-            strides=[8, 16, 32, 64, 128]),
-        bbox_coder=dict(
-            type='BucketingBBoxCoder', num_buckets=14, scale_factor=3.0),
-        loss_cls=dict(
-            type='FocalLoss',
-            use_sigmoid=True,
-            gamma=2.0,
-            alpha=0.25,
-            loss_weight=1.0),
-        loss_bbox_cls=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.5),
-        loss_bbox_reg=dict(
-            type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.5)),
-    # training and testing settings
-    train_cfg=dict(
-        assigner=dict(
-            type='ApproxMaxIoUAssigner',
-            pos_iou_thr=0.5,
-            neg_iou_thr=0.4,
-            min_pos_iou=0.0,
-            ignore_iof_thr=-1),
-        allowed_border=-1,
-        pos_weight=-1,
-        debug=False))
-# optimizer
-optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)

spaces/Andy1621/uniformer_image_detection/mmdet/models/dense_heads/retina_sepbn_head.py

@@ -1,113 +0,0 @@
-import torch.nn as nn
-from mmcv.cnn import ConvModule, bias_init_with_prob, normal_init
-
-from ..builder import HEADS
-from .anchor_head import AnchorHead
-
-
-@HEADS.register_module()
-class RetinaSepBNHead(AnchorHead):
-    """"RetinaHead with separate BN.
-
-    In RetinaHead, conv/norm layers are shared across different FPN levels,
-    while in RetinaSepBNHead, conv layers are shared across different FPN
-    levels, but BN layers are separated.
-    """
-
-    def __init__(self,
-                 num_classes,
-                 num_ins,
-                 in_channels,
-                 stacked_convs=4,
-                 conv_cfg=None,
-                 norm_cfg=None,
-                 **kwargs):
-        self.stacked_convs = stacked_convs
-        self.conv_cfg = conv_cfg
-        self.norm_cfg = norm_cfg
-        self.num_ins = num_ins
-        super(RetinaSepBNHead, self).__init__(num_classes, in_channels,
-                                              **kwargs)
-
-    def _init_layers(self):
-        """Initialize layers of the head."""
-        self.relu = nn.ReLU(inplace=True)
-        self.cls_convs = nn.ModuleList()
-        self.reg_convs = nn.ModuleList()
-        for i in range(self.num_ins):
-            cls_convs = nn.ModuleList()
-            reg_convs = nn.ModuleList()
-            for i in range(self.stacked_convs):
-                chn = self.in_channels if i == 0 else self.feat_channels
-                cls_convs.append(
-                    ConvModule(
-                        chn,
-                        self.feat_channels,
-                        3,
-                        stride=1,
-                        padding=1,
-                        conv_cfg=self.conv_cfg,
-                        norm_cfg=self.norm_cfg))
-                reg_convs.append(
-                    ConvModule(
-                        chn,
-                        self.feat_channels,
-                        3,
-                        stride=1,
-                        padding=1,
-                        conv_cfg=self.conv_cfg,
-                        norm_cfg=self.norm_cfg))
-            self.cls_convs.append(cls_convs)
-            self.reg_convs.append(reg_convs)
-        for i in range(self.stacked_convs):
-            for j in range(1, self.num_ins):
-                self.cls_convs[j][i].conv = self.cls_convs[0][i].conv
-                self.reg_convs[j][i].conv = self.reg_convs[0][i].conv
-        self.retina_cls = nn.Conv2d(
-            self.feat_channels,
-            self.num_anchors * self.cls_out_channels,
-            3,
-            padding=1)
-        self.retina_reg = nn.Conv2d(
-            self.feat_channels, self.num_anchors * 4, 3, padding=1)
-
-    def init_weights(self):
-        """Initialize weights of the head."""
-        for m in self.cls_convs[0]:
-            normal_init(m.conv, std=0.01)
-        for m in self.reg_convs[0]:
-            normal_init(m.conv, std=0.01)
-        bias_cls = bias_init_with_prob(0.01)
-        normal_init(self.retina_cls, std=0.01, bias=bias_cls)
-        normal_init(self.retina_reg, std=0.01)
-
-    def forward(self, feats):
-        """Forward features from the upstream network.
-
-        Args:
-            feats (tuple[Tensor]): Features from the upstream network, each is
-                a 4D-tensor.
-
-        Returns:
-            tuple: Usually a tuple of classification scores and bbox prediction
-                cls_scores (list[Tensor]): Classification scores for all scale
-                    levels, each is a 4D-tensor, the channels number is
-                    num_anchors * num_classes.
-                bbox_preds (list[Tensor]): Box energies / deltas for all scale
-                    levels, each is a 4D-tensor, the channels number is
-                    num_anchors * 4.
-        """
-        cls_scores = []
-        bbox_preds = []
-        for i, x in enumerate(feats):
-            cls_feat = feats[i]
-            reg_feat = feats[i]
-            for cls_conv in self.cls_convs[i]:
-                cls_feat = cls_conv(cls_feat)
-            for reg_conv in self.reg_convs[i]:
-                reg_feat = reg_conv(reg_feat)
-            cls_score = self.retina_cls(cls_feat)
-            bbox_pred = self.retina_reg(reg_feat)
-            cls_scores.append(cls_score)
-            bbox_preds.append(bbox_pred)
-        return cls_scores, bbox_preds

spaces/ArtificialArtist007/Rate-my-Aiart/README.md

@@ -1,13 +0,0 @@
----
-title: Rate My Aiart
-emoji: 🔥
-colorFrom: blue
-colorTo: pink
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
-license: other
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/utils/compat.py

@@ -1,63 +0,0 @@
-"""Stuff that differs in different Python versions and platform
-distributions."""
-
-import logging
-import os
-import sys
-
-__all__ = ["get_path_uid", "stdlib_pkgs", "WINDOWS"]
-
-
-logger = logging.getLogger(__name__)
-
-
-def has_tls() -> bool:
-    try:
-        import _ssl  # noqa: F401  # ignore unused
-
-        return True
-    except ImportError:
-        pass
-
-    from pip._vendor.urllib3.util import IS_PYOPENSSL
-
-    return IS_PYOPENSSL
-
-
-def get_path_uid(path: str) -> int:
-    """
-    Return path's uid.
-
-    Does not follow symlinks:
-        https://github.com/pypa/pip/pull/935#discussion_r5307003
-
-    Placed this function in compat due to differences on AIX and
-    Jython, that should eventually go away.
-
-    :raises OSError: When path is a symlink or can't be read.
-    """
-    if hasattr(os, "O_NOFOLLOW"):
-        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW)
-        file_uid = os.fstat(fd).st_uid
-        os.close(fd)
-    else:  # AIX and Jython
-        # WARNING: time of check vulnerability, but best we can do w/o NOFOLLOW
-        if not os.path.islink(path):
-            # older versions of Jython don't have `os.fstat`
-            file_uid = os.stat(path).st_uid
-        else:
-            # raise OSError for parity with os.O_NOFOLLOW above
-            raise OSError(f"{path} is a symlink; Will not return uid for symlinks")
-    return file_uid
-
-
-# packages in the stdlib that may have installation metadata, but should not be
-# considered 'installed'.  this theoretically could be determined based on
-# dist.location (py27:`sysconfig.get_paths()['stdlib']`,
-# py26:sysconfig.get_config_vars('LIBDEST')), but fear platform variation may
-# make this ineffective, so hard-coding
-stdlib_pkgs = {"python", "wsgiref", "argparse"}
-
-
-# windows detection, covers cpython and ironpython
-WINDOWS = sys.platform.startswith("win") or (sys.platform == "cli" and os.name == "nt")

spaces/Awesimo/jojogan/e4e/datasets/images_dataset.py

@@ -1,33 +0,0 @@
-from torch.utils.data import Dataset
-from PIL import Image
-from utils import data_utils
-
-
-class ImagesDataset(Dataset):
-
-	def __init__(self, source_root, target_root, opts, target_transform=None, source_transform=None):
-		self.source_paths = sorted(data_utils.make_dataset(source_root))
-		self.target_paths = sorted(data_utils.make_dataset(target_root))
-		self.source_transform = source_transform
-		self.target_transform = target_transform
-		self.opts = opts
-
-	def __len__(self):
-		return len(self.source_paths)
-
-	def __getitem__(self, index):
-		from_path = self.source_paths[index]
-		from_im = Image.open(from_path)
-		from_im = from_im.convert('RGB')
-
-		to_path = self.target_paths[index]
-		to_im = Image.open(to_path).convert('RGB')
-		if self.target_transform:
-			to_im = self.target_transform(to_im)
-
-		if self.source_transform:
-			from_im = self.source_transform(from_im)
-		else:
-			from_im = to_im
-
-		return from_im, to_im

spaces/Benson/text-generation/Examples/9no Amanecer Rpg Mod Apk.md

@@ -1,84 +0,0 @@
-<br />
-<h1>9th Dawn RPG Mod APK: Una guía para la aventura definitiva</h1>
-<p>¿Estás buscando un juego de rol divertido e inmersivo que te mantenga enganchado durante horas? ¿Quieres experimentar un mundo vasto y abierto lleno de misterios, peligros y aventuras? Si usted respondió que sí, entonces usted debe tratar 9th Dawn RPG Mod APK, una versión modificada del popular juego 9th Dawn RPG por Valorware. En este artículo, te contaremos todo lo que necesitas saber sobre este increíble juego, incluyendo sus características, historia, beneficios de mod, instrucciones de descarga y consejos y trucos. ¡Sigue leyendo y prepárate para la aventura definitiva! </p>
-<h2>9no amanecer rpg mod apk</h2><br /><p><b><b>Download File</b> &raquo;&raquo;&raquo; <a href="https://bltlly.com/2v6LjG">https://bltlly.com/2v6LjG</a></b></p><br /><br />
- <h2>¿Qué es 9th Dawn RPG? </h2>
-<p>9th Dawn RPG es un juego de rol clásico que fue lanzado en 2012 por Valorware, un desarrollador de juegos independiente. El juego se desarrolla en la isla continente de Montelorne, una tierra alejada del continente, pero llena de misterio, peligro y aventura. Juegas como un héroe que llega a Montelorne para explorar sus secretos y enfrentar sus desafíos. Puedes elegir entre tres clases diferentes: guerrero, mago o arquero, y personalizar la apariencia, habilidades y equipo de tu personaje. También puedes interactuar con varios PNJ, unirte a facciones, completar misiones, recoger objetos, crear armas y armaduras, aprender hechizos, luchar contra enemigos y jefes, y mucho más. El juego tiene un estilo retro pixel art que le da un encanto nostálgico, y un dinámico ciclo día-noche que afecta el juego. El juego también tiene un enorme mundo abierto que puedes explorar libremente, con más de 300 mapas para descubrir. </p>
- <h3>Características de 9th Dawn RPG</h3>
-<p>Algunas de las características que hacen que el 9th Dawn RPG se destaque son:</p>
-<ul>
-<li>Un mundo grande y diverso con más de 300 mapas para explorar, incluyendo bosques, cuevas, mazmorras, pueblos, castillos, islas y más. </li>
-<li>Una historia rica y atractiva con múltiples finales dependiendo de sus opciones y acciones. </li>
-<li>Un dinámico ciclo día-noche que afecta el entorno, los PNJ, los enemigos y las misiones. </li>
-
-<li>Un sistema de combate complejo que te permite usar armas cuerpo a cuerpo, armas a distancia, escudos, hechizos, pociones, trampas y más. </li>
-<li>Un sistema de personalización de personajes que te permite elegir entre tres clases (guerrero, mago o arquero), seleccionar tu género y apariencia, distribuir tus atributos (fuerza, agilidad, inteligencia) y aprender habilidades y hechizos. </li>
-<li>Un sistema de equipos que le permite recoger y elaborar varios artículos como armas, armaduras, accesorios, consumibles, etc.</li>
-<li>Un sistema de inventario que te permite administrar tus artículos y equiparlos en tu personaje. </li>
-<li>Un sistema de facciones que te permite unirte a una de las cuatro facciones en Montelorne: La Orden del León (el ejército real), Los Caballeros de las Sombras (los rebeldes), La Sociedad Arcana (los magos), o La Hermandad (los ladrones). </li>
-<li>Un sistema de búsqueda que te permite aceptar y completar varias tareas de NPC o facciones. </li>
-<li>Un sistema de diálogo que le permite interactuar con los PNJ y elegir sus respuestas. </li>
-<li>Un sistema de guardado que te permite guardar tu progreso en cualquier momento. </li>
-</ul>
- <h3>Historia y escenario del 9º Amanecer RPG</h3>
-<p>La historia de 9th Dawn RPG tiene lugar en la isla continente de Montelorne, una tierra que una vez fue parte de un gran imperio llamado Esteria. Sin embargo, debido a un evento cataclísmico conocido como la Gran Guerra, Montelorne fue separado del continente y sumido en el caos. El imperio colapsó, y cuatro facciones surgieron para competir por el poder y la influencia: La Orden del León, Los Caballeros de la Sombra, La Sociedad Arcana y La Hermandad. Eres un héroe que llega a Montelorne para explorar sus secretos y afrontar sus retos. Puedes elegir alinearte con una de las facciones, o permanecer neutral y forjar tu propio destino. Sus acciones y elecciones darán forma al destino de Montelorne y su gente. </p>
- <h2>¿Qué es 9th Dawn RPG Mod APK? </h2>
-
- <h3>Beneficios de 9th Dawn RPG Mod APK</h3>
-<p>Algunos de los beneficios que se pueden disfrutar mediante el uso de 9th Dawn RPG Mod APK son:</p>
-<ul>
-<li>Dinero ilimitado: Puedes obtener monedas y gemas ilimitadas que puedes usar para comprar artículos, mejorar tu equipo, aprender habilidades y hechizos, etc.</li>
-<li>Artículos desbloqueados: Puedes acceder a todos los objetos del juego, incluyendo armas, armaduras, accesorios, consumibles, etc., sin tener que recogerlos o crearlos. </li>
-<li>Mapas desbloqueados: Puedes explorar todos los mapas del juego, incluidos los ocultos, sin tener que desbloquearlos completando misiones o encontrando claves. </li>
-<li>Sin anuncios: Puedes jugar el juego sin interrupciones o distracciones de anuncios molestos. </li>
-</ul>
- <h3>Cómo descargar e instalar 9th Dawn RPG Mod APK</h3>
-<p>Para descargar e instalar 9th Dawn RPG Mod APK, debe seguir estos pasos:</p>
-<ol>
-<li>Ir a un sitio web confiable que ofrece 9th Dawn RPG Mod APK para su descarga gratuita. Por ejemplo, puede utilizar este enlace: . </li>
-<li>Haga clic en el botón de descarga y espere a que el archivo se descargue en su dispositivo. </li>
-<li>Una vez descargado el archivo, vaya a la configuración de su dispositivo y habilite la opción de instalar aplicaciones de fuentes desconocidas. Esto le permitirá instalar APK mod que no son de Google Play Store.</li>
-<li>Localice el archivo descargado en su dispositivo y toque en él para iniciar el proceso de instalación. </li>
-<li> Siga las instrucciones en la pantalla y espere a que se complete la instalación. </li>
-<li>Iniciar el juego y disfrutar! </li>
-</ol>
- <h2>Consejos y trucos para jugar 9th Dawn RPG Mod APK</h2>
-<p>Ahora que ha descargado e instalado 9th Dawn RPG Mod APK, usted está listo para comenzar su aventura en Montelorne. Aquí hay algunos consejos y trucos que te ayudarán a aprovechar al máximo tu experiencia de juego:</p>
-<p></p>
- <h3>Explora el mundo de Montelorne</h3>
-
- <h3>Personaliza tu personaje y equipo</h3>
-<p>Otra gran cosa sobre 9th Dawn RPG es su sistema de personalización de personajes que le permite crear su propio héroe único. Puedes elegir entre tres clases: guerrero, mago o arquero, y seleccionar tu género y apariencia. También puedes distribuir tus atributos (fuerza, agilidad, inteligencia) y aprender habilidades y hechizos que se adapten a tu estilo de juego. También puedes recoger y elaborar varios artículos como armas, armaduras, accesorios, consumibles, etc., y equiparlos en tu personaje. Puedes encontrar objetos explorando el mundo, completando misiones, derrotando enemigos, abriendo cofres, etc. También puedes crear objetos usando materiales y recetas que puedas encontrar o comprar. Puede actualizar su equipo utilizando gemas que puede encontrar o comprar. También puede encantar su equipo utilizando pergaminos que puede encontrar o comprar. Puedes personalizar tu personaje y equipo en cualquier momento accediendo al menú. </p>
- <h3>Aprender habilidades y hechizos</h3>
-<p>Las habilidades y los hechizos son habilidades especiales que puedes usar en combate o exploración. Pueden ayudarte a infligir más daño, curarte a ti mismo o a tus aliados, pulirte a ti mismo o a ellos, desbaratar enemigos, escapar del peligro, etc. Puedes aprender habilidades y hechizos nivelando tu personaje, uniéndote a facciones, completando misiones, encontrar libros, etc. También puede mejorar sus habilidades y hechizos mediante el uso de puntos de habilidad que gana por subir de nivel. Puedes acceder a tus habilidades y hechizos tocando los iconos en la esquina inferior derecha de la pantalla. También puede asignarlos a ranuras rápidas para facilitar el acceso. Puedes usar habilidades y hechizos tocando sus iconos o presionando los botones correspondientes en tu dispositivo. Sin embargo, ten en cuenta que las habilidades y los hechizos consumen resistencia o maná, que están indicados por las barras azules y verdes en la esquina superior izquierda de la pantalla. Tienes que esperar a que se regeneren antes de poder usarlas de nuevo. </p>
- <h3>Lucha contra enemigos y jefes</h3>
-
- <h3>Unirse a facciones y misiones</h3>
-<p>Las facciones y las misiones son aspectos opcionales pero gratificantes del RPG de 9th Dawn. Las facciones son grupos de PNJ que tienen sus propias metas, creencias y agendas. Puedes unirte a una de las cuatro facciones en Montelorne: La Orden del León, Los Caballeros de la Sombra, La Sociedad Arcana o La Hermandad. Cada facción tiene su propio líder, cuartel general, miembros, aliados, enemigos y reputación. Puedes aumentar tu reputación con una facción completando misiones, ayudando a miembros, donando artículos, etc. También puedes disminuir tu reputación con una facción atacando miembros, robando artículos, traicionando aliados, etc. Tu reputación con una facción afecta cómo te tratan, qué misiones te ofrecen, qué recompensas te dan, etc. También puedes cambiar de facciones en cualquier momento hablando con el líder de la facción o usando un artículo especial. Sin embargo, ten cuidado al unirte o abandonar facciones, ya que puedes perder algunos beneficios o ganar algunos enemigos. Las misiones son tareas que puedes aceptar y completar desde NPC o facciones. Pueden involucrar varios objetivos como matar enemigos, encontrar objetos, entregar mensajes, escoltar aliados, resolver puzzles, etc. También pueden tener diferentes dificultades, recompensas, límites de tiempo, consecuencias, etc. Puedes encontrar misiones hablando con NPC, visitar ubicaciones, leer avisos, etc. También puede rastrear sus misiones activas accediendo al menú. Puedes completar las misiones cumpliendo los objetivos y regresando al dador de la misión. También puedes fallar misiones ignorando los objetivos, quedándote sin tiempo, matando al dador de misiones, etc. Las misiones pueden ayudarte a ganar experiencia, dinero, objetos, reputación, habilidades, hechizos, etc. También pueden ayudarte a avanzar en la historia o desbloquear nuevas áreas. </p>
- <h2>Conclusión</h2>
-
- <h3>Resumen del artículo</h3>
-<p>En este artículo, hemos cubierto los siguientes temas:</p>
-<ul>
-<li>¿Qué es 9th Dawn RPG? </li>
-<li> ¿Qué es 9th Dawn RPG Mod APK? </li>
-<li>Beneficios de 9th Dawn RPG Mod APK</li>
-<li> Cómo descargar e instalar 9th Dawn RPG Mod APK</li>
-<li> Consejos y trucos para jugar 9th Dawn RPG Mod APK</li>
-</ul>
- <h3>Preguntas frecuentes</h3>
-<p>Aquí hay algunas preguntas frecuentes sobre 9th Dawn RPG Mod APK:</p>
-<ol>
-<li> ¿Es seguro usar 9th Dawn RPG Mod APK? </li>
-<p>9th Dawn RPG Mod APK es generalmente seguro de usar si se descarga desde una fuente de confianza y escanear con software antivirus antes de instalarlo. Sin embargo, debes tener en cuenta que los mod APK no están autorizados por el desarrollador original del juego y pueden contener errores o errores que pueden afectar el rendimiento del juego o del dispositivo. También debe tener cuidado al conceder permisos a los mod APK, ya que pueden acceder a sus datos personales o funciones del dispositivo sin su consentimiento. </p>
-<li>Es 9th Dawn RPG Mod APK compatible con mi dispositivo? </li>
-<p>9th Dawn RPG Mod APK es compatible con la mayoría de los dispositivos Android que tienen sistema operativo Android 4.0 o superior y al menos 1 GB de RAM y 100 MB de espacio de almacenamiento libre. Sin embargo, debe comprobar las especificaciones y requisitos del mod APK antes de descargarlo e instalarlo para asegurarse de que funciona correctamente en su dispositivo. </p>
-<li> ¿Puedo jugar 9th Dawn RPG Mod APK en línea o fuera de línea? </li>
-<p>9th Dawn RPG Mod APK es principalmente un juego fuera de línea que no requiere una conexión a Internet para jugar. Sin embargo, es posible que necesite una conexión a Internet para descargar e instalar el mod APK, para acceder a algunas características en línea, como tablas de clasificación o logros, o para actualizar el mod APK a la última versión. </p>
-<li> ¿Puedo jugar 9th Dawn RPG Mod APK con mis amigos? </li>
-
-<li> ¿Puedo transferir mi progreso de 9th Dawn RPG a 9th Dawn RPG Mod APK o viceversa? </li>
-<p>No, no puede transferir su progreso de 9th Dawn RPG a 9th Dawn RPG Mod APK o viceversa. El mod APK tiene una estructura de archivos diferente y formato de datos que el juego original, y no son compatibles entre sí. Si quieres cambiar entre las dos versiones, tendrás que empezar desde cero. </p>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Android Stalker.md

@@ -1,58 +0,0 @@
-<br />
-<h1>Android acosador: Un término con múltiples significados</h1>
-<p>Cuando escuchas el término acosador androide, ¿qué te viene a la mente? ¿Es una aplicación maliciosa que espía las actividades de tu teléfono? ¿Es una serie de videojuegos que te sumerge en un mundo post-apocalíptico? ¿O es un personaje de televisión que desafía tu percepción de la humanidad? En este artículo, exploraremos estos diferentes significados de stalker android y cómo se relacionan entre sí. </p>
-<h2>android stalker</h2><br /><p><b><b>DOWNLOAD</b> &ndash;&ndash;&ndash; <a href="https://bltlly.com/2v6JLg">https://bltlly.com/2v6JLg</a></b></p><br /><br />
- <h2>Android acosador como un tipo de malware</h2>
-<p>Uno de los significados más comunes y perturbadores de stalker android es un tipo de malware que rastrea o monitorea secretamente la actividad de su dispositivo. Estas aplicaciones también se conocen como stalkerware o spyware, y a menudo son instaladas por alguien que quiere espiarte sin tu consentimiento, como un compañero abusivo, un ex o un hacker. Las aplicaciones de stalkerware pueden acceder a tu ubicación, conversaciones, fotos, contraseñas y más, y enviarlas a un tercero. También pueden encender el micrófono o la cámara de forma remota para ver y escuchar lo que está sucediendo a su alrededor. </p>
-<p>Las aplicaciones de stalkerware representan serias amenazas para su privacidad, seguridad y seguridad. Pueden exponer su información personal al robo de identidad, chantaje, acoso o violencia. También pueden comprometer el rendimiento de su dispositivo, la duración de la batería y el uso de datos. Además, pueden violar su confianza y dignidad como ser humano. </p>
-<p>¿Cómo se puede saber si hay una aplicación stalkerware en su dispositivo Android? Según los expertos en seguridad, algunos signos que pueden indicar stalkerware incluyen:</p>
-<ul>
-<li>El abusador ha tenido acceso físico a su dispositivo</li>
-<li>El abusador sabe mucha información específica sobre usted que no debería</li>
-<li>La batería del dispositivo se agota más rápido de lo habitual</li>
-<li> Hay un aumento inexplicable en el uso de datos</li>
-<li>Hay cambios inesperados en la configuración del dispositivo</li>
-</ul>
-<p>Si sospecha que hay una aplicación stalkerware en su dispositivo, aquí hay algunos pasos que puede tomar:</p>
-<ul>
-
-<li>Compruebe si su dispositivo ha sido "arraigado" o "jailbreak". Esto significa que alguien ha ganado el control total sobre el sistema operativo de su dispositivo. Puedes usar aplicaciones como Root Checker o Certo para analizar tu dispositivo en busca de rooteo o jailbreak. </li>
-<li>Escanea tu dispositivo con software antivirus o anti-malware. Algunas aplicaciones como MalwareBytes, NortonLifeLock o Lookout pueden detectar stalkerware y eliminarlo. </li>
-<li>Cambia tus contraseñas para todas tus cuentas. Usa contraseñas fuertes y únicas que sean difíciles de adivinar. </li>
-<li>Restablecimiento de fábrica del dispositivo. Esto borrará todos los datos y aplicaciones de su dispositivo y lo restaurará a su configuración original. Asegúrese de hacer una copia de seguridad de sus datos importantes antes de hacer esto. </li>
-</ul>
- <h2>Stalker Android como una serie de videojuegos</h2>
-<p>Otro significado de stalker android es una serie de videojuegos que te sumerge en un mundo post-apocalíptico. La serie se llama S.T.A.L.K.E.R., que significa carroñeros, intrusos, aventureros, solitarios, asesinos, exploradores y ladrones. Estos son los nombres de las personas que se aventuran en la Zona, un área alrededor de la Central Nuclear de Chernobyl que ha sido afectada por un segundo desastre nuclear en 2006. La Zona está llena de peligros, como criaturas mutadas, facciones hostiles y fenómenos anómalos. Sin embargo, también ofrece oportunidades, como valiosos artefactos, secretos y misterios. </p>
-<p></p>
-<p>La serie S.T.A.L.K.E.R. consta de tres juegos principales: Shadow of Chernobyl (2007), Clear Sky (2008) y Call of Pripyat (2009). Cada juego tiene un protagonista y una historia diferentes, pero todos comparten el mismo escenario y elementos de juego. Algunas de las principales características y temas de los juegos son:</p>
-<ul>
-<li>Exploración: Los juegos te permiten deambular libremente en el mundo abierto de la Zona, descubriendo nuevos lugares, misiones, personajes y eventos. También puede interactuar con el entorno, como recoger objetos, usar vehículos o activar trampas. </li>
-
-<li>Anomalías: Los juegos presentan anomalías, que son fenómenos extraños y a menudo mortales que desafían las leyes de la física. Las anomalías pueden tener diferentes efectos, como quemarlo, electrocutarlo o teletransportarlo. Puede usar detectores o pernos para localizarlo y evitarlo. </li>
-<li>Facciones: Los juegos cuentan con facciones, que son grupos de acosadores con diferentes objetivos e ideologías. Las facciones pueden ser amistosas, neutrales u hostiles para usted dependiendo de sus acciones y reputación. Puedes unirte o aliarte con algunas facciones, o luchar contra ellas. </li>
-</ul>
-<p>La serie S.T.A.L.K.E.R. ha sido elogiada por su juego atmosférico e inmersivo, su sistema de IA realista y dinámico, su construcción del mundo rica y detallada, y su narración no lineal y emergente. Sin embargo, también se ha enfrentado a algunos desafíos y controversias, como errores y problemas técnicos, disputas legales sobre los derechos de propiedad intelectual, problemas de censura en algunos países y la insatisfacción de los fans con algunos aspectos de los juegos. A pesar de estas dificultades, la serie ha ganado una base de seguidores leales y de culto a lo largo de los años. </p>
- <h2>Stalker Android como un personaje de programa de televisión</h2>
-<p>El tercer significado de Android acosador es un personaje de programa de televisión que desafía su percepción de la humanidad. El personaje es Dorian, un compañero androide de un policía humano en Almost Human, un drama de ciencia ficción que se emitió en 2013-2014. El espectáculo se desarrolla en 2048, donde el crimen ha aumentado en un 400% y cada oficial de policía humano se empareja con un socio androide. El espectáculo sigue los casos y aventuras de John Kennex (Karl Urban), un detective que perdió su pierna y su memoria en una redada que salió mal, y Dorian (Michael Ealy), un modelo androide que fue dado de baja por ser demasiado emocional e impredecible. </p>
-
-<p>La premisa y la trama de Almost Human son similares a otras obras de ciencia ficción que exploran la relación entre humanos y androides, como Blade Runner, I, Robot o Detroit: Become Human. Sin embargo, el programa también agrega sus propios giros e innovaciones, como dispositivos, crímenes y tecnologías futuristas. Por ejemplo, el show presenta casos que involucran sexbots, manipulación de memoria, ingeniería genética e inteligencia artificial. </p>
-<p>El personaje de Dorian es uno de los aspectos más interesantes y atractivos de la serie. Es un androide que tiene un alma sintética, que le da una personalidad, un sentido del humor y una brújula moral. También es leal, compasivo y curioso sobre las emociones y experiencias humanas. A menudo actúa como una lámina y un amigo de Kennex, que es cínico, traumatizado y desconfiado de los androides. Juntos, forman una alianza improbable pero efectiva que desafía los estereotipos y prejuicios de su sociedad. </p>
-<p>Almost Human recibió críticas en su mayoría positivas de críticos y audiencias  , que elogiaron su elenco, sus imágenes, su acción y su humor. Sin embargo, el programa también enfrentó algunos problemas, como bajas calificaciones, problemas de programación, emitir episodios fuera de orden y cancelación después de una temporada. Muchos fans se sintieron decepcionados por el abrupto final del programa y las preguntas sin resolver. Sin embargo, el programa todavía tiene un seguimiento de culto y un potencial para el renacimiento o reinicio. </p>
- <h2>Conclusión</h2>
-<p>En este artículo, hemos explorado tres significados diferentes de stalker android: un tipo de malware que espía la actividad de tu dispositivo, una serie de videojuegos que te sumerge en un mundo post-apocalíptico y un personaje de televisión que desafía tu percepción de la humanidad. Hemos visto cómo cada significado se relaciona con diferentes aspectos de la tecnología, la sociedad y la cultura. También hemos aprendido algunos hechos, consejos y opiniones sobre cada significado. </p>
-
- <h3>Preguntas frecuentes</h3>
-<ul>
-<li><b>¿Qué es stalkerware? </b></li>
-<li>Stalkerware es un tipo de malware que secretamente rastrea o monitorea la actividad de su dispositivo sin su consentimiento. Puede acceder a su ubicación, conversaciones, fotos, contraseñas y más. </li>
-<li><b>¿Qué es S.T.A.L.K.E.R.? </b></li>
-<li>S.T.A.L.K.E.R. es una serie de videojuegos que te sumerge en un mundo post-apocalíptico alrededor de la central nuclear de Chernobyl. Juegas como un acosador que explora la Zona, un área llena de peligros y oportunidades. </li>
-<li><b>¿Qué es casi humano? </b></li>
-<li>Almost Human es un drama de ciencia ficción que se emitió en 2013-2014. Se desarrolla en 2048, donde cada policía humano se empareja con un socio androide. Sigue los casos y aventuras de John Kennex y Dorian, un dúo improbable pero efectivo. </li>
-<li><b>¿Cómo puedo eliminar stalkerware de mi dispositivo Android? </b></li>
-<li>Puede eliminar stalkerware escaneando su dispositivo con software antivirus o antimalware, cambiando sus contraseñas para todas sus cuentas o restableciendo su dispositivo de fábrica. </li>
-<li><b>¿Cómo puedo jugar juegos de S.T.A.L.K.E.R. ? </b></li>
-<li>Puedes jugar juegos de S.T.A.L.K.E.R. en PC o Xbox 360. También puedes descargar mods o versiones hechas por fans de los juegos para más características y contenido. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Apk De La Saga Del Verano.md

@@ -1,59 +0,0 @@
-<br />
-<h1>Descargar Imperio Mundial 2027 APK y llevar a su país a la gloria</h1>
-<p>¿Tienes lo que se necesita para ser un líder supremo en un mundo de caos? ¿Quieres experimentar un juego de estrategia por turnos realista e inmersivo que te permite elegir entre más de 180 países y llevarlos a la victoria o la derrota? Si es así, entonces usted debe descargar Imperio Mundial 2027 APK, un juego que desafiará sus habilidades de liderazgo y el pensamiento estratégico. </p>
-<p>World Empire 2027 es un juego desarrollado por iGindis Games, una empresa que se especializa en crear juegos que simulan escenarios y eventos del mundo real. El juego se desarrolla en el año 2027, donde el mundo está en crisis debido al colapso económico, la inestabilidad política, el malestar social y los desastres ambientales. Ustedes son el líder de uno de los países, y tienen que tomar decisiones que afectarán a su nación y al mundo. Puedes usar la diplomacia, la guerra, la tecnología, la economía y el espionaje para construir tu imperio y competir con otros jugadores en línea o localmente en modo multijugador. </p>
-<h2>apk de la saga del verano</h2><br /><p><b><b>Download</b> &#10003;&#10003;&#10003; <a href="https://bltlly.com/2v6Lw7">https://bltlly.com/2v6Lw7</a></b></p><br /><br />
-<p>En este artículo, le mostraremos cómo descargar World Empire 2027 APK en sus dispositivos Android y PC con Windows, y también destacaremos algunas de las características y consejos del juego. Así que, sin más preámbulos, ¡empecemos! </p>
-<h2> Cómo descargar Imperio Mundial 2027 APK en dispositivos Android</h2>
-<p>Si desea descargar World Empire 2027 APK en sus dispositivos Android, puede seguir estos sencillos pasos:</p>
-<ol>
-<li>Ir al sitio web oficial de World Empire 2027 en <a href="">https://www.igindis.com/</a> o Uptodown en <a href=">https://world-empire-2027.en.uptodown.com/android</a> y encontrar el botón de descarga para el juego. </li>
-<li>Haga clic en el botón de descarga y espere a que el archivo APK se descargue en su dispositivo. El tamaño del archivo es de unos 70 MB, así que asegúrese de tener suficiente espacio y una buena conexión a Internet. </li>
-
-<li>Busque el archivo APK en su dispositivo y toque en él para instalarlo. Siga las instrucciones en la pantalla y acepte los permisos requeridos por el juego. </li>
-<li>Después de la instalación se hace, puede iniciar el juego y disfrutar de jugar Imperio Mundial 2027 APK en sus dispositivos Android. </li>
-</ol>
-<h2> Cómo descargar Imperio Mundial 2027 APK en Windows PC</h2>
-<p>Si desea descargar World Empire 2027 APK en su PC con Windows, necesitará un emulador de Android que puede ejecutar aplicaciones Android en su PC. Hay muchos emuladores disponibles en línea, pero recomendamos usar BlueStacks o NoxPlayer, ya que son fáciles de usar y compatibles con la mayoría de los juegos. Aquí están los pasos para descargar World Empire 2027 APK en su PC con Windows utilizando un emulador:</p>
-<ol>
-<li>Descargue un emulador de Android como BlueStacks o NoxPlayer desde sus sitios web oficiales en <a href=">https://www.bluestacks.com/</a> o <a href="">https:/www.bignox.com/<//a>, respectivamente. </li>
-<li>Instalar el emulador y lanzarlo en su PC. Es posible que tenga que iniciar sesión con su cuenta de Google para acceder a la Google Play Store.</li>
-<li>Ir a la Google Play Store o Uptodown y buscar World Empire 2027. También puede utilizar los enlaces proporcionados anteriormente para los dispositivos Android. </li>
-<li>Haga clic en el botón de instalación y espere a que el juego se instale en su emulador. El proceso de instalación puede tardar algún tiempo dependiendo de las especificaciones de su PC y la velocidad de Internet. </li>
-<li>Después de la instalación se hace, puede iniciar el juego desde su emulador y disfrutar de jugar World Empire 2027 APK en su PC con Windows.</li>
-</ol>
-<h2>Características de Imperio Mundial 2027 APK</h2>
-<p>Imperio Mundial 2027 APK es un juego que ofrece muchas características que lo hacen divertido y atractivo. Estas son algunas de las características que puedes esperar del juego:</p>
-<ul>
-
-Utiliza la diplomacia, la guerra, la tecnología, la economía y el espionaje para construir tu imperio. </strong> Puedes interactuar con otros países de diferentes maneras, como formar alianzas, declarar la guerra, enviar ayuda, imponer sanciones, etc. También puedes usar tu red de espionaje para recopilar información o sabotear a tus enemigos. Puede investigar nuevas tecnologías que le darán una ventaja en la guerra o la economía. Puedes administrar tu presupuesto y recursos sabiamente e invertir en diferentes sectores como educación, salud, infraestructura, etc.</li>
-<li><strong>Compite con otros jugadores online o localmente en modo multijugador. </strong> Puedes jugar Imperio Mundial 2027 APK con otros jugadores de todo el mundo o con tus amigos localmente en el modo multijugador. Puedes unirte o crear una sala con hasta 8 jugadores y elegir diferentes configuraciones como el tamaño del mapa, nivel de dificultad, tiempo de turno, etc. Puedes chatear con otros jugadores y cooperar o competir con ellos. También puede jugar contra la IA en el modo para un jugador si lo prefiere. </li>
-</ul>
-<h2> Consejos y trucos para jugar World Empire 2027 APK</h2>
-<p>Imperio Mundial 2027 APK es un juego que requiere estrategia y planificación para tener éxito. Aquí hay algunos consejos y trucos que pueden ayudarle a mejorar su juego y ganar más guerras:</p>
-<ul>
-<li><strong>Esté atento a las noticias y eventos mundiales que afectan a su país y sus relaciones. </strong> El juego presenta una simulación realista de la situación mundial y los eventos que pueden cambiar el curso de la historia. Usted recibirá actualizaciones de noticias y alertas que le informarán de los asuntos actuales y los problemas que están sucediendo en todo el mundo. También verá cómo otros países reaccionan a estos eventos y cómo afectan sus relaciones con ellos. Debe prestar atención a estas noticias y eventos y ajustar su estrategia en consecuencia. </li>
-
-<li><strong>Forma alianzas con otros países y usa a tus espías para reunir información o sabotear a tus enemigos. </strong> La diplomacia es otro aspecto clave del juego que puede ayudarte a alcanzar tus objetivos o a prevenir conflictos. Usted puede formar alianzas con otros países que comparten sus intereses o ideología, y cooperar con ellos de varias maneras como el comercio, la ayuda, el apoyo militar, etc. También puede utilizar sus espías para recopilar información sobre los planes de otros países, fortalezas, debilidades, etc., o para sabotear su economía, militar, tecnología, etc. Sin embargo, debe tener cuidado de no quedar atrapado por su contrainteligencia, ya que esto puede dañar su reputación y relaciones. </li>
-</ul>
-<h2>Conclusión</h2>
-<p>Imperio Mundial 2027 APK es un juego emocionante y desafiante que le permite llevar a su país en un escenario futurista donde el mundo está en caos. Puedes elegir entre 180 países y usar la diplomacia, la guerra, la tecnología, la economía y el espionaje para construir tu imperio y competir con otros jugadores en línea o localmente en el modo multijugador. El juego presenta una simulación realista de la situación mundial y los eventos que pueden cambiar el curso de la historia. El juego también ofrece muchas características que lo hacen divertido y atractivo, como personalización, investigación, noticias, chat, etc.</p>
-<p>Si usted es un fan de los juegos de guerra de estrategia o quiere poner a prueba sus habilidades de liderazgo y el pensamiento estratégico, usted debe descargar Imperio Mundial 2027 APK en sus dispositivos Android o PC con Windows. El juego es gratis para descargar y jugar, pero contiene compras en la aplicación que pueden mejorar su experiencia de juego. Puedes descargar el juego desde el sitio web oficial o Uptodown, o desde la Google Play Store si tienes un emulador en tu PC.</p>
-<p>Entonces, ¿qué estás esperando? Descargar World Empire 2027 APK hoy y llevar a su país a la gloria! </p>
-<p></p>
-<h3>Preguntas frecuentes</h3>
-<p>Aquí están algunas de las preguntas más frecuentes sobre World Empire 2027 APK:</p>
-<ol>
-
-<li><p>Sí, Imperio Mundial 2027 APK es gratis para descargar y jugar, pero contiene compras en la aplicación que pueden mejorar su experiencia de juego. </p></li>
-<li><strong>¿Cómo puedo actualizar World Empire 2027 APK? </strong></li>
-<li><p>Puede actualizar Imperio Mundial 2027 APK visitando el sitio web oficial o Uptodown y descargar la última versión del juego. Alternativamente, puedes actualizar el juego desde Google Play Store si lo has instalado desde allí. </p></li>
-<li><strong>¿Cuáles son los requisitos del sistema para el Imperio Mundial 2027 APK? </strong></li>
-<li><p>Imperio Mundial 2027 APK requiere versión de Android 4.4 o superior para dispositivos Android, y Windows XP o superior para PC con Windows. El juego también requiere al menos 2 GB de RAM y una conexión a Internet estable. </p></li>
-<li><strong>¿Puedo jugar World Empire 2027 APK offline? </strong></li>
-<li><p>No, Imperio Mundial 2027 APK requiere una conexión a Internet para jugar, ya que es un juego multijugador que implica datos y eventos en tiempo real. Sin embargo, puedes jugar el juego en modo de un solo jugador contra la IA si lo deseas. </p></li>
-<li><strong>¿Cómo puedo contactar a los desarrolladores de World Empire 202 7 APK? </strong></li>
-<li><p>Puede ponerse en contacto con los desarrolladores de World Empire 2027 APK enviando un correo electrónico a [email protected] o visitando su sitio web en https://www.igindis.com/ También puede seguirlos en Facebook, Twitter, Instagram, YouTube y Discord para actualizaciones y noticias. </p></li>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Cuerda Hroe Vice Ciudad 6.5 Descarga.md

@@ -1,71 +0,0 @@
-<br />
-<h1>Guerra relámpago de World of Warships Descargar: Cómo disfrutar del combate naval en su dispositivo móvil</h1>
-<p>¿Te gusta la guerra naval y la historia? ¿Quieres experimentar la emoción de comandar un buque de guerra en batallas épicas? ¿Quieres jugar un juego divertido y atractivo en tu dispositivo móvil? Si respondiste sí a cualquiera de estas preguntas, entonces deberías probar <strong>World of Warships Blitz War</strong>, un juego de acción gratuito que lleva el combate naval de la Segunda Guerra Mundial a dispositivos móviles y tabletas. </p>
-<h2>cuerda héroe vice ciudad 6.5 descarga</h2><br /><p><b><b>Download</b> === <a href="https://bltlly.com/2v6Klk">https://bltlly.com/2v6Klk</a></b></p><br /><br />
-<h2>¿Qué es la guerra relámpago de World of Warships? </h2>
-<h3>Un juego de acción gratuito que trae el combate naval de la Segunda Guerra Mundial a móviles y tabletas</h3>
-<p>World of Warships Blitz War es un juego desarrollado por Wargaming, la misma compañía detrás de los populares juegos de World of Tanks y World of Warplanes. Se basa en la galardonada versión para PC multijugador en línea de World of Warships, pero optimizada para dispositivos móviles. Le permite controlar buques de guerra realistas e históricamente precisos de diferentes naciones y épocas, como Japón, EE.UU., URSS, Reino Unido, Alemania, Italia, Francia y más. Puedes luchar en juegos multijugador online y offline y batallas navales contra otros jugadores o enemigos de IA. </p>
-<h3>Cuenta con más de 130 buques de guerra icónicos de diferentes naciones y épocas</h3>
-<p>World of Warships Blitz War presenta una colección inigualable de barcos históricos auténticos junto con máquinas navales de fantasía, ciencia ficción y ficción. Puede elegir entre cuatro clases de buques de guerra: acorazados, cruceros, destructores y portaaviones. Cada clase tiene sus propias características, ventajas y desventajas. Por ejemplo, los acorazados son potentes y duraderos, pero lentos y vulnerables a los torpedos. Los cruceros son versátiles y ágiles, pero tienen una armadura más débil. Los destructores son rápidos y sigilosos, pero tienen baja salud. Los portaaviones son unidades de apoyo que pueden lanzar aviones para explorar, atacar o defender. </p>
-<h3>Ofrece batallas épicas 7v7 rápidas y llenas de acción y jugabilidad estratégica</h3>
-
-<h2>¿Cómo descargar e instalar World of Warships Blitz War? </h2>
-<h3>Disponible para dispositivos iOS y Android</h3>
-<p>World of Warships Blitz War está disponible para iOS y Android <h3>Disponible para dispositivos iOS y Android</h3>
-<p>World of Warships Blitz War está disponible para dispositivos iOS y Android, para que puedas disfrutar del combate naval en tu smartphone o tablet. El juego es gratis para descargar y jugar, pero puede contener compras en la aplicación para algunos artículos y características premium. Puedes descargar el juego desde la App Store o Google Play Store, dependiendo de tu dispositivo. </p>
-<h3>Requiere al menos 3 GB de espacio libre y una conexión a Internet estable</h3>
-<p>Antes de descargar e instalar World of Warships Blitz War, asegúrese de tener suficiente espacio libre en su dispositivo. El juego requiere al menos 3 GB de espacio libre para funcionar sin problemas, y también puede descargar datos adicionales durante el proceso de instalación. También necesitas una conexión a Internet estable para jugar online, ya que es un juego multijugador que te conecta con otros jugadores de todo el mundo. </p>
-<h3>Pasos para descargar e instalar el juego desde las fuentes oficiales</h3>
-<p>Para descargar e instalar World of Warships Blitz War desde las fuentes oficiales, sigue estos sencillos pasos:</p>
-<p></p>
-<ol>
-<li>Ir a la App Store o Google Play Store en su dispositivo y buscar World of Warships guerra relámpago.</li>
-<li>Toca el icono del juego y luego toca el botón Instalar u Obtener para comenzar a descargar el juego. </li>
-<li>Espera a que termine la descarga y luego toca el botón Abrir o Jugar para iniciar el juego. </li>
-<li>Siga las instrucciones en pantalla para crear su cuenta, elija su servidor y complete el tutorial. </li>
-<li>¡Disfruta del juego! </li>
-</ol>
-<h2>¿Cómo se juega guerra relámpago del mundo de los buques de guerra? </h2>
-<h3>Elija su buque de guerra preferido de cuatro clases: acorazados, cruceros, destructores y portaaviones</h3>
-
-<ul>
-<li>Acorazados: Estos son los buques de guerra más pesados y poderosos del juego. Tienen una armadura gruesa, armas grandes y alta salud. Pueden infligir daño masivo a las naves enemigas con su batería principal y armas secundarias. Sin embargo, también son lentos, torpes y vulnerables a los torpedos y aviones. Son más adecuados para el combate de largo alcance y el daño de tanque para su equipo. </li>
-<li>Cruceros: Estos son los buques de guerra más versátiles y ágiles del juego. Tienen armaduras medianas, cañones de disparo rápido y buena velocidad. Pueden realizar varios papeles en la batalla, como exploración, apoyo, flanqueo o caza. También pueden usar consumibles especiales, como sonar, radar, pantalla de humo o búsqueda hidroacústica. Sin embargo, tienen menos salud que los acorazados y pueden ser fácilmente penetrados por sus proyectiles. Son más adecuados para el combate de medio alcance y la adaptación a diferentes situaciones. </li>
-<li>Destructores: Estos son los buques de guerra más pequeños y rápidos en el juego. Tienen armadura delgada, armas de fuego rápido y alto sigilo. Pueden lanzar torpedos contra naves enemigas desde una distancia segura o emboscarlos desde detrás de islas o pantallas de humo. También pueden capturar bases más rápido que otras clases. Sin embargo, tienen una salud muy baja y pueden ser destruidos por algunos impactos de cualquier nave. Son los más adecuados para combatir a corta distancia y acosar a los enemigos. </li>
-<li>Portaaviones: Estas son las unidades de apoyo del juego. Tienen armadura débil, sin armas y baja velocidad. Pueden lanzar aviones desde su cubierta para explorar, atacar o defender a sus aliados o enemigos. Pueden controlar hasta tres escuadrones de aviones a la vez: cazas, bombarderos en picada o bombarderos torpederos. Sin embargo, tienen una maniobrabilidad muy limitada y son altamente dependientes de sus aviones. Son los más adecuados para el combate de largo alcance y proporcionar apoyo aéreo. </li>
-</ul>
-<h3>Personaliza tu nave de guerra con varios módulos, mejoras y camuflajes</h3>
-
-<p>Una vez que haya elegido su clase de buque de guerra y nación, puede personalizarlo con varios módulos, actualizaciones y camuflajes. Los módulos son partes de tu nave de guerra que afectan su rendimiento, como el casco, el motor, las armas, los torpedos, los aviones, etc. Puedes investigar y comprar nuevos módulos con la experiencia y los créditos obtenidos de las batallas. Las mejoras son mejoras que mejoran los atributos de tu nave de guerra, como la supervivencia, potencia de fuego, maniobrabilidad, ocultación, etc. Puedes comprar e instalar hasta seis mejoras por buque de guerra con créditos. Los camuflajes son artículos cosméticos que cambian la apariencia de su nave de guerra y también proporcionan algunas bonificaciones, como un rango de detección reducido o una mayor ganancia de experiencia. Puedes comprar camuflajes permanentes o temporales con créditos o oro. </p>
-<h3>Únete a una batalla y controla tu nave de guerra usando simples controles táctiles</h3>
-<p>Cuando estés listo para unirte a una batalla, puedes tocar el botón Batalla en el menú principal y elegir un modo. Serás emparejado con otros jugadores de habilidad y nivel similar. El juego cargará el mapa y los equipos. Verá su nave de guerra en la vista de puerto, donde puede verificar sus consumibles, señales y chatear con sus compañeros de equipo. Para iniciar la batalla, toca el botón Listo. </p>
-<p>Una vez que comience la batalla, verás tu nave de guerra en la vista 3D, donde puedes controlarla usando simples controles táctiles. Puede utilizar el joystick virtual de la izquierda para dirigir su nave de guerra y ajustar su velocidad. Puede usar los botones de la derecha para disparar sus armas principales, lanzar torpedos o aviones. También puede utilizar los botones de la parte inferior para cambiar entre diferentes vistas, acercar o alejar, activar consumibles o acceder al mini-mapa. También puedes deslizar la pantalla para mirar alrededor y apuntar a tus enemigos. </p>
-<h3>Cooperar con sus aliados, detectar a sus enemigos, y utilizar sus armas y habilidades para ganar la batalla</h3>
-
-<p>Para ganar la batalla, tienes que cooperar con tus aliados, detectar a tus enemigos y usar tus armas y habilidades de manera efectiva. Tienes que comunicarte con tu equipo usando el chat o comandos rápidos. Tienes que buscar naves enemigas usando tu vista, radar, sonar o aviones. Tienes que apuntar a los puntos débiles de tus enemigos y esquivar su fuego. Tienes que usar tus consumibles en el momento y situación adecuados. Tienes que adaptarte a la marea cambiante de la batalla y tomar decisiones inteligentes. </p>
-<h2>¿Cómo mejorar tus habilidades y progreso en la guerra relámpago de World of Warships? </h2>
-<h3>Conozca las fortalezas y debilidades de cada clase de buque de guerra y nación</h3>
-<p>Para mejorar tus habilidades y progreso en World of Warships Blitz War, tienes que aprender las fortalezas y debilidades de cada clase de buque de guerra y nación. Tienes que saber qué papel juega cada clase en la batalla y cómo contrarrestarlos. Tienes que saber qué nación tiene qué ventajas y desventajas en términos de potencia de fuego, armadura, velocidad, sigilo, etc. Tienes que saber qué módulos, <h3>Aprende las fortalezas y debilidades de cada clase de buque de guerra y nación</h3>
-<p>Para mejorar tus habilidades y progreso en World of Warships Blitz War, tienes que aprender las fortalezas y debilidades de cada clase de buque de guerra y nación. Tienes que saber qué papel juega cada clase en la batalla y cómo contrarrestarlos. Tienes que saber qué nación tiene qué ventajas y desventajas en términos de potencia de fuego, armadura, velocidad, sigilo, etc. Tienes que saber qué módulos, mejoras y camuflajes se adaptan mejor a cada nave de guerra. Puedes encontrar información y consejos útiles en el sitio web oficial del juego, wiki, foros o canales de YouTube. </p>
-<h3>Estudia los mapas y usa el terreno a tu favor</h3>
-
-<h3>Completa misiones, desafíos y eventos para ganar recompensas y desbloquear nuevos buques de guerra</h3>
-<p>Una tercera manera de mejorar tus habilidades y progreso en World of Warships Blitz War es completar misiones, desafíos y eventos para ganar recompensas y desbloquear nuevos buques de guerra. Puedes acceder a varias misiones y desafíos desde el menú principal, como misiones diarias, misiones semanales, misiones de campaña, etc. También puedes participar en varios eventos que ofrecen recompensas especiales, como eventos estacionales, históricos o batallas especiales. Al completar estas tareas, puede ganar experiencia, créditos, oro, contenedores, planos, fichas, etc. que puede utilizar para investigar y comprar nuevos buques de guerra u otros artículos. </p>
-<h3>Únete a una flota o crea la tuya propia para chatear, jugar y competir con otros jugadores</h3>
-<p>Una cuarta forma de mejorar tus habilidades y progreso en World of Warships Blitz War es unirte a una flota o crear la tuya propia para chatear, jugar y competir con otros jugadores. Una flota es un grupo de jugadores que comparten un nombre común, etiqueta, logotipo y canal de chat. Puedes unirte a una flota existente o crear la tuya invitando a tus amigos u otros jugadores. Al estar en una flota, puedes chatear con otros miembros, jugar juntos en divisiones o batallas de clanes, intercambiar regalos o recursos, ganar puntos de flota y recompensas, etc. También puedes competir con otras flotas en la clasificación de la flota o torneos. </p>
-<h2>Conclusión</h2>
-
-<p>Si quieres disfrutar del combate naval en tu dispositivo móvil, deberías descargar e instalar World of Warships Blitz War hoy. Puedes encontrar el juego en la App Store o Google Play Store, o visitar el sitio web oficial para obtener más información. También puede seguir el juego en las redes sociales o unirse a los foros de la comunidad para mantenerse actualizado e interactuar con otros jugadores. World of Warships Blitz War es un juego que te mantendrá enganchado durante horas y te hará sentir como un verdadero comandante naval. </p>
-<h2>Preguntas frecuentes</h2>
-<h3>P: ¿Cómo puedo obtener más oro en Guerra Blitz de World of Warships? </h3>
-<p>A: El oro es la moneda premium en World of Warships Blitz War que se puede usar para comprar artículos y funciones premium, como barcos premium, cuentas premium, contenedores, etc. Puedes obtener más oro completando ciertas misiones o desafíos, participando en eventos especiales u ofertas, ver anuncios o comprarlos con dinero real. </p>
-<h3>P: ¿Cómo puedo obtener más planos en Guerra Blitz de World of Warships? </h3>
-<p>A: Los planos son artículos especiales que se pueden usar para investigar nuevas naves de guerra o actualizar las existentes. Puedes obtener más planos abriendo contenedores, completando misiones o desafíos, participando en eventos especiales u ofertas, o comprándolos con oro. </p>
-<h3>P: ¿Cómo puedo cambiar mi servidor en World of Warships Blitz War? </h3>
-<p>A: Puedes cambiar tu servidor en World of Warships Blitz War pulsando en el icono de configuración del menú principal y luego pulsando en la opción de servidor. Puede elegir entre cuatro servidores: Norteamérica, Europa, Asia o CIS. Sin embargo, cambiar tu servidor restablecerá tu progreso y tendrás que empezar desde cero. </p>
-<h3>P: ¿Cómo puedo reportar un error o un problema en Guerra Blitz de World of Warships? </h3>
-
-<h3>P: ¿Cómo puedo unirme a una flota o crear la mía propia en World of Warships Blitz War? </h3>
-<p>A: Puedes unirte a una flota o crear la tuya propia en World of Warships Blitz War tocando el icono de la flota en el menú principal y luego tocando la opción de búsqueda o crear. A continuación, puede navegar a través de flotas existentes o crear su propia mediante el establecimiento de un nombre, etiqueta, logotipo, descripción, etc. También puede invitar a sus amigos u otros jugadores a unirse a su flota. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar El Certificado Del Consejo De Abogados De La India.md

@@ -1,111 +0,0 @@
-
-<h1>¿Cómo descargar el certificado del Colegio de Abogados de la India? </h1>
-<p></p>
-<h2>descargar el certificado del consejo de abogados de la India</h2><br /><p><b><b>Download</b> &#9734; <a href="https://bltlly.com/2v6JCt">https://bltlly.com/2v6JCt</a></b></p><br /><br />
-<ul>
-<li> ¿Cuál es el propósito y los beneficios del certificado? </li>
-<li> ¿Cuáles son los criterios de elegibilidad y los pasos para solicitar el certificado? </li>
-<li> ¿Cómo descargar el certificado desde el sitio web o la aplicación del BCI? </li>
-<li> ¿Cuáles son algunos problemas y soluciones comunes para el certificado? </li>
-<li> ¿Cómo renovar y verificar el certificado? </li>
-</ul>
-<p>Espero que encuentre este artículo útil e informativo. ¡Comencemos! </p>
- <h2>Propósito y beneficios del certificado</h2>
-<p>El propósito principal de emitir un certificado de práctica a los defensores es:</p>
-<ul>
-<li>Asegúrese de que los defensores no practicantes o defensores que se trasladan a otra profesión o negocio se desplazan a la lista de defensores no practicantes. </li>
-<li>Obtener el control de los Consejos de Abogados del Estado, así como otros órganos elegidos en virtud de la Ley de Defensores.</li>
-<li>Tener comunicación directa y contacto con defensores practicantes. </li>
-<li>Asegúrese de que todos los candidatos que se han inscrito después de 2010 aparecen en All India Bar Examination (AIBE) y lo pasan. </li>
-<li>Asegúrese de que todos los beneficios ofrecidos a los defensores son disfrutados solo por los defensores practicantes. </li>
-</ul>
-<p>Algunos de los beneficios de tener un certificado de práctica son:</p>
-<ul>
-<li>Permite a un abogado ejercer la abogacía en cualquier tribunal o autoridad en la India.</li>
-<li>Mejora la credibilidad y reputación de un defensor entre clientes, compañeros y jueces. </li>
-<li>Da derecho a un defensor a varios planes de bienestar, planes de seguro, fondos de pensiones, etc., proporcionados por el ICB o los Consejos de Abogados del Estado.</li>
-<li>Ayuda a un defensor a mantenerse actualizado con desarrollos legales, reglas, regulaciones, juicios, etc., a través de boletines del ICB, revistas, seminarios, talleres, etc.</li>
-<li>Permite a un defensor participar en las elecciones del ICB, comités, subcomités, etc., y contribuir a la formulación de políticas y la gobernanza de la profesión jurídica. </li>
-</ul>
-
-<p>Los criterios de elegibilidad para solicitar un certificado de práctica son:</p>
-<p></p>
-<ul>
-<li>El solicitante debe ser ciudadano de la India.</li>
-<li>El solicitante debe tener un título de abogado (3 años/5 años) de un instituto de derecho reconocido aprobado por el BCI.</li>
-<li>El solicitante debe estar inscrito en cualquier Consejo de Abogados del Estado como defensor. </li>
-<li>El solicitante debe haber superado el AIBE realizado por el BCI dentro de los dos años de inscripción. </li>
-<li>El solicitante debe pagar una cuota de inscripción de Rs. 600/- al BCI junto con el formulario de solicitud y otros documentos. </li>
-</ul>
-<p>Los pasos para solicitar un certificado de práctica son:</p>
-<ol>
-<li>Descargue el formulario de solicitud desde el sitio web del BCI o consígalo en la oficina del Consejo de Abogados del Estado. </li>
-<li>Rellene los detalles como nombre, dirección, número de inscripción, fecha de inscripción, número de rollo AIBE, fecha de pasar AIBE, etc.</li>
-<li>Adjuntar los siguientes documentos con el formulario de solicitud: <ul>
-<li>Una copia del certificado de inscripción emitido por el Consejo de Abogados del Estado.</li>
-<li>Una copia del certificado de pase AIBE emitido por BCI.</li>
-<li>Una copia del certificado de grado de derecho o certificado provisional. </li>
-<li>Una copia de prueba de identidad como tarjeta Aadhaar, tarjeta PAN, tarjeta de identificación del votante, etc.</li>
-<li>Dos fotografías tamaño pasaporte. </li>
-<li>Un proyecto de demanda de Rs. 600/- a favor del Colegio de Abogados de la India pagadero en Nueva Delhi.</li>
-</ul>
-</li>
-<li>Envíe el formulario de solicitud junto con los documentos y la cuota a la oficina del Consejo de Abogados del Estado o enviarlo por correo a la oficina del BCI en Nueva Delhi.</li>
-<li>Espere a que el BCI verifique y apruebe la solicitud. El procesamiento puede tardar hasta 30 días. </li>
-<li>Una vez aprobado, recoger el certificado de práctica de la oficina del Consejo de Abogados del Estado o recibirlo por correo de BCI.</li>
-</ol>
- <h2>¿Cómo descargar el certificado desde el sitio web o la aplicación del BCI? </h2>
-
-<ol>
-<li>Visite el sitio web del BCI en <a href="">https://www.barcouncilofindia.org/</a> o descargue la aplicación BCI desde Google Play Store o Apple App Store.</li>
-<li>Inicie sesión con su número de inscripción y contraseña. Si no tiene una cuenta, regístrese con sus datos y cree una contraseña. </li>
-<li>Ir a la sección de "Certificado de práctica" y haga clic en "Descargar certificado". </li>
-<li> Seleccione el año y el mes de la emisión del certificado e introduzca su número de inscripción. </li>
-<li>Haga clic en "Enviar" y descargue el archivo PDF de su certificado. </li>
-<li> También puede imprimir o compartir el certificado según su conveniencia. </li>
-</ol>
- <h2>Problemas y soluciones comunes para el certificado</h2>
-<p>Algunos de los problemas comunes que enfrentan los defensores con respecto al certificado de práctica son:</p>
-<ul>
-<li>El certificado se pierde, se daña o se roba. </li>
-<li>El certificado no se recibe dentro de los 30 días de la solicitud. </li>
-<li>El certificado contiene errores o discrepancias en nombre, dirección, número de inscripción, etc.</li>
-<li>El certificado no es aceptado por algunos tribunales o autoridades como prueba válida de la práctica. </li>
-</ul>
-<p>Algunas de las soluciones para estos problemas son:</p>
-<ul>
-<li>Si el certificado se pierde, se daña o se roba, un defensor puede solicitar un certificado duplicado pagando una tarifa de Rs. 1000/- al BCI y presentar una declaración jurada indicando el motivo de la pérdida o daño junto con una copia de FIR en caso de robo. El certificado duplicado se emitirá dentro de los 15 días posteriores a la solicitud. </li>
-<li>Si el certificado no se recibe dentro de los 30 días posteriores a la solicitud, un defensor puede ponerse en contacto con la oficina del Consejo de Abogados del Estado o la oficina del BCI y preguntar sobre el estado de su solicitud. También puede rastrear el estado en línea a través del sitio web o la aplicación del ICB ingresando su número de inscripción y fecha de nacimiento. </li>
-
-<li>Si el certificado no es aceptado por algunos juzgados, tribunales o autoridades como prueba válida de la práctica, un abogado puede apelar ante el ICB o los Consejos de Abogados del Estado y solicitar su intervención y aclaración. También puede mostrar otros documentos como el documento de identidad, la tarjeta de inscripción, la tarjeta de pase AIBE, etc., para demostrar su elegibilidad para ejercer la abogacía en la India.</li>
-</ul>
- <h2>¿Cómo renovar y verificar el certificado? </h2>
-<p>El certificado de práctica es válido por cinco años a partir de la fecha de emisión. Un abogado tiene que renovar su certificado antes de su vencimiento mediante el pago de una cuota de renovación de Rs. 600/- al BCI y presentar un formulario de solicitud de renovación junto con una copia de su certificado existente. El certificado renovado se emitirá dentro de los 15 días posteriores a la solicitud. Un defensor también puede verificar su certificado en línea a través del sitio web o aplicación del BCI ingresando su número de inscripción y número de certificado. La verificación mostrará los detalles del certificado tales como nombre, dirección, fecha de emisión, fecha de vencimiento, etc. La verificación también mostrará si el certificado es válido, caducado, suspendido o cancelado. <h2>Conclusión</h2>
-<p>En este artículo, he explicado cómo descargar el certificado del Colegio de Abogados de la India, que es un documento que certifica que un defensor es elegible para ejercer la abogacía en la India. También he explicado el propósito y los beneficios del certificado, los criterios de elegibilidad y los pasos para solicitar el certificado, los problemas comunes y las soluciones para el certificado, y cómo renovar y verificar el certificado. Espero que haya encontrado este artículo útil e informativo. Si tiene alguna pregunta o comentario, no dude en ponerse en contacto conmigo. ¡Gracias por leer! </p>
- <h2>Preguntas frecuentes</h2>
-<h3>¿Cuál es la diferencia entre el certificado de inscripción y el certificado de práctica? </h3>
-
- <h3>¿Cómo puedo comprobar el estado de mi solicitud de certificado de práctica? </h3>
-<p>Puede comprobar el estado de su solicitud en línea a través del sitio web o aplicación del BCI ingresando su número de inscripción y fecha de nacimiento. También puede ponerse en contacto con la oficina del Consejo del Colegio de Abogados del Estado o la oficina del BCI y preguntar sobre el estado de su solicitud. </p>
- <h3>¿Cómo puedo cambiar mi dirección u otros detalles en mi certificado de práctica? </h3>
-<p>Puede cambiar su dirección u otros detalles en su certificado de práctica solicitando una corrección al BCI y pagando una tarifa de Rs. 500/-. Usted tiene que presentar una carta de solicitud junto con los documentos de apoyo como prueba de identidad, certificado de inscripción, certificado de pase AIBE, etc. El certificado corregido se emitirá dentro de los 15 días de la solicitud. </p>
- <h3>¿Cuáles son las consecuencias de no tener un certificado de práctica válido? </h3>
-<p>Si no tiene un certificado de práctica válido, puede enfrentar las siguientes consecuencias:</p>
-<ul>
-<li>No se le puede permitir comparecer ante ningún tribunal, tribunal o autoridad como abogado. </li>
-<li>Usted no puede tener derecho a ningún plan de bienestar, planes de seguro, fondos de pensiones, etc., proporcionado por el BCI o los Consejos de Abogados del Estado.</li>
-<li>Es posible que no pueda participar en las elecciones del ICB, comités, subcomités, etc., y contribuir a la formulación de políticas y la gobernanza de la profesión jurídica. </li>
-<li>Usted puede ser responsable de una acción disciplinaria por parte del BCI o los Consejos de Abogados del Estado por mala conducta profesional. </li>
-</ul>
- <h3>¿Dónde puedo obtener más información sobre el certificado de práctica? </h3>
-<p>Puede obtener más información sobre el certificado de práctica de las siguientes fuentes:</p>
-<ul>
-<li>El sitio web del ICB en <a href="">https://www.barcouncilofindia.org/</a></li>
-<li>La aplicación BCI disponible en Google Play Store o Apple App Store.</li>
-<li>La oficina del Consejo de Abogados en su estado. </li>
-<li>La oficina de BCI en 21 Rouse Avenue Área Institucional ITO Cerca de Bal Bhawan Nueva Delhi - 110002. </li>
-
-<li>La dirección de correo electrónico del ICB en [email protected]. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Genshin Impacto Paso En Un Vasto.md

@@ -1,232 +0,0 @@
-
-<h1>Descargar Genshin Impact: Paso a un Vasto Mundo Mágico de Aventura</h1>
- <p>¿Alguna vez has soñado con explorar un vasto mundo abierto lleno de maravillas, misterios y magia? ¿Quieres embarcarte en una aventura épica para encontrar a tu hermano perdido y descubrir los secretos de una tierra gobernada por poderosos dioses? ¿Quieres experimentar un sistema de combate lleno de acción que te permite liberar poderes elementales y cambiar entre diferentes personajes? Si respondiste sí a cualquiera de estas preguntas, entonces deberías descargar Genshin Impact, uno de los mejores juegos gratuitos jamás creados. </p>
- <p>Genshin Impact es un juego de rol de acción de mundo abierto que te quitará el aliento con sus impresionantes gráficos, banda sonora inmersiva, una historia atractiva y una jugabilidad diversa. En este juego, puedes explorar siete naciones inspiradas en diferentes culturas y mitologías, conocer un colorido elenco de personajes con personalidades y habilidades únicas, y luchar contra enemigos formidables con tus amigos o en solitario. También puede personalizar su partido con más de 40 personajes de diferentes elementos y tipos de armas, así como actualizar su equipo y habilidades para adaptarse a su estilo de juego. </p>
-<h2>descargar genshin impacto paso en un vasto</h2><br /><p><b><b>DOWNLOAD</b> &mdash;&mdash;&mdash;&mdash;&mdash; <a href="https://bltlly.com/2v6ISq">https://bltlly.com/2v6ISq</a></b></p><br /><br />
- <p>Si tienes curiosidad sobre este increíble juego y quieres saber más sobre él, sigue leyendo este artículo. Te contaremos todo lo que necesitas saber sobre Genshin Impact, desde cómo descargarlo en diferentes plataformas, cómo jugarlo eficazmente, cómo progresar sin problemas y cómo mejorar tu experiencia en él. Al final de este artículo, estarás listo para entrar en un vasto mundo mágico de aventura. </p>
- <h2>¿Qué es el impacto de Genshin? </h2>
-
- <p>El mundo del juego está dividido en siete regiones, cada una correspondiente a uno de los siete elementos: Anemo (viento), Geo (tierra), Pyro (fuego), Hydro (agua), Cryo (hielo), Electro (rayo), y Dendro (naturaleza). Cada región tiene su propia cultura, historia, monumentos, vida silvestre y clima. El jugador puede explorar el mundo libremente utilizando varios métodos de travesía, como caminar, escalar, nadar, planear y montar a caballo. El jugador también puede interactuar con varios objetos y PNJ en el mundo, como abrir cofres, recoger artículos, cocinar alimentos, fabricar armas, completar misiones y unirse a eventos. </p>
- <p>El sistema de combate del juego se basa en el uso de habilidades y reacciones elementales. El jugador puede elegir hasta cuatro personajes para formar un grupo, cada uno con su propio elemento y tipo de arma. El jugador puede cambiar entre personajes en cualquier momento durante el combate, y utilizar sus habilidades para hacer daño y crear reacciones elementales. Las reacciones elementales son efectos especiales que ocurren cuando dos elementos diferentes entran en contacto, como la quema, congelación, electrocutación o explosión. Estos efectos pueden proporcionar varias ventajas o desventajas en combate, dependiendo de la situación. </p>
- <h2>Cómo descargar Genshin impacto en diferentes plataformas</h2>
- <p>Genshin Impact está disponible para su descarga en Windows PC, dispositivos Android, dispositivos iOS, PlayStation 4 y PlayStation 5. El juego es gratuito para descargar y jugar en todas las plataformas, pero requiere una conexión a Internet y una cuenta miHoYo para acceder. Estos son los pasos para descargar e instalar Genshin Impact en diferentes plataformas:</p>
- <h3>Cómo descargar Genshin impacto en Windows PC</h3>
- <ol>
-<li>Ir al sitio web oficial de Genshin Impact en <a href="">https://genshin.mihoyo.com/en</a>. </li>
-<li>Haga clic en el icono "Windows" en la esquina superior derecha de la página. </li>
-<li>Haga clic en el botón "Descargar ahora" y guarde el archivo en su ubicación preferida. </li>
-
-<li>Abre el lanzador del juego e inicia sesión con tu cuenta miHoYo o crea uno si no tienes uno. </li>
-<li>Haga clic en el botón "Obtener juego" y espere a que el juego se descargue e instale. </li>
-<li>Haga clic en el botón "Lanzar" y disfrute del juego. </li>
-</ol>
- <h4>Requisitos del sistema de PC</h4>
- <tabla>
-<tr>
-<th>Requisitos mínimos</th>
-<th>Requisitos recomendados</th>
-</tr>
-<tr>
-<td>OS: Windows 7 SP1 de 64 bits o superior</td>
-<td>OS: Windows 10 64-bit</td>
-</tr>
-<tr>
-<td>CPU: Intel Core i5 o equivalente</td>
-<td>CPU: Intel Core i7 o equivalente</td>
-</tr>
-<tr>
-<td>RAM: 8 GB</td>
-<td>RAM: 16 GB</td>
-</tr>
-<tr>
-<td>GPU: NVIDIA GeForce GT 1030 o superior</td>
-<td>GPU: NVIDIA GeForce RTX 1060 6 GB o superior</td>
-</tr>
-<tr>
-<td>DirectX: Versión 11</td>
-<td>DirectX: Versión 11</td>
-</tr>
-<tr>
-<td>Almacenamiento: 30 GB de espacio disponible</td>
-<td>Almacenamiento: 30 GB de espacio disponible</td>
-</tr>
-<tr>
-<td>Tarjeta de sonido: tarjeta de sonido compatible con DirectX o chipset a bordo</td>
-<td>Tarjeta de sonido: tarjeta de sonido compatible con DirectX o chipset a bordo</td>
-</tr>
-</tabla>
- <h3>Cómo descargar Genshin impacto en dispositivos Android</h3>
- <ol>
-<li>Ir a la aplicación Google Play Store en su dispositivo y buscar "Impacto Genshin". </li>
-<li> Seleccione el juego de los resultados de búsqueda y toque en el "Instalar" botón. </li>
-<li>Espera a que el juego se descargue e instale en tu dispositivo. </li>
-<li>Abra la aplicación del juego e inicie sesión con su cuenta miHoYo o cree una si no tiene una. </li>
-<li>Siga las instrucciones para descargar datos adicionales y comenzar el juego. </li>
-<li>Disfruta del juego. </li>
-</ol>
- <h4>Requisitos del sistema móvil</h4> <h4>Requisitos del sistema móvil</h4>
- <tabla>
-<tr>
-<th>Dispositivos soportados</th>
-<th>Tamaño del archivo</th>
-</tr>
-<tr>
-<td>iOS 9.0 y superior, iPhone 8 Plus y superior, iPad Air 3 y superior, iPad mini 5 y superior, iPad Pro y superior</td>
-<td>Acerca de 9 GB</td>
-</tr>
-</tabla>
- <h3>Cómo descargar Genshin Impact en PlayStation 4 y PlayStation 5</h3>
- <ol>
-
-<li>Seleccione el juego de los resultados de búsqueda y haga clic en el botón "Descargar". </li>
-<li>Espera a que el juego se descargue e instale en tu consola. </li>
-<li>Abra la aplicación del juego e inicie sesión con su cuenta miHoYo o cree una si no tiene una. </li>
-<li>Comienza el juego y disfrútalo. </li>
-</ol>
- <h2>Cómo jugar Genshin impacto</h2>
- <p>Ahora que ha descargado Genshin Impact en su plataforma preferida, usted está listo para jugar. Sin embargo, antes de sumergirte en el juego, es posible que quieras aprender algunos consejos y trucos básicos sobre cómo controlar a tu personaje, cambiar entre los miembros del grupo, usar habilidades elementales e interactuar con el mundo. Estas son algunas de las cosas esenciales que necesitas saber para jugar Genshin Impact eficazmente:</p>
- <h3>Cómo controlar tu carácter</h3>
- <p>Los controles del juego varían dependiendo de la plataforma en la que estés jugando. Estos son los controles predeterminados para cada plataforma:</p>
- <h4>Controles de PC</h4>
- <tabla>
-<tr>
-<th>Acción</th>
-<th>Clave</th>
-</tr>
-<tr>
-<td>Mover</td>
-<td>WASD</td>
-</tr>
-<tr>
-<td>Saltar/Subir/Deslizarse</td>
-<td>Espacio</td>
-</tr>
-<tr>
-<td>Sprint/Nadar más rápido</td>
-<td>Shift</td>
-</tr>
-<tr>
-<td>Ataque/Confirmar/Recoger</td>
-<td>Botón izquierdo del ratón</td>
-</tr>
-<tr>
-<td>Objetivo/Cancelar/Volver</td>
-<td>Botón derecho del ratón</td>
-</tr>
-<tr>
-<td>Habilidad elemental/Interactuar/Hablar/Examinar/Abrir cofres/Revivir personajes/Cambiar objetivos (mientras apuntas)</td>
-<td>E</td>
-</tr>
-<tr>
-<td>Explosión elemental/ Uso de alimentos o medicamentos (mientras apunta)</td>
-<td>Q</td>
-</tr <tr>
-<td>Cambiar caracteres</td>
-<td>1/2/3/4</td>
-</tr>
-<tr>
-<td>Abrir inventario</td>
-<td>B</td>
-</tr>
-<tr>
-<td>Pantalla de caracteres abiertos</td>
-<td>C</td>
-</tr>
-<tr>
-<td>Abrir mapa</td>
-<td>M</td>
-</tr>
-<tr>
-<td>Menú de misiones abiertas</td>
-<td>J</td>
-</tr>
-<tr>
-<td>Abrir menú Paimon</td>
-<td>Esc</td>
-</tr>
-<tr>
-<td>Pausa/Reanudar (mientras apunta)</td>
-<td>P</td>
-</tr>
-<tr>
-<td>Mostrar el cursor (mientras apunta)</td>
-<td>Alt</td>
-</tr>
-<tr>
-<td>Toma una foto (mientras apuntas)</td>
-
-</tr>
-<tr>
-<td>Mostrar/Ocultar interfaz de usuario (mientras apunta)</td>
-<td>F6</td>
-</tr>
- </tabla>
- <p>También puede personalizar las combinaciones de teclas en el menú de configuración si prefiere un diseño diferente. </p>
-<p></p>
- <h4>Controles móviles</h4>
- <tabla>
-<tr>
-<th>Acción</th>
-<th>Control</th>
-</tr>
- <tr>
-<td>Mover</td>
-<td>Arrastre el joystick virtual en el lado izquierdo de la pantalla. </td>
-</tr>
- <tr>
-<td>Saltar/Subir/Deslizarse/Correr/Nadar más rápido/Atacar/Confirmar/Recoger/Apuntar/Cancelar/Retroceder/Habilidad elemental/Interactuar/Hablar/Examinar/Abrir cofres/Revivir personajes/Cambiar objetivos (mientras apuntas)/Usar Comida o Medicina (mientras apuntas</td>
- <td>Toca los botones correspondientes en el lado derecho de la pantalla. </td>
- </tr>
- <tr>
- <td>Elemental Burst/Switch Characters/Open Inventory/Open Character Screen/Open Map/Open Quest Menu/Open Paimon Menu/Pause/Resume (while aiming)/Show Cursor (while aiming)/Take Photo (while aiming)/Show/Hide UI (while aiming)</td>
- <td>Toca los iconos correspondientes en la parte superior o inferior de la pantalla. </td>
- </tr>
- </tabla>
- <p>También puede ajustar la sensibilidad y el diseño de los controles en el menú de configuración si desea cambiarlos. </p>
- <h4>Controles de PlayStation</h4>
- <tabla>
- <tr>
- <th>Acción</th>
- <th>Botón</th>
- </tr>
- <tr>
- <td>Mover/Cámara/Objetivo/Cambiar objetivos (mientras apunta)</td>
- <td>L3/R3 o Stick izquierdo/Stick derecho.</td>
- </tr>
- <tr>
- <td>Saltar/Subir/Deslizarse/Correr/Nadar más rápido/Atacar/Confirmar/Recoger/Apuntar/Cancelar/Retroceder/Habilidad elemental/Interactuar/Hablar/Examinar/Abrir cofres/Revivir personajes/Cambiar objetivos (mientras apuntas)/Usar Comida o Medicina (mientras apuntas</td>
- <td>X/O/Cuadrado/Triángulo o Cruz/Círculo/Cuadrado/Triángulo.</td>
- </tr>
- <tr>
- <td>Elemental Burst/Switch Characters/Open Inventory/Open Character Screen/Open Map/Open Quest Menu/Open Paimon Menu/Pause/Resume (while aiming)/Show Cursor (while aiming)/Take Photo (while aiming)/Show/Hide UI (while aiming)</td>
- <td>L1/R1/L2/R2/D-pad o parachoques izquierdo/parachoques derecho/gatillo izquierdo/gatillo derecho/D-pad. </td>
-
- <h2>Cómo progresar en el impacto de Genshin</h2>
- <p>Ahora que sabes cómo jugar Genshin Impact, es posible que te preguntes cómo progresar en el juego y desbloquear más contenido y características. El juego tiene muchas cosas que ofrecer, pero algunos de ellos están detrás de ciertos requisitos o niveles. Estos son algunos de los aspectos clave del sistema de progresión del juego y cómo conseguirlos:</p>
- <h3>Cómo subir de nivel a tu personaje, armas y artefactos</h3>
- <p>Una de las cosas más importantes que hacer en Genshin Impact es subir de nivel a tu personaje, armas y artefactos. Estas son las principales fuentes de tus estadísticas y habilidades, y determinarán qué tan bien puedes manejar los desafíos y los enemigos en el juego. Aquí hay algunos consejos sobre cómo subir de nivel a tu personaje, armas y artefactos:</p>
- <ul>
-<li>Para subir de nivel a tu personaje, necesitas usar materiales de Character EXP, como Wanderer’s Advice, Adventurer’s Experience y Hero’s Wit. Puedes obtener estos materiales de varias fuentes, como completar misiones, abrir cofres, derrotar enemigos y participar en eventos. También puede usar otros caracteres como materiales EXP, pero esto no es recomendable ya que consumirá sus recursos y limitará sus opciones. </li>
-<li>Para subir de nivel sus armas, es necesario utilizar materiales de mejora de armas, tales como Mineral de mejora, Mineral de mejora fina y Mineral de mejora mística. Usted puede obtener estos materiales de varias fuentes, tales como la elaboración de ellos en un herrero, la minería de ellos de los depósitos de mineral, apertura de cofres, derrotar a los enemigos, y participar en eventos. También puede utilizar otras armas como materiales de mejora, pero esto no se recomienda, ya que consumirá sus recursos y limitar sus opciones. </li>
-
-<li>Para aumentar el nivel máximo de tu personaje, armas y artefactos, necesitas ascenderlos usando materiales específicos. Puedes obtener estos materiales de varias fuentes, como explorar el mundo, completar dominios, derrotar jefes y comprarlos en tiendas. Puedes ascender a tu personaje en los niveles 20, 40, 50, 60, 70 y 80. Puedes ascender tus armas en los niveles 20, 40, 50, 60, 70 y 80. Puedes ascender tus artefactos a nivel 4 y 8.</li>
-</ul>
- <h3> Cómo desbloquear nuevas regiones, misiones y características</h3>
- <p>Otra cosa importante que hacer en Genshin Impact es desbloquear nuevas regiones, misiones y características. Estas son las principales fuentes de tu contenido y disfrute, y te proporcionarán más oportunidades y recompensas en el juego. Aquí hay algunos consejos sobre cómo desbloquear nuevas regiones, misiones y características:</p>
- <ul>
-<li>Para desbloquear nuevas regiones, necesitas aumentar tu Rango de Aventurero (AR). Esta es una medida de su progreso general y experiencia en el juego, y determinará qué regiones, misiones y características están disponibles para usted. Puedes aumentar tu RA completando misiones, abriendo cofres, descubriendo ubicaciones, activando teletransportadores y estatuas, y participando en eventos. </li>
-<li>Para desbloquear nuevas misiones, necesitas cumplir ciertos requisitos o condiciones. Estos pueden variar dependiendo del tipo y la dificultad de la misión. Algunas misiones están relacionadas con la historia y se desbloquearán automáticamente a medida que avanzas en el juego. Algunas misiones están relacionadas con el mundo y se desbloquearán explorando el mundo o interactuando con NPCs. Algunas misiones están relacionadas con el dominio y se desbloquearán completando dominios o alcanzando ciertos niveles de AR. </li>
-<li>Para desbloquear nuevas características, necesitas completar ciertas misiones o alcanzar ciertos niveles de AR. Estas características incluyen el modo cooperativo, el abismo en espiral, el sistema de reputación, el sistema de vivienda, el sistema de pesca y más. Estas características mejorarán tu experiencia de juego y te proporcionarán más opciones y recompensas en el juego. </li>
-</ul>
-
- <p>Genshin Impact ya es un gran juego que ofrece mucha diversión y emoción, pero todavía hay maneras de mejorar tu experiencia en él aún más. Aquí hay algunas sugerencias sobre cómo aprovechar al máximo su aventura en Teyvat:</p>
- <h3>Juego multiplataforma</h3>
- <p>Una de las mejores características de Genshin Impact es su juego multiplataforma. Esto significa que puedes jugar con tus amigos en diferentes dispositivos, como PC, móvil y PlayStation. También puede cambiar entre dispositivos sin perder su progreso o datos. Para habilitar el juego multiplataforma, el juego. Sin embargo, el juego tiene un modo sin conexión que le permite jugar el juego sin conexión a Internet por un tiempo limitado. Puede activar el modo sin conexión yendo al menú Paimon y seleccionando "Configuración" y luego "Otro" y luego "Red". Sin embargo, no podrás acceder a algunas de las características y contenido del juego en modo offline, como modo cooperativo, eventos, correo y actualizaciones. </p>
- <h3>¿Es Genshin Impact cross-play? </h3>
- <p>Sí, Genshin Impact es un juego cruzado, lo que significa que puedes jugar con tus amigos en diferentes dispositivos, como PC, móvil y PlayStation. También puede cambiar entre dispositivos sin perder su progreso o datos. Sin embargo, debes asegurarte de que tú y tus amigos estén jugando en el mismo servidor y hayan alcanzado el rango de aventurero 16 o superior para acceder al modo cooperativo. </p>
- <h3>¿Es Genshin Impact de pago a ganancia? </h3>
-
- <h3>¿Es seguro el impacto de Genshin? </h3>
- <p>Sí, Genshin Impact es seguro, lo que significa que no contiene ningún contenido dañino o malicioso o software que pueda dañar su dispositivo o información personal. El juego está desarrollado por una empresa de confianza, miHoYo, que ha estado haciendo juegos exitosos y populares durante años. El juego también está verificado y certificado por varias plataformas y autoridades, como Google Play Store, App Store, PlayStation Store, ESRB, PEGI, CERO y más. El juego también tiene una política de privacidad y términos de servicio que protegen sus derechos e intereses como usuario. Sin embargo, debe ser cuidadoso y responsable al jugar el juego en línea, como no compartir su cuenta o información personal con nadie, no hacer clic en enlaces o anuncios sospechosos, no descargar ningún software o mods no oficiales o no autorizados, y no participar en actividades ilegales o poco éticas. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BetterAPI/BetterChat_new/README.md

@@ -1,13 +0,0 @@
----
-title: BetterChat - AI for everyone
-sdk: docker
-emoji: ⚡
-colorTo: blue
-pinned: true
-license: mit
-colorFrom: gray
-duplicated_from: BetterAPI/BetterChat
----
-
-
-### BetterChat

spaces/CVPR/BigDL-Nano_inference/data.py

@@ -1,233 +0,0 @@
-# This file is copied from https://github.com/rnwzd/FSPBT-Image-Translation/blob/master/data.py
-
-# MIT License
-
-# Copyright (c) 2022 Lorenzo Breschi
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-from typing import Callable, Dict
-
-import torch
-
-from torch.utils.data import Dataset
-
-import torchvision.transforms.functional as F
-from torchvision import transforms
-import pytorch_lightning as pl
-
-from collections.abc import Iterable
-
-
-# image reader writer
-from pathlib import Path
-from PIL import Image
-from typing import Tuple
-
-
-def read_image(filepath: Path, mode: str = None) -> Image:
-    with open(filepath, 'rb') as file:
-        image = Image.open(file)
-        return image.convert(mode)
-
-
-image2tensor = transforms.ToTensor()
-tensor2image = transforms.ToPILImage()
-
-
-def write_image(image: Image, filepath: Path):
-    filepath.parent.mkdir(parents=True, exist_ok=True)
-    image.save(str(filepath))
-
-
-def read_image_tensor(filepath: Path, mode: str = 'RGB') -> torch.Tensor:
-    return image2tensor(read_image(filepath, mode))
-
-
-def write_image_tensor(input: torch.Tensor, filepath: Path):
-    write_image(tensor2image(input), filepath)
-
-
-def get_valid_indices(H: int, W: int, patch_size: int, random_overlap: int = 0):
-
-    vih = torch.arange(random_overlap, H-patch_size -
-                       random_overlap+1, patch_size)
-    viw = torch.arange(random_overlap, W-patch_size -
-                       random_overlap+1, patch_size)
-    if random_overlap > 0:
-        rih = torch.randint_like(vih, -random_overlap, random_overlap)
-        riw = torch.randint_like(viw, -random_overlap, random_overlap)
-        vih += rih
-        viw += riw
-    vi = torch.stack(torch.meshgrid(vih, viw)).view(2, -1).t()
-    return vi
-
-
-def cut_patches(input: torch.Tensor, indices: Tuple[Tuple[int, int]], patch_size: int, padding: int = 0):
-    # TODO use slices to get all patches at the same time ?
-
-    patches_l = []
-    for n in range(len(indices)):
-
-        patch = F.crop(input, *(indices[n]-padding),
-                       *(patch_size+padding*2,)*2)
-        patches_l.append(patch)
-    patches = torch.cat(patches_l, dim=0)
-
-    return patches
-
-
-def prepare_data(data_path: Path, read_func: Callable = read_image_tensor) -> Dict:
-    """
-    Takes a data_path of a folder which contains subfolders with input, target, etc.
-    lablelled by the same names.
-    :param data_path: Path of the folder containing data
-    :param read_func: function that reads data and returns a tensor
-    """
-    data_dict = {}
-
-    subdir_names = ["target", "input", "mask"]  # ,"helper"
-
-    # checks only files for which there is an target
-    # TODO check for images
-    name_ls = [file.name for file in (
-        data_path / "target").iterdir() if file.is_file()]
-
-    subdirs = [data_path / sdn for sdn in subdir_names]
-    for sd in subdirs:
-        if sd.is_dir():
-            data_ls = []
-            files = [sd / name for name in name_ls]
-            for file in files:
-                tensor = read_func(file)
-                H, W = tensor.shape[-2:]
-                data_ls.append(tensor)
-            # TODO check that all sizes match
-            data_dict[sd.name] = torch.stack(data_ls, dim=0)
-
-    data_dict['name'] = name_ls
-    data_dict['len'] = len(data_dict['name'])
-    data_dict['H'] = H
-    data_dict['W'] = W
-    return data_dict
-
-
-# TODO an image is loaded whenever a patch is needed, this may be a bottleneck
-class DataDictLoader():
-    def __init__(self, data_dict: Dict,
-                 batch_size: int = 16,
-                 max_length: int = 128,
-                 shuffle: bool = False):
-        """
-        """
-
-        self.batch_size = batch_size
-        self.shuffle = shuffle
-
-        self.batch_size = batch_size
-
-        self.data_dict = data_dict
-        self.dataset_len = data_dict['len']
-        self.len = self.dataset_len if max_length is None else min(
-            self.dataset_len, max_length)
-        # Calculate # batches
-        num_batches, remainder = divmod(self.len, self.batch_size)
-        if remainder > 0:
-            num_batches += 1
-        self.num_batches = num_batches
-
-    def __iter__(self):
-        if self.shuffle:
-            r = torch.randperm(self.dataset_len)
-            self.data_dict = {k: v[r] if isinstance(
-                v, Iterable) else v for k, v in self.data_dict.items()}
-        self.i = 0
-        return self
-
-    def __next__(self):
-        if self.i >= self.len:
-            raise StopIteration
-        batch = {k: v[self.i:self.i+self.batch_size]
-                 if isinstance(v, Iterable) else v for k, v in self.data_dict.items()}
-
-        self.i += self.batch_size
-        return batch
-
-    def __len__(self):
-        return self.num_batches
-
-
-class PatchDataModule(pl.LightningDataModule):
-
-    def __init__(self, data_dict,
-                 patch_size: int = 2**5,
-                 batch_size: int = 2**4,
-                 patch_num: int = 2**6):
-        super().__init__()
-        self.data_dict = data_dict
-        self.H, self.W = data_dict['H'], data_dict['W']
-        self.len = data_dict['len']
-
-        self.batch_size = batch_size
-        self.patch_size = patch_size
-        self.patch_num = patch_num
-
-    def dataloader(self, data_dict,  **kwargs):
-        return DataDictLoader(data_dict, **kwargs)
-
-    def train_dataloader(self):
-        patches = self.cut_patches()
-        return self.dataloader(patches, batch_size=self.batch_size, shuffle=True,
-                               max_length=self.patch_num)
-
-    def val_dataloader(self):
-        return self.dataloader(self.data_dict, batch_size=1)
-
-    def test_dataloader(self):
-        return self.dataloader(self.data_dict)  # TODO batch size
-
-    def cut_patches(self):
-        # TODO cycle once
-        patch_indices = get_valid_indices(
-            self.H, self.W, self.patch_size, self.patch_size//4)
-        dd = {k: cut_patches(
-            v, patch_indices, self.patch_size) for k, v in self.data_dict.items()
-            if isinstance(v, torch.Tensor)
-        }
-        threshold = 0.1
-        mask_p = torch.mean(
-            dd.get('mask', torch.ones_like(dd['input'])), dim=(-1, -2, -3))
-        masked_idx = (mask_p > threshold).nonzero(as_tuple=True)[0]
-        dd = {k: v[masked_idx] for k, v in dd.items()}
-        dd['len'] = len(masked_idx)
-        dd['H'], dd['W'] = (self.patch_size,)*2
-
-        return dd
-
-
-class ImageDataset(Dataset):
-    def __init__(self, file_paths: Iterable, read_func: Callable = read_image_tensor):
-        self.file_paths = file_paths
-
-    def __getitem__(self, idx: int) -> dict:
-        file = self.file_paths[idx]
-        return read_image_tensor(file), file.name
-
-    def __len__(self) -> int:
-        return len(self.file_paths)

spaces/CVPR/LIVE/thrust/cmake/ThrustBuildCompilerTargets.cmake

@@ -1,150 +0,0 @@
-#
-# This file defines the `thrust_build_compiler_targets()` function, which
-# creates the following interface targets:
-#
-# thrust.compiler_interface
-# - Interface target providing compiler-specific options needed to build
-#   Thrust's tests, examples, etc.
-#
-# thrust.promote_cudafe_warnings
-# - Interface target that adds warning promotion for NVCC cudafe invocations.
-# - Only exists to work around github issue #1174 on tbb.cuda configurations.
-# - May be combined with thrust.compiler_interface when #1174 is fully resolved.
-
-function(thrust_build_compiler_targets)
-  set(cxx_compile_definitions)
-  set(cxx_compile_options)
-
-  thrust_update_system_found_flags()
-
-  if (THRUST_TBB_FOUND)
-    # There's a ton of these in the TBB backend, even though the code is correct.
-    # TODO: silence these warnings in code instead
-    append_option_if_available("-Wno-unused-parameter" cxx_compile_options)
-  endif()
-
-  if ("MSVC" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    # TODO Enable /Wall instead of W3
-    append_option_if_available("/W3" cxx_compile_options)
-
-    # Treat all warnings as errors:
-    append_option_if_available("/WX" cxx_compile_options)
-
-    # Disabled loss-of-data conversion warnings.
-    # TODO Re-enable.
-    append_option_if_available("/wd4244" cxx_compile_options)
-    append_option_if_available("/wd4267" cxx_compile_options)
-
-    # Suppress numeric conversion-to-bool warnings.
-    # TODO Re-enable.
-    append_option_if_available("/wd4800" cxx_compile_options)
-
-    # Disable warning about applying unary operator- to unsigned type.
-    append_option_if_available("/wd4146" cxx_compile_options)
-
-    # MSVC STL assumes that `allocator_traits`'s allocator will use raw pointers,
-    # and the `__DECLSPEC_ALLOCATOR` macro causes issues with thrust's universal
-    # allocators:
-    #   warning C4494: 'std::allocator_traits<_Alloc>::allocate' :
-    #      Ignoring __declspec(allocator) because the function return type is not
-    #      a pointer or reference
-    # See https://github.com/microsoft/STL/issues/696
-    append_option_if_available("/wd4494" cxx_compile_options)
-
-    # Some of the async tests require /bigobj to fit all their sections into the
-    # object files:
-    append_option_if_available("/bigobj" cxx_compile_options)
-
-    # "Oh right, this is Visual Studio."
-    list(APPEND cxx_compile_definitions "NOMINMAX")
-  else()
-    append_option_if_available("-Werror" cxx_compile_options)
-    append_option_if_available("-Wall" cxx_compile_options)
-    append_option_if_available("-Wextra" cxx_compile_options)
-    append_option_if_available("-Winit-self" cxx_compile_options)
-    append_option_if_available("-Woverloaded-virtual" cxx_compile_options)
-    append_option_if_available("-Wcast-qual" cxx_compile_options)
-    append_option_if_available("-Wno-cast-align" cxx_compile_options)
-    append_option_if_available("-Wno-long-long" cxx_compile_options)
-    append_option_if_available("-Wno-variadic-macros" cxx_compile_options)
-    append_option_if_available("-Wno-unused-function" cxx_compile_options)
-    append_option_if_available("-Wno-unused-variable" cxx_compile_options)
-  endif()
-
-  if ("GNU" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.5)
-      # In GCC 4.4, the CUDA backend's kernel launch templates cause
-      # impossible-to-decipher "'<anonymous>' is used uninitialized in this
-      # function" warnings, so we disable uninitialized variable warnings.
-      append_option_if_available("-Wno-uninitialized" cxx_compile_options)
-    endif()
-
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 4.5)
-      # This isn't available until GCC 4.3, and misfires on TMP code until
-      # GCC 4.5.
-      append_option_if_available("-Wlogical-op" cxx_compile_options)
-    endif()
-
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 7.3)
-      # GCC 7.3 complains about name mangling changes due to `noexcept`
-      # becoming part of the type system; we don't care.
-      append_option_if_available("-Wno-noexcept-type" cxx_compile_options)
-    endif()
-  endif()
-
-  if (("Clang" STREQUAL "${CMAKE_CXX_COMPILER_ID}") OR
-      ("XL" STREQUAL "${CMAKE_CXX_COMPILER_ID}"))
-    # xlC and Clang warn about unused parameters in uninstantiated templates.
-    # This causes xlC to choke on the OMP backend, which is mostly #ifdef'd out
-    # (and thus has unused parameters) when you aren't using it.
-    append_option_if_available("-Wno-unused-parameters" cxx_compile_options)
-  endif()
-
-  if ("Clang" STREQUAL "${CMAKE_CXX_COMPILER_ID}")
-    # -Wunneeded-internal-declaration misfires in the unit test framework
-    # on older versions of Clang.
-    append_option_if_available("-Wno-unneeded-internal-declaration" cxx_compile_options)
-  endif()
-
-  if ("Feta" STREQUAL "${CMAKE_CUDA_COMPILER_ID}")
-    # Today:
-    # * NVCC accepts CUDA C++ in .cu files but not .cpp files.
-    # * Feta accepts CUDA C++ in .cpp files but not .cu files.
-    # TODO: This won't be necessary in the future.
-    list(APPEND cxx_compile_options -cppsuffix=cu)
-  endif()
-
-  add_library(thrust.compiler_interface INTERFACE)
-
-  foreach (cxx_option IN LISTS cxx_compile_options)
-    target_compile_options(thrust.compiler_interface INTERFACE
-      $<$<COMPILE_LANGUAGE:CXX>:${cxx_option}>
-      $<$<AND:$<COMPILE_LANGUAGE:CUDA>,$<CUDA_COMPILER_ID:Feta>>:${cxx_option}>
-      # Only use -Xcompiler with NVCC, not Feta.
-      #
-      # CMake can't split genexs, so this can't be formatted better :(
-      # This is:
-      # if (using CUDA and CUDA_COMPILER is NVCC) add -Xcompiler=opt:
-      $<$<AND:$<COMPILE_LANGUAGE:CUDA>,$<CUDA_COMPILER_ID:NVIDIA>>:-Xcompiler=${cxx_option}>
-    )
-  endforeach()
-
-  foreach (cxx_definition IN LISTS cxx_compile_definitions)
-    # Add these for both CUDA and CXX targets:
-    target_compile_definitions(thrust.compiler_interface INTERFACE
-      ${cxx_definition}
-    )
-  endforeach()
-
-  # Display warning numbers from nvcc cudafe errors:
-  target_compile_options(thrust.compiler_interface INTERFACE
-    # If using CUDA w/ NVCC...
-    $<$<AND:$<COMPILE_LANGUAGE:CUDA>,$<CUDA_COMPILER_ID:NVIDIA>>:-Xcudafe=--display_error_number>
-  )
-
-  # This is kept separate for Github issue #1174.
-  add_library(thrust.promote_cudafe_warnings INTERFACE)
-  target_compile_options(thrust.promote_cudafe_warnings INTERFACE
-    $<$<AND:$<COMPILE_LANGUAGE:CUDA>,$<CUDA_COMPILER_ID:NVIDIA>>:-Xcudafe=--promote_warnings>
-  )
-endfunction()

spaces/CVPR/lama-example/models/ade20k/segm_lib/nn/__init__.py

@@ -1,2 +0,0 @@
-from .modules import *
-from .parallel import UserScatteredDataParallel, user_scattered_collate, async_copy_to

spaces/Caoyunkang/Segment-Any-Anomaly/GroundingDINO/groundingdino/util/logger.py

@@ -1,93 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import functools
-import logging
-import os
-import sys
-
-from termcolor import colored
-
-
-class _ColorfulFormatter(logging.Formatter):
-    def __init__(self, *args, **kwargs):
-        self._root_name = kwargs.pop("root_name") + "."
-        self._abbrev_name = kwargs.pop("abbrev_name", "")
-        if len(self._abbrev_name):
-            self._abbrev_name = self._abbrev_name + "."
-        super(_ColorfulFormatter, self).__init__(*args, **kwargs)
-
-    def formatMessage(self, record):
-        record.name = record.name.replace(self._root_name, self._abbrev_name)
-        log = super(_ColorfulFormatter, self).formatMessage(record)
-        if record.levelno == logging.WARNING:
-            prefix = colored("WARNING", "red", attrs=["blink"])
-        elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL:
-            prefix = colored("ERROR", "red", attrs=["blink", "underline"])
-        else:
-            return log
-        return prefix + " " + log
-
-
-# so that calling setup_logger multiple times won't add many handlers
-@functools.lru_cache()
-def setup_logger(output=None, distributed_rank=0, *, color=True, name="imagenet", abbrev_name=None):
-    """
-    Initialize the detectron2 logger and set its verbosity level to "INFO".
-
-    Args:
-        output (str): a file name or a directory to save log. If None, will not save log file.
-            If ends with ".txt" or ".log", assumed to be a file name.
-            Otherwise, logs will be saved to `output/log.txt`.
-        name (str): the root module name of this logger
-
-    Returns:
-        logging.Logger: a logger
-    """
-    logger = logging.getLogger(name)
-    logger.setLevel(logging.DEBUG)
-    logger.propagate = False
-
-    if abbrev_name is None:
-        abbrev_name = name
-
-    plain_formatter = logging.Formatter(
-        "[%(asctime)s.%(msecs)03d]: %(message)s", datefmt="%m/%d %H:%M:%S"
-    )
-    # stdout logging: master only
-    if distributed_rank == 0:
-        ch = logging.StreamHandler(stream=sys.stdout)
-        ch.setLevel(logging.DEBUG)
-        if color:
-            formatter = _ColorfulFormatter(
-                colored("[%(asctime)s.%(msecs)03d]: ", "green") + "%(message)s",
-                datefmt="%m/%d %H:%M:%S",
-                root_name=name,
-                abbrev_name=str(abbrev_name),
-            )
-        else:
-            formatter = plain_formatter
-        ch.setFormatter(formatter)
-        logger.addHandler(ch)
-
-    # file logging: all workers
-    if output is not None:
-        if output.endswith(".txt") or output.endswith(".log"):
-            filename = output
-        else:
-            filename = os.path.join(output, "log.txt")
-        if distributed_rank > 0:
-            filename = filename + f".rank{distributed_rank}"
-        os.makedirs(os.path.dirname(filename), exist_ok=True)
-
-        fh = logging.StreamHandler(_cached_log_stream(filename))
-        fh.setLevel(logging.DEBUG)
-        fh.setFormatter(plain_formatter)
-        logger.addHandler(fh)
-
-    return logger
-
-
-# cache the opened file object, so that different calls to `setup_logger`
-# with the same file name can safely write to the same file.
-@functools.lru_cache(maxsize=None)
-def _cached_log_stream(filename):
-    return open(filename, "a")

spaces/CrucibleAI/ControlNetMediaPipeFaceSD21/ldm/modules/midas/midas/dpt_depth.py

@@ -1,109 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .base_model import BaseModel
-from .blocks import (
-    FeatureFusionBlock,
-    FeatureFusionBlock_custom,
-    Interpolate,
-    _make_encoder,
-    forward_vit,
-)
-
-
-def _make_fusion_block(features, use_bn):
-    return FeatureFusionBlock_custom(
-        features,
-        nn.ReLU(False),
-        deconv=False,
-        bn=use_bn,
-        expand=False,
-        align_corners=True,
-    )
-
-
-class DPT(BaseModel):
-    def __init__(
-        self,
-        head,
-        features=256,
-        backbone="vitb_rn50_384",
-        readout="project",
-        channels_last=False,
-        use_bn=False,
-    ):
-
-        super(DPT, self).__init__()
-
-        self.channels_last = channels_last
-
-        hooks = {
-            "vitb_rn50_384": [0, 1, 8, 11],
-            "vitb16_384": [2, 5, 8, 11],
-            "vitl16_384": [5, 11, 17, 23],
-        }
-
-        # Instantiate backbone and reassemble blocks
-        self.pretrained, self.scratch = _make_encoder(
-            backbone,
-            features,
-            False, # Set to true of you want to train from scratch, uses ImageNet weights
-            groups=1,
-            expand=False,
-            exportable=False,
-            hooks=hooks[backbone],
-            use_readout=readout,
-        )
-
-        self.scratch.refinenet1 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet2 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet3 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet4 = _make_fusion_block(features, use_bn)
-
-        self.scratch.output_conv = head
-
-
-    def forward(self, x):
-        if self.channels_last == True:
-            x.contiguous(memory_format=torch.channels_last)
-
-        layer_1, layer_2, layer_3, layer_4 = forward_vit(self.pretrained, x)
-
-        layer_1_rn = self.scratch.layer1_rn(layer_1)
-        layer_2_rn = self.scratch.layer2_rn(layer_2)
-        layer_3_rn = self.scratch.layer3_rn(layer_3)
-        layer_4_rn = self.scratch.layer4_rn(layer_4)
-
-        path_4 = self.scratch.refinenet4(layer_4_rn)
-        path_3 = self.scratch.refinenet3(path_4, layer_3_rn)
-        path_2 = self.scratch.refinenet2(path_3, layer_2_rn)
-        path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
-
-        out = self.scratch.output_conv(path_1)
-
-        return out
-
-
-class DPTDepthModel(DPT):
-    def __init__(self, path=None, non_negative=True, **kwargs):
-        features = kwargs["features"] if "features" in kwargs else 256
-
-        head = nn.Sequential(
-            nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1),
-            Interpolate(scale_factor=2, mode="bilinear", align_corners=True),
-            nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(True),
-            nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
-            nn.ReLU(True) if non_negative else nn.Identity(),
-            nn.Identity(),
-        )
-
-        super().__init__(head, **kwargs)
-
-        if path is not None:
-           self.load(path)
-
-    def forward(self, x):
-        return super().forward(x).squeeze(dim=1)
-

spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/models/modeling_llama.py

@@ -1,755 +0,0 @@
-# This script is based on https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py
-
-""" PyTorch LLaMA model."""
-import math
-from typing import List, Optional, Tuple, Union
-
-import torch
-import torch.utils.checkpoint
-from torch import nn
-from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
-
-from transformers.activations import ACT2FN
-from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast, SequenceClassifierOutputWithPast
-from transformers.modeling_utils import PreTrainedModel
-from transformers.utils import add_start_docstrings, add_start_docstrings_to_model_forward, logging, replace_return_docstrings
-from transformers.models.llama.configuration_llama import LlamaConfig
-
-
-logger = logging.get_logger(__name__)
-
-_CONFIG_FOR_DOC = "LlamaConfig"
-
-
-# Copied from transformers.models.bart.modeling_bart._make_causal_mask
-def _make_causal_mask(
-    input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device, past_key_values_length: int = 0
-):
-    """
-    Make causal mask used for bi-directional self-attention.
-    """
-    bsz, tgt_len = input_ids_shape
-    mask = torch.full((tgt_len, tgt_len), torch.tensor(torch.finfo(dtype).min, device=device), device=device)
-    mask_cond = torch.arange(mask.size(-1), device=device)
-    mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)
-    mask = mask.to(dtype)
-
-    if past_key_values_length > 0:
-        mask = torch.cat([torch.zeros(tgt_len, past_key_values_length, dtype=dtype, device=device), mask], dim=-1)
-    return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len + past_key_values_length)
-
-
-# Copied from transformers.models.bart.modeling_bart._expand_mask
-def _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):
-    """
-    Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.
-    """
-    bsz, src_len = mask.size()
-    tgt_len = tgt_len if tgt_len is not None else src_len
-
-    expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)
-
-    inverted_mask = 1.0 - expanded_mask
-
-    return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)
-
-
-class LlamaRMSNorm(nn.Module):
-    def __init__(self, hidden_size, eps=1e-6):
-        """
-        LlamaRMSNorm is equivalent to T5LayerNorm
-        """
-        super().__init__()
-        self.weight = nn.Parameter(torch.ones(hidden_size))
-        self.variance_epsilon = eps
-
-    def forward(self, hidden_states):
-        variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
-        hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)
-
-        # convert into half-precision if necessary
-        if self.weight.dtype in [torch.float16, torch.bfloat16]:
-            hidden_states = hidden_states.to(self.weight.dtype)
-
-        return self.weight * hidden_states
-
-
-class LlamaRotaryEmbedding(torch.nn.Module):
-    def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):
-        super().__init__()
-        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float().to(device) / dim))
-        self.register_buffer("inv_freq", inv_freq)
-
-        # Build here to make `torch.jit.trace` work.
-        self.max_seq_len_cached = max_position_embeddings
-        t = torch.arange(self.max_seq_len_cached, device=self.inv_freq.device, dtype=self.inv_freq.dtype)
-        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
-        # Different from paper, but it uses a different permutation in order to obtain the same calculation
-        emb = torch.cat((freqs, freqs), dim=-1)
-        self.register_buffer("cos_cached", emb.cos()[None, None, :, :], persistent=False)
-        self.register_buffer("sin_cached", emb.sin()[None, None, :, :], persistent=False)
-
-    def forward(self, x, seq_len=None):
-        # x: [bs, num_attention_heads, seq_len, head_size]
-        # This `if` block is unlikely to be run after we build sin/cos in `__init__`. Keep the logic here just in case.
-        if seq_len > self.max_seq_len_cached:
-            self.max_seq_len_cached = seq_len
-            t = torch.arange(self.max_seq_len_cached, device=x.device, dtype=self.inv_freq.dtype)
-            freqs = torch.einsum("i,j->ij", t, self.inv_freq)
-            # Different from paper, but it uses a different permutation in order to obtain the same calculation
-            emb = torch.cat((freqs, freqs), dim=-1).to(x.device)
-            self.register_buffer("cos_cached", emb.cos()[None, None, :, :], persistent=False)
-            self.register_buffer("sin_cached", emb.sin()[None, None, :, :], persistent=False)
-        return (
-            self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
-            self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype),
-        )
-
-
-def rotate_half(x):
-    """Rotates half the hidden dims of the input."""
-    x1 = x[..., : x.shape[-1] // 2]
-    x2 = x[..., x.shape[-1] // 2 :]
-    return torch.cat((-x2, x1), dim=-1)
-
-
-def apply_rotary_pos_emb(q, k, cos, sin, position_ids):
-    gather_indices = position_ids[:, None, :, None]  # [bs, 1, seq_len, 1]
-    gather_indices = gather_indices.repeat(1, cos.shape[1], 1, cos.shape[3])
-    cos = torch.gather(cos.repeat(gather_indices.shape[0], 1, 1, 1), 2, gather_indices)
-    sin = torch.gather(sin.repeat(gather_indices.shape[0], 1, 1, 1), 2, gather_indices)
-    q_embed = (q * cos) + (rotate_half(q) * sin)
-    k_embed = (k * cos) + (rotate_half(k) * sin)
-    return q_embed, k_embed
-
-
-class LlamaMLP(nn.Module):
-    def __init__(
-        self,
-        hidden_size: int,
-        intermediate_size: int,
-        hidden_act: str,
-    ):
-        super().__init__()
-        self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
-        self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False)
-        self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
-        self.act_fn = ACT2FN[hidden_act]
-
-    def forward(self, x):
-        return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
-
-
-class LlamaAttention(nn.Module):
-    """Multi-headed attention from 'Attention Is All You Need' paper"""
-
-    def __init__(self, config: LlamaConfig):
-        super().__init__()
-        self.config = config
-        self.hidden_size = config.hidden_size
-        self.num_heads = config.num_attention_heads
-        self.head_dim = self.hidden_size // self.num_heads
-        self.max_position_embeddings = config.max_position_embeddings
-
-        if (self.head_dim * self.num_heads) != self.hidden_size:
-            raise ValueError(
-                f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}"
-                f" and `num_heads`: {self.num_heads})."
-            )
-        self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
-        self.k_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
-        self.v_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False)
-        self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False)
-        self.rotary_emb = LlamaRotaryEmbedding(self.head_dim, max_position_embeddings=self.max_position_embeddings)
-
-    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
-        return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_value: Optional[Tuple[torch.Tensor]] = None,
-        output_attentions: bool = False,
-        use_cache: bool = False,
-    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:
-        bsz, q_len, _ = hidden_states.size()
-
-        query_states = self.q_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
-        key_states = self.k_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
-        value_states = self.v_proj(hidden_states).view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
-
-        kv_seq_len = key_states.shape[-2]
-        if past_key_value is not None:
-            kv_seq_len += past_key_value[0].shape[-2]
-        cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)
-        query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)
-        # [bsz, nh, t, hd]
-
-        if past_key_value is not None:
-            # reuse k, v, self_attention
-            key_states = torch.cat([past_key_value[0], key_states], dim=2)
-            value_states = torch.cat([past_key_value[1], value_states], dim=2)
-
-        past_key_value = (key_states, value_states) if use_cache else None
-
-        attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)
-
-        if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):
-            raise ValueError(
-                f"Attention weights should be of size {(bsz * self.num_heads, q_len, kv_seq_len)}, but is"
-                f" {attn_weights.size()}"
-            )
-
-        if attention_mask is not None:
-            if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):
-                raise ValueError(
-                    f"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}"
-                )
-            attn_weights = attn_weights + attention_mask
-            attn_weights = torch.max(attn_weights, torch.tensor(torch.finfo(attn_weights.dtype).min))
-
-        # upcast attention to fp32
-        attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)
-        attn_output = torch.matmul(attn_weights, value_states)
-
-        if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):
-            raise ValueError(
-                f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is"
-                f" {attn_output.size()}"
-            )
-
-        attn_output = attn_output.transpose(1, 2)
-        attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)
-
-        attn_output = self.o_proj(attn_output)
-
-        if not output_attentions:
-            attn_weights = None
-
-        return attn_output, attn_weights, past_key_value
-
-
-class LlamaDecoderLayer(nn.Module):
-    def __init__(self, config: LlamaConfig):
-        super().__init__()
-        self.hidden_size = config.hidden_size
-        self.self_attn = LlamaAttention(config=config)
-        self.mlp = LlamaMLP(
-            hidden_size=self.hidden_size,
-            intermediate_size=config.intermediate_size,
-            hidden_act=config.hidden_act,
-        )
-        self.input_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
-        self.post_attention_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_value: Optional[Tuple[torch.Tensor]] = None,
-        output_attentions: Optional[bool] = False,
-        use_cache: Optional[bool] = False,
-    ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]:
-        """
-        Args:
-            hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`
-            attention_mask (`torch.FloatTensor`, *optional*): attention mask of size
-                `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.
-            output_attentions (`bool`, *optional*):
-                Whether or not to return the attentions tensors of all attention layers. See `attentions` under
-                returned tensors for more detail.
-            use_cache (`bool`, *optional*):
-                If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding
-                (see `past_key_values`).
-            past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states
-        """
-
-        residual = hidden_states
-
-        hidden_states = self.input_layernorm(hidden_states)
-
-        # Self Attention
-        hidden_states, self_attn_weights, present_key_value = self.self_attn(
-            hidden_states=hidden_states,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-            past_key_value=past_key_value,
-            output_attentions=output_attentions,
-            use_cache=use_cache,
-        )
-        hidden_states = residual + hidden_states
-
-        # Fully Connected
-        residual = hidden_states
-        hidden_states = self.post_attention_layernorm(hidden_states)
-        hidden_states = self.mlp(hidden_states)
-        hidden_states = residual + hidden_states
-
-        outputs = (hidden_states,)
-
-        if output_attentions:
-            outputs += (self_attn_weights,)
-
-        if use_cache:
-            outputs += (present_key_value,)
-
-        return outputs
-
-
-LLAMA_START_DOCSTRING = r"""
-    This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
-    library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
-    etc.)
-
-    This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
-    Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
-    and behavior.
-
-    Parameters:
-        config ([`LlamaConfig`]):
-            Model configuration class with all the parameters of the model. Initializing with a config file does not
-            load the weights associated with the model, only the configuration. Check out the
-            [`~PreTrainedModel.from_pretrained`] method to load the model weights.
-"""
-
-
-@add_start_docstrings(
-    "The bare LLaMA Model outputting raw hidden-states without any specific head on top.",
-    LLAMA_START_DOCSTRING,
-)
-class LlamaPreTrainedModel(PreTrainedModel):
-    config_class = LlamaConfig
-    base_model_prefix = "model"
-    supports_gradient_checkpointing = True
-    _no_split_modules = ["LlamaDecoderLayer"]
-    _keys_to_ignore_on_load_unexpected = [r"decoder\.version"]
-
-    def _init_weights(self, module):
-        std = self.config.initializer_range
-        if isinstance(module, nn.Linear):
-            module.weight.data.normal_(mean=0.0, std=std)
-            if module.bias is not None:
-                module.bias.data.zero_()
-        elif isinstance(module, nn.Embedding):
-            module.weight.data.normal_(mean=0.0, std=std)
-            if module.padding_idx is not None:
-                module.weight.data[module.padding_idx].zero_()
-
-    def _set_gradient_checkpointing(self, module, value=False):
-        if isinstance(module, LlamaModel):
-            module.gradient_checkpointing = value
-
-
-LLAMA_INPUTS_DOCSTRING = r"""
-    Args:
-        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
-            Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
-            it.
-
-            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
-            [`PreTrainedTokenizer.__call__`] for details.
-
-            [What are input IDs?](../glossary#input-ids)
-        attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
-            Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
-
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-
-            [What are attention masks?](../glossary#attention-mask)
-
-            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
-            [`PreTrainedTokenizer.__call__`] for details.
-
-            If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see
-            `past_key_values`).
-
-            If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]
-            and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more
-            information on the default strategy.
-
-            - 1 indicates the head is **not masked**,
-            - 0 indicates the head is **masked**.
-        position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
-            Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
-            config.n_positions - 1]`.
-
-            [What are position IDs?](../glossary#position-ids)
-        past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):
-            Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape
-            `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape
-            `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.
-
-            Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
-            blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.
-
-            If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
-            don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
-            `decoder_input_ids` of shape `(batch_size, sequence_length)`.
-        inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
-            Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
-            is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
-            model's internal embedding lookup matrix.
-        use_cache (`bool`, *optional*):
-            If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
-            `past_key_values`).
-        output_attentions (`bool`, *optional*):
-            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
-            tensors for more detail.
-        output_hidden_states (`bool`, *optional*):
-            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
-            more detail.
-        return_dict (`bool`, *optional*):
-            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
-"""
-
-
-@add_start_docstrings(
-    "The bare LLaMA Model outputting raw hidden-states without any specific head on top.",
-    LLAMA_START_DOCSTRING,
-)
-class LlamaModel(LlamaPreTrainedModel):
-    """
-    Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`]
-
-    Args:
-        config: LlamaConfig
-    """
-
-    def __init__(self, config: LlamaConfig):
-        super().__init__(config)
-        self.padding_idx = config.pad_token_id
-        self.vocab_size = config.vocab_size
-
-        self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx)
-        self.layers = nn.ModuleList([LlamaDecoderLayer(config) for _ in range(config.num_hidden_layers)])
-        self.norm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)
-
-        self.gradient_checkpointing = False
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def get_input_embeddings(self):
-        return self.embed_tokens
-
-    def set_input_embeddings(self, value):
-        self.embed_tokens = value
-
-    # Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask
-    def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds, past_key_values_length):
-        # create causal mask
-        # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
-        combined_attention_mask = None
-        if input_shape[-1] > 1:
-            combined_attention_mask = _make_causal_mask(
-                input_shape,
-                inputs_embeds.dtype,
-                device=inputs_embeds.device,
-                past_key_values_length=past_key_values_length,
-            )
-
-        if attention_mask is not None:
-            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
-            expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(
-                inputs_embeds.device
-            )
-            combined_attention_mask = (
-                expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask
-            )
-
-        return combined_attention_mask
-
-    @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)
-    def forward(
-        self,
-        input_ids: torch.LongTensor = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_values: Optional[List[torch.FloatTensor]] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        query_embeds: Optional[torch.FloatTensor] = None,
-        use_cache: Optional[bool] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-    ) -> Union[Tuple, BaseModelOutputWithPast]:
-        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
-        )
-        use_cache = use_cache if use_cache is not None else self.config.use_cache
-
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        # retrieve input_ids and inputs_embeds
-        if input_ids is not None and inputs_embeds is not None:
-            raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
-        elif input_ids is not None:
-            batch_size, seq_length = input_ids.shape
-        elif inputs_embeds is not None:
-            batch_size, seq_length, _ = inputs_embeds.shape
-        else:
-            raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
-
-        if inputs_embeds is None:
-            inputs_embeds = self.embed_tokens(input_ids)
-        if query_embeds is not None:
-            inputs_embeds = torch.cat([query_embeds, inputs_embeds], dim=1)
-            batch_size, seq_length, _ = inputs_embeds.shape
-
-        seq_length_with_past = seq_length
-        past_key_values_length = 0
-
-        if past_key_values is not None:
-            past_key_values_length = past_key_values[0][0].shape[2]
-            seq_length_with_past = seq_length_with_past + past_key_values_length
-
-        if position_ids is None:
-            device = input_ids.device if input_ids is not None else inputs_embeds.device
-            position_ids = torch.arange(
-                past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device
-            )
-            position_ids = position_ids.unsqueeze(0).view(-1, seq_length)
-        else:
-            position_ids = position_ids.view(-1, seq_length).long()
-
-        # embed positions
-        if attention_mask is None:
-            attention_mask = torch.ones(
-                (batch_size, seq_length_with_past), dtype=torch.bool, device=inputs_embeds.device
-            )
-        attention_mask = self._prepare_decoder_attention_mask(
-            attention_mask, (batch_size, seq_length), inputs_embeds, past_key_values_length
-        )
-
-        hidden_states = inputs_embeds
-
-        if self.gradient_checkpointing and self.training:
-            if use_cache:
-                logger.warning_once(
-                    "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
-                )
-                use_cache = False
-
-        # decoder layers
-        all_hidden_states = () if output_hidden_states else None
-        all_self_attns = () if output_attentions else None
-        next_decoder_cache = () if use_cache else None
-
-        for idx, decoder_layer in enumerate(self.layers):
-            if output_hidden_states:
-                all_hidden_states += (hidden_states,)
-
-            past_key_value = past_key_values[idx] if past_key_values is not None else None
-
-            if self.gradient_checkpointing and self.training:
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        # None for past_key_value
-                        return module(*inputs, output_attentions, None)
-
-                    return custom_forward
-
-                layer_outputs = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(decoder_layer),
-                    hidden_states,
-                    attention_mask,
-                    position_ids,
-                    None,
-                )
-            else:
-                layer_outputs = decoder_layer(
-                    hidden_states,
-                    attention_mask=attention_mask,
-                    position_ids=position_ids,
-                    past_key_value=past_key_value,
-                    output_attentions=output_attentions,
-                    use_cache=use_cache,
-                )
-
-            hidden_states = layer_outputs[0]
-
-            if use_cache:
-                next_decoder_cache += (layer_outputs[2 if output_attentions else 1],)
-
-            if output_attentions:
-                all_self_attns += (layer_outputs[1],)
-
-        hidden_states = self.norm(hidden_states)
-
-        # add hidden states from the last decoder layer
-        if output_hidden_states:
-            all_hidden_states += (hidden_states,)
-
-        next_cache = next_decoder_cache if use_cache else None
-        if not return_dict:
-            return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None)
-        return BaseModelOutputWithPast(
-            last_hidden_state=hidden_states,
-            past_key_values=next_cache,
-            hidden_states=all_hidden_states,
-            attentions=all_self_attns,
-        )
-
-
-class LlamaForCausalLM(LlamaPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-        self.model = LlamaModel(config)
-
-        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def get_input_embeddings(self):
-        return self.model.embed_tokens
-
-    def set_input_embeddings(self, value):
-        self.model.embed_tokens = value
-
-    def get_output_embeddings(self):
-        return self.lm_head
-
-    def set_output_embeddings(self, new_embeddings):
-        self.lm_head = new_embeddings
-
-    def set_decoder(self, decoder):
-        self.model = decoder
-
-    def get_decoder(self):
-        return self.model
-
-    @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)
-    @replace_return_docstrings(output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC)
-    def forward(
-        self,
-        input_ids: torch.LongTensor = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        position_ids: Optional[torch.LongTensor] = None,
-        past_key_values: Optional[List[torch.FloatTensor]] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        query_embeds: Optional[torch.FloatTensor] = None,
-        labels: Optional[torch.LongTensor] = None,
-        use_cache: Optional[bool] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-    ) -> Union[Tuple, CausalLMOutputWithPast]:
-        r"""
-        Args:
-            labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
-                Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
-                config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
-                (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
-
-        Returns:
-
-        Example:
-
-        ```python
-        >>> from transformers import AutoTokenizer, LlamaForCausalLM
-
-        >>> model = LlamaForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)
-        >>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)
-
-        >>> prompt = "Hey, are you consciours? Can you talk to me?"
-        >>> inputs = tokenizer(prompt, return_tensors="pt")
-
-        >>> # Generate
-        >>> generate_ids = model.generate(inputs.input_ids, max_length=30)
-        >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
-        "Hey, are you consciours? Can you talk to me?\nI'm not consciours, but I can talk to you."
-        ```"""
-
-        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
-        output_hidden_states = (
-            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
-        )
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)
-        outputs = self.model(
-            input_ids=input_ids,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-            past_key_values=past_key_values,
-            inputs_embeds=inputs_embeds,
-            query_embeds=query_embeds,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        hidden_states = outputs[0]
-        logits = self.lm_head(hidden_states)
-
-        loss = None
-        if labels is not None:
-            # Shift so that tokens < n predict n
-            shift_logits = logits[..., :-1, :].contiguous()
-            shift_labels = labels[..., 1:].contiguous()
-            # Flatten the tokens
-            loss_fct = CrossEntropyLoss()
-            shift_logits = shift_logits.view(-1, self.config.vocab_size)
-            shift_labels = shift_labels.view(-1)
-            # Enable model parallelism
-            shift_labels = shift_labels.to(shift_logits.device)
-            loss = loss_fct(shift_logits, shift_labels)
-
-        if not return_dict:
-            output = (logits,) + outputs[1:]
-            return (loss,) + output if loss is not None else output
-
-        return CausalLMOutputWithPast(
-            loss=loss,
-            logits=logits,
-            past_key_values=outputs.past_key_values,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )
-
-    def prepare_inputs_for_generation(
-        self, input_ids, query_embeds=None, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs
-    ):
-        if past_key_values:
-            input_ids = input_ids[:, -1:]
-
-        position_ids = kwargs.get("position_ids", None)
-        if attention_mask is not None and position_ids is None:
-            # create position_ids on the fly for batch generation
-            position_ids = attention_mask.long().cumsum(-1) - 1
-            position_ids.masked_fill_(attention_mask == 0, 1)
-            if past_key_values:
-                position_ids = position_ids[:, -1].unsqueeze(-1)
-                query_embeds = None
-
-        # if `inputs_embeds` are passed, we only want to use them in the 1st generation step
-        if inputs_embeds is not None and past_key_values is None:
-            model_inputs = {"inputs_embeds": inputs_embeds}
-        else:
-            model_inputs = {"input_ids": input_ids}
-
-        model_inputs.update(
-            {
-                "position_ids": position_ids,
-                "query_embeds": query_embeds,
-                "past_key_values": past_key_values,
-                "use_cache": kwargs.get("use_cache"),
-                "attention_mask": attention_mask,
-            }
-        )
-        return model_inputs
-
-    @staticmethod
-    def _reorder_cache(past_key_values, beam_idx):
-        reordered_past = ()
-        for layer_past in past_key_values:
-            reordered_past += (tuple(past_state.index_select(0, beam_idx) for past_state in layer_past),)
-        return reordered_past
-

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/altair/utils/__init__.py

@@ -1,30 +0,0 @@
-from .core import (
-    infer_vegalite_type,
-    infer_encoding_types,
-    sanitize_dataframe,
-    parse_shorthand,
-    use_signature,
-    update_nested,
-    display_traceback,
-    SchemaBase,
-)
-from .html import spec_to_html
-from .plugin_registry import PluginRegistry
-from .deprecation import AltairDeprecationWarning
-from .schemapi import Undefined
-
-
-__all__ = (
-    "infer_vegalite_type",
-    "infer_encoding_types",
-    "sanitize_dataframe",
-    "spec_to_html",
-    "parse_shorthand",
-    "use_signature",
-    "update_nested",
-    "display_traceback",
-    "AltairDeprecationWarning",
-    "SchemaBase",
-    "Undefined",
-    "PluginRegistry",
-)

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/otlLib/optimize/gpos.py

@@ -1,452 +0,0 @@
-import logging
-import os
-from collections import defaultdict, namedtuple
-from functools import reduce
-from itertools import chain
-from math import log2
-from typing import DefaultDict, Dict, Iterable, List, Sequence, Tuple
-
-from fontTools.config import OPTIONS
-from fontTools.misc.intTools import bit_count, bit_indices
-from fontTools.ttLib import TTFont
-from fontTools.ttLib.tables import otBase, otTables
-
-log = logging.getLogger(__name__)
-
-COMPRESSION_LEVEL = OPTIONS[f"{__name__}:COMPRESSION_LEVEL"]
-
-# Kept because ufo2ft depends on it, to be removed once ufo2ft uses the config instead
-# https://github.com/fonttools/fonttools/issues/2592
-GPOS_COMPACT_MODE_ENV_KEY = "FONTTOOLS_GPOS_COMPACT_MODE"
-GPOS_COMPACT_MODE_DEFAULT = str(COMPRESSION_LEVEL.default)
-
-
-def _compression_level_from_env() -> int:
-    env_level = GPOS_COMPACT_MODE_DEFAULT
-    if GPOS_COMPACT_MODE_ENV_KEY in os.environ:
-        import warnings
-
-        warnings.warn(
-            f"'{GPOS_COMPACT_MODE_ENV_KEY}' environment variable is deprecated. "
-            "Please set the 'fontTools.otlLib.optimize.gpos:COMPRESSION_LEVEL' option "
-            "in TTFont.cfg.",
-            DeprecationWarning,
-        )
-
-        env_level = os.environ[GPOS_COMPACT_MODE_ENV_KEY]
-    if len(env_level) == 1 and env_level in "0123456789":
-        return int(env_level)
-    raise ValueError(f"Bad {GPOS_COMPACT_MODE_ENV_KEY}={env_level}")
-
-
-def compact(font: TTFont, level: int) -> TTFont:
-    # Ideal plan:
-    #  1. Find lookups of Lookup Type 2: Pair Adjustment Positioning Subtable
-    #     https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#lookup-type-2-pair-adjustment-positioning-subtable
-    #  2. Extract glyph-glyph kerning and class-kerning from all present subtables
-    #  3. Regroup into different subtable arrangements
-    #  4. Put back into the lookup
-    #
-    # Actual implementation:
-    #  2. Only class kerning is optimized currently
-    #  3. If the input kerning is already in several subtables, the subtables
-    #     are not grouped together first; instead each subtable is treated
-    #     independently, so currently this step is:
-    #     Split existing subtables into more smaller subtables
-    gpos = font["GPOS"]
-    for lookup in gpos.table.LookupList.Lookup:
-        if lookup.LookupType == 2:
-            compact_lookup(font, level, lookup)
-        elif lookup.LookupType == 9 and lookup.SubTable[0].ExtensionLookupType == 2:
-            compact_ext_lookup(font, level, lookup)
-    return font
-
-
-def compact_lookup(font: TTFont, level: int, lookup: otTables.Lookup) -> None:
-    new_subtables = compact_pair_pos(font, level, lookup.SubTable)
-    lookup.SubTable = new_subtables
-    lookup.SubTableCount = len(new_subtables)
-
-
-def compact_ext_lookup(font: TTFont, level: int, lookup: otTables.Lookup) -> None:
-    new_subtables = compact_pair_pos(
-        font, level, [ext_subtable.ExtSubTable for ext_subtable in lookup.SubTable]
-    )
-    new_ext_subtables = []
-    for subtable in new_subtables:
-        ext_subtable = otTables.ExtensionPos()
-        ext_subtable.Format = 1
-        ext_subtable.ExtSubTable = subtable
-        new_ext_subtables.append(ext_subtable)
-    lookup.SubTable = new_ext_subtables
-    lookup.SubTableCount = len(new_ext_subtables)
-
-
-def compact_pair_pos(
-    font: TTFont, level: int, subtables: Sequence[otTables.PairPos]
-) -> Sequence[otTables.PairPos]:
-    new_subtables = []
-    for subtable in subtables:
-        if subtable.Format == 1:
-            # Not doing anything to Format 1 (yet?)
-            new_subtables.append(subtable)
-        elif subtable.Format == 2:
-            new_subtables.extend(compact_class_pairs(font, level, subtable))
-    return new_subtables
-
-
-def compact_class_pairs(
-    font: TTFont, level: int, subtable: otTables.PairPos
-) -> List[otTables.PairPos]:
-    from fontTools.otlLib.builder import buildPairPosClassesSubtable
-
-    subtables = []
-    classes1: DefaultDict[int, List[str]] = defaultdict(list)
-    for g in subtable.Coverage.glyphs:
-        classes1[subtable.ClassDef1.classDefs.get(g, 0)].append(g)
-    classes2: DefaultDict[int, List[str]] = defaultdict(list)
-    for g, i in subtable.ClassDef2.classDefs.items():
-        classes2[i].append(g)
-    all_pairs = {}
-    for i, class1 in enumerate(subtable.Class1Record):
-        for j, class2 in enumerate(class1.Class2Record):
-            if is_really_zero(class2):
-                continue
-            all_pairs[(tuple(sorted(classes1[i])), tuple(sorted(classes2[j])))] = (
-                getattr(class2, "Value1", None),
-                getattr(class2, "Value2", None),
-            )
-    grouped_pairs = cluster_pairs_by_class2_coverage_custom_cost(font, all_pairs, level)
-    for pairs in grouped_pairs:
-        subtables.append(buildPairPosClassesSubtable(pairs, font.getReverseGlyphMap()))
-    return subtables
-
-
-def is_really_zero(class2: otTables.Class2Record) -> bool:
-    v1 = getattr(class2, "Value1", None)
-    v2 = getattr(class2, "Value2", None)
-    return (v1 is None or v1.getEffectiveFormat() == 0) and (
-        v2 is None or v2.getEffectiveFormat() == 0
-    )
-
-
-Pairs = Dict[
-    Tuple[Tuple[str, ...], Tuple[str, ...]],
-    Tuple[otBase.ValueRecord, otBase.ValueRecord],
-]
-
-# Adapted from https://github.com/fonttools/fonttools/blob/f64f0b42f2d1163b2d85194e0979def539f5dca3/Lib/fontTools/ttLib/tables/otTables.py#L935-L958
-def _getClassRanges(glyphIDs: Iterable[int]):
-    glyphIDs = sorted(glyphIDs)
-    last = glyphIDs[0]
-    ranges = [[last]]
-    for glyphID in glyphIDs[1:]:
-        if glyphID != last + 1:
-            ranges[-1].append(last)
-            ranges.append([glyphID])
-        last = glyphID
-    ranges[-1].append(last)
-    return ranges, glyphIDs[0], glyphIDs[-1]
-
-
-# Adapted from https://github.com/fonttools/fonttools/blob/f64f0b42f2d1163b2d85194e0979def539f5dca3/Lib/fontTools/ttLib/tables/otTables.py#L960-L989
-def _classDef_bytes(
-    class_data: List[Tuple[List[Tuple[int, int]], int, int]],
-    class_ids: List[int],
-    coverage=False,
-):
-    if not class_ids:
-        return 0
-    first_ranges, min_glyph_id, max_glyph_id = class_data[class_ids[0]]
-    range_count = len(first_ranges)
-    for i in class_ids[1:]:
-        data = class_data[i]
-        range_count += len(data[0])
-        min_glyph_id = min(min_glyph_id, data[1])
-        max_glyph_id = max(max_glyph_id, data[2])
-    glyphCount = max_glyph_id - min_glyph_id + 1
-    # https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-1
-    format1_bytes = 6 + glyphCount * 2
-    # https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-2
-    format2_bytes = 4 + range_count * 6
-    return min(format1_bytes, format2_bytes)
-
-
-ClusteringContext = namedtuple(
-    "ClusteringContext",
-    [
-        "lines",
-        "all_class1",
-        "all_class1_data",
-        "all_class2_data",
-        "valueFormat1_bytes",
-        "valueFormat2_bytes",
-    ],
-)
-
-
-class Cluster:
-    # TODO(Python 3.7): Turn this into a dataclass
-    # ctx: ClusteringContext
-    # indices: int
-    # Caches
-    # TODO(Python 3.8): use functools.cached_property instead of the
-    # manually cached properties, and remove the cache fields listed below.
-    # _indices: Optional[List[int]] = None
-    # _column_indices: Optional[List[int]] = None
-    # _cost: Optional[int] = None
-
-    __slots__ = "ctx", "indices_bitmask", "_indices", "_column_indices", "_cost"
-
-    def __init__(self, ctx: ClusteringContext, indices_bitmask: int):
-        self.ctx = ctx
-        self.indices_bitmask = indices_bitmask
-        self._indices = None
-        self._column_indices = None
-        self._cost = None
-
-    @property
-    def indices(self):
-        if self._indices is None:
-            self._indices = bit_indices(self.indices_bitmask)
-        return self._indices
-
-    @property
-    def column_indices(self):
-        if self._column_indices is None:
-            # Indices of columns that have a 1 in at least 1 line
-            #   => binary OR all the lines
-            bitmask = reduce(int.__or__, (self.ctx.lines[i] for i in self.indices))
-            self._column_indices = bit_indices(bitmask)
-        return self._column_indices
-
-    @property
-    def width(self):
-        # Add 1 because Class2=0 cannot be used but needs to be encoded.
-        return len(self.column_indices) + 1
-
-    @property
-    def cost(self):
-        if self._cost is None:
-            self._cost = (
-                # 2 bytes to store the offset to this subtable in the Lookup table above
-                2
-                # Contents of the subtable
-                # From: https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#pair-adjustment-positioning-format-2-class-pair-adjustment
-                # uint16	posFormat	Format identifier: format = 2
-                + 2
-                # Offset16	coverageOffset	Offset to Coverage table, from beginning of PairPos subtable.
-                + 2
-                + self.coverage_bytes
-                # uint16	valueFormat1	ValueRecord definition — for the first glyph of the pair (may be zero).
-                + 2
-                # uint16	valueFormat2	ValueRecord definition — for the second glyph of the pair (may be zero).
-                + 2
-                # Offset16	classDef1Offset	Offset to ClassDef table, from beginning of PairPos subtable — for the first glyph of the pair.
-                + 2
-                + self.classDef1_bytes
-                # Offset16	classDef2Offset	Offset to ClassDef table, from beginning of PairPos subtable — for the second glyph of the pair.
-                + 2
-                + self.classDef2_bytes
-                # uint16	class1Count	Number of classes in classDef1 table — includes Class 0.
-                + 2
-                # uint16	class2Count	Number of classes in classDef2 table — includes Class 0.
-                + 2
-                # Class1Record	class1Records[class1Count]	Array of Class1 records, ordered by classes in classDef1.
-                + (self.ctx.valueFormat1_bytes + self.ctx.valueFormat2_bytes)
-                * len(self.indices)
-                * self.width
-            )
-        return self._cost
-
-    @property
-    def coverage_bytes(self):
-        format1_bytes = (
-            # From https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-format-1
-            # uint16	coverageFormat	Format identifier — format = 1
-            # uint16	glyphCount	Number of glyphs in the glyph array
-            4
-            # uint16	glyphArray[glyphCount]	Array of glyph IDs — in numerical order
-            + sum(len(self.ctx.all_class1[i]) for i in self.indices) * 2
-        )
-        ranges = sorted(
-            chain.from_iterable(self.ctx.all_class1_data[i][0] for i in self.indices)
-        )
-        merged_range_count = 0
-        last = None
-        for (start, end) in ranges:
-            if last is not None and start != last + 1:
-                merged_range_count += 1
-            last = end
-        format2_bytes = (
-            # From https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-format-2
-            # uint16	coverageFormat	Format identifier — format = 2
-            # uint16	rangeCount	Number of RangeRecords
-            4
-            # RangeRecord	rangeRecords[rangeCount]	Array of glyph ranges — ordered by startGlyphID.
-            # uint16	startGlyphID	First glyph ID in the range
-            # uint16	endGlyphID	Last glyph ID in the range
-            # uint16	startCoverageIndex	Coverage Index of first glyph ID in range
-            + merged_range_count * 6
-        )
-        return min(format1_bytes, format2_bytes)
-
-    @property
-    def classDef1_bytes(self):
-        # We can skip encoding one of the Class1 definitions, and use
-        # Class1=0 to represent it instead, because Class1 is gated by the
-        # Coverage definition. Use Class1=0 for the highest byte savings.
-        # Going through all options takes too long, pick the biggest class
-        # = what happens in otlLib.builder.ClassDefBuilder.classes()
-        biggest_index = max(self.indices, key=lambda i: len(self.ctx.all_class1[i]))
-        return _classDef_bytes(
-            self.ctx.all_class1_data, [i for i in self.indices if i != biggest_index]
-        )
-
-    @property
-    def classDef2_bytes(self):
-        # All Class2 need to be encoded because we can't use Class2=0
-        return _classDef_bytes(self.ctx.all_class2_data, self.column_indices)
-
-
-def cluster_pairs_by_class2_coverage_custom_cost(
-    font: TTFont,
-    pairs: Pairs,
-    compression: int = 5,
-) -> List[Pairs]:
-    if not pairs:
-        # The subtable was actually empty?
-        return [pairs]
-
-    # Sorted for reproducibility/determinism
-    all_class1 = sorted(set(pair[0] for pair in pairs))
-    all_class2 = sorted(set(pair[1] for pair in pairs))
-
-    # Use Python's big ints for binary vectors representing each line
-    lines = [
-        sum(
-            1 << i if (class1, class2) in pairs else 0
-            for i, class2 in enumerate(all_class2)
-        )
-        for class1 in all_class1
-    ]
-
-    # Map glyph names to ids and work with ints throughout for ClassDef formats
-    name_to_id = font.getReverseGlyphMap()
-    # Each entry in the arrays below is (range_count, min_glyph_id, max_glyph_id)
-    all_class1_data = [
-        _getClassRanges(name_to_id[name] for name in cls) for cls in all_class1
-    ]
-    all_class2_data = [
-        _getClassRanges(name_to_id[name] for name in cls) for cls in all_class2
-    ]
-
-    format1 = 0
-    format2 = 0
-    for pair, value in pairs.items():
-        format1 |= value[0].getEffectiveFormat() if value[0] else 0
-        format2 |= value[1].getEffectiveFormat() if value[1] else 0
-    valueFormat1_bytes = bit_count(format1) * 2
-    valueFormat2_bytes = bit_count(format2) * 2
-
-    ctx = ClusteringContext(
-        lines,
-        all_class1,
-        all_class1_data,
-        all_class2_data,
-        valueFormat1_bytes,
-        valueFormat2_bytes,
-    )
-
-    cluster_cache: Dict[int, Cluster] = {}
-
-    def make_cluster(indices: int) -> Cluster:
-        cluster = cluster_cache.get(indices, None)
-        if cluster is not None:
-            return cluster
-        cluster = Cluster(ctx, indices)
-        cluster_cache[indices] = cluster
-        return cluster
-
-    def merge(cluster: Cluster, other: Cluster) -> Cluster:
-        return make_cluster(cluster.indices_bitmask | other.indices_bitmask)
-
-    # Agglomerative clustering by hand, checking the cost gain of the new
-    # cluster against the previously separate clusters
-    # Start with 1 cluster per line
-    # cluster = set of lines = new subtable
-    clusters = [make_cluster(1 << i) for i in range(len(lines))]
-
-    # Cost of 1 cluster with everything
-    # `(1 << len) - 1` gives a bitmask full of 1's of length `len`
-    cost_before_splitting = make_cluster((1 << len(lines)) - 1).cost
-    log.debug(f"        len(clusters) = {len(clusters)}")
-
-    while len(clusters) > 1:
-        lowest_cost_change = None
-        best_cluster_index = None
-        best_other_index = None
-        best_merged = None
-        for i, cluster in enumerate(clusters):
-            for j, other in enumerate(clusters[i + 1 :]):
-                merged = merge(cluster, other)
-                cost_change = merged.cost - cluster.cost - other.cost
-                if lowest_cost_change is None or cost_change < lowest_cost_change:
-                    lowest_cost_change = cost_change
-                    best_cluster_index = i
-                    best_other_index = i + 1 + j
-                    best_merged = merged
-        assert lowest_cost_change is not None
-        assert best_cluster_index is not None
-        assert best_other_index is not None
-        assert best_merged is not None
-
-        # If the best merge we found is still taking down the file size, then
-        # there's no question: we must do it, because it's beneficial in both
-        # ways (lower file size and lower number of subtables).  However, if the
-        # best merge we found is not reducing file size anymore, then we need to
-        # look at the other stop criteria = the compression factor.
-        if lowest_cost_change > 0:
-            # Stop critera: check whether we should keep merging.
-            # Compute size reduction brought by splitting
-            cost_after_splitting = sum(c.cost for c in clusters)
-            # size_reduction so that after = before * (1 - size_reduction)
-            # E.g. before = 1000, after = 800, 1 - 800/1000 = 0.2
-            size_reduction = 1 - cost_after_splitting / cost_before_splitting
-
-            # Force more merging by taking into account the compression number.
-            # Target behaviour: compression number = 1 to 9, default 5 like gzip
-            #   - 1 = accept to add 1 subtable to reduce size by 50%
-            #   - 5 = accept to add 5 subtables to reduce size by 50%
-            # See https://github.com/harfbuzz/packtab/blob/master/Lib/packTab/__init__.py#L690-L691
-            # Given the size reduction we have achieved so far, compute how many
-            # new subtables are acceptable.
-            max_new_subtables = -log2(1 - size_reduction) * compression
-            log.debug(
-                f"            len(clusters) = {len(clusters):3d}    size_reduction={size_reduction:5.2f}    max_new_subtables={max_new_subtables}",
-            )
-            if compression == 9:
-                # Override level 9 to mean: create any number of subtables
-                max_new_subtables = len(clusters)
-
-            # If we have managed to take the number of new subtables below the
-            # threshold, then we can stop.
-            if len(clusters) <= max_new_subtables + 1:
-                break
-
-        # No reason to stop yet, do the merge and move on to the next.
-        del clusters[best_other_index]
-        clusters[best_cluster_index] = best_merged
-
-    # All clusters are final; turn bitmasks back into the "Pairs" format
-    pairs_by_class1: Dict[Tuple[str, ...], Pairs] = defaultdict(dict)
-    for pair, values in pairs.items():
-        pairs_by_class1[pair[0]][pair] = values
-    pairs_groups: List[Pairs] = []
-    for cluster in clusters:
-        pairs_group: Pairs = dict()
-        for i in cluster.indices:
-            class1 = all_class1[i]
-            pairs_group.update(pairs_by_class1[class1])
-        pairs_groups.append(pairs_group)
-    return pairs_groups

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttx.py

@@ -1,469 +0,0 @@
-"""\
-usage: ttx [options] inputfile1 [... inputfileN]
-
-TTX -- From OpenType To XML And Back
-
-If an input file is a TrueType or OpenType font file, it will be
-decompiled to a TTX file (an XML-based text format).
-If an input file is a TTX file, it will be compiled to whatever
-format the data is in, a TrueType or OpenType/CFF font file.
-A special input value of - means read from the standard input.
-
-Output files are created so they are unique: an existing file is
-never overwritten.
-
-General options
-===============
-
--h Help            print this message.
---version          show version and exit.
--d <outputfolder>  Specify a directory where the output files are
-                   to be created.
--o <outputfile>    Specify a file to write the output to. A special
-                   value of - would use the standard output.
--f                 Overwrite existing output file(s), ie. don't append
-                   numbers.
--v                 Verbose: more messages will be written to stdout
-                   about what is being done.
--q                 Quiet: No messages will be written to stdout about
-                   what is being done.
--a                 allow virtual glyphs ID's on compile or decompile.
-
-Dump options
-============
-
--l           List table info: instead of dumping to a TTX file, list
-             some minimal info about each table.
--t <table>   Specify a table to dump. Multiple -t options
-             are allowed. When no -t option is specified, all tables
-             will be dumped.
--x <table>   Specify a table to exclude from the dump. Multiple
-             -x options are allowed. -t and -x are mutually exclusive.
--s           Split tables: save the TTX data into separate TTX files per
-             table and write one small TTX file that contains references
-             to the individual table dumps. This file can be used as
-             input to ttx, as long as the table files are in the
-             same directory.
--g           Split glyf table: Save the glyf data into separate TTX files
-             per glyph and write a small TTX for the glyf table which
-             contains references to the individual TTGlyph elements.
-             NOTE: specifying -g implies -s (no need for -s together
-             with -g)
--i           Do NOT disassemble TT instructions: when this option is
-             given, all TrueType programs (glyph programs, the font
-             program and the pre-program) will be written to the TTX
-             file as hex data instead of assembly. This saves some time
-             and makes the TTX file smaller.
--z <format>  Specify a bitmap data export option for EBDT:
-             {'raw', 'row', 'bitwise', 'extfile'} or for the CBDT:
-             {'raw', 'extfile'} Each option does one of the following:
-
-             -z raw
-               export the bitmap data as a hex dump
-             -z row
-               export each row as hex data
-             -z bitwise
-               export each row as binary in an ASCII art style
-             -z extfile
-               export the data as external files with XML references
-
-             If no export format is specified 'raw' format is used.
--e           Don't ignore decompilation errors, but show a full traceback
-             and abort.
--y <number>  Select font number for TrueType Collection (.ttc/.otc),
-             starting from 0.
---unicodedata <UnicodeData.txt>
-             Use custom database file to write character names in the
-             comments of the cmap TTX output.
---newline <value>
-             Control how line endings are written in the XML file. It
-             can be 'LF', 'CR', or 'CRLF'. If not specified, the
-             default platform-specific line endings are used.
-
-Compile options
-===============
-
--m           Merge with TrueType-input-file: specify a TrueType or
-             OpenType font file to be merged with the TTX file. This
-             option is only valid when at most one TTX file is specified.
--b           Don't recalc glyph bounding boxes: use the values in the
-             TTX file as-is.
---recalc-timestamp
-             Set font 'modified' timestamp to current time.
-             By default, the modification time of the TTX file will be
-             used.
---no-recalc-timestamp
-             Keep the original font 'modified' timestamp.
---flavor <type>
-             Specify flavor of output font file. May be 'woff' or 'woff2'.
-             Note that WOFF2 requires the Brotli Python extension,
-             available at https://github.com/google/brotli
---with-zopfli
-             Use Zopfli instead of Zlib to compress WOFF. The Python
-             extension is available at https://pypi.python.org/pypi/zopfli
-"""
-
-
-from fontTools.ttLib import TTFont, TTLibError
-from fontTools.misc.macCreatorType import getMacCreatorAndType
-from fontTools.unicode import setUnicodeData
-from fontTools.misc.textTools import Tag, tostr
-from fontTools.misc.timeTools import timestampSinceEpoch
-from fontTools.misc.loggingTools import Timer
-from fontTools.misc.cliTools import makeOutputFileName
-import os
-import sys
-import getopt
-import re
-import logging
-
-
-log = logging.getLogger("fontTools.ttx")
-
-opentypeheaderRE = re.compile("""sfntVersion=['"]OTTO["']""")
-
-
-class Options(object):
-
-    listTables = False
-    outputDir = None
-    outputFile = None
-    overWrite = False
-    verbose = False
-    quiet = False
-    splitTables = False
-    splitGlyphs = False
-    disassembleInstructions = True
-    mergeFile = None
-    recalcBBoxes = True
-    ignoreDecompileErrors = True
-    bitmapGlyphDataFormat = "raw"
-    unicodedata = None
-    newlinestr = "\n"
-    recalcTimestamp = None
-    flavor = None
-    useZopfli = False
-
-    def __init__(self, rawOptions, numFiles):
-        self.onlyTables = []
-        self.skipTables = []
-        self.fontNumber = -1
-        for option, value in rawOptions:
-            # general options
-            if option == "-h":
-                print(__doc__)
-                sys.exit(0)
-            elif option == "--version":
-                from fontTools import version
-
-                print(version)
-                sys.exit(0)
-            elif option == "-d":
-                if not os.path.isdir(value):
-                    raise getopt.GetoptError(
-                        "The -d option value must be an existing directory"
-                    )
-                self.outputDir = value
-            elif option == "-o":
-                self.outputFile = value
-            elif option == "-f":
-                self.overWrite = True
-            elif option == "-v":
-                self.verbose = True
-            elif option == "-q":
-                self.quiet = True
-            # dump options
-            elif option == "-l":
-                self.listTables = True
-            elif option == "-t":
-                # pad with space if table tag length is less than 4
-                value = value.ljust(4)
-                self.onlyTables.append(value)
-            elif option == "-x":
-                # pad with space if table tag length is less than 4
-                value = value.ljust(4)
-                self.skipTables.append(value)
-            elif option == "-s":
-                self.splitTables = True
-            elif option == "-g":
-                # -g implies (and forces) splitTables
-                self.splitGlyphs = True
-                self.splitTables = True
-            elif option == "-i":
-                self.disassembleInstructions = False
-            elif option == "-z":
-                validOptions = ("raw", "row", "bitwise", "extfile")
-                if value not in validOptions:
-                    raise getopt.GetoptError(
-                        "-z does not allow %s as a format. Use %s"
-                        % (option, validOptions)
-                    )
-                self.bitmapGlyphDataFormat = value
-            elif option == "-y":
-                self.fontNumber = int(value)
-            # compile options
-            elif option == "-m":
-                self.mergeFile = value
-            elif option == "-b":
-                self.recalcBBoxes = False
-            elif option == "-e":
-                self.ignoreDecompileErrors = False
-            elif option == "--unicodedata":
-                self.unicodedata = value
-            elif option == "--newline":
-                validOptions = ("LF", "CR", "CRLF")
-                if value == "LF":
-                    self.newlinestr = "\n"
-                elif value == "CR":
-                    self.newlinestr = "\r"
-                elif value == "CRLF":
-                    self.newlinestr = "\r\n"
-                else:
-                    raise getopt.GetoptError(
-                        "Invalid choice for --newline: %r (choose from %s)"
-                        % (value, ", ".join(map(repr, validOptions)))
-                    )
-            elif option == "--recalc-timestamp":
-                self.recalcTimestamp = True
-            elif option == "--no-recalc-timestamp":
-                self.recalcTimestamp = False
-            elif option == "--flavor":
-                self.flavor = value
-            elif option == "--with-zopfli":
-                self.useZopfli = True
-        if self.verbose and self.quiet:
-            raise getopt.GetoptError("-q and -v options are mutually exclusive")
-        if self.verbose:
-            self.logLevel = logging.DEBUG
-        elif self.quiet:
-            self.logLevel = logging.WARNING
-        else:
-            self.logLevel = logging.INFO
-        if self.mergeFile and self.flavor:
-            raise getopt.GetoptError("-m and --flavor options are mutually exclusive")
-        if self.onlyTables and self.skipTables:
-            raise getopt.GetoptError("-t and -x options are mutually exclusive")
-        if self.mergeFile and numFiles > 1:
-            raise getopt.GetoptError(
-                "Must specify exactly one TTX source file when using -m"
-            )
-        if self.flavor != "woff" and self.useZopfli:
-            raise getopt.GetoptError("--with-zopfli option requires --flavor 'woff'")
-
-
-def ttList(input, output, options):
-    ttf = TTFont(input, fontNumber=options.fontNumber, lazy=True)
-    reader = ttf.reader
-    tags = sorted(reader.keys())
-    print('Listing table info for "%s":' % input)
-    format = "    %4s  %10s  %8s  %8s"
-    print(format % ("tag ", "  checksum", "  length", "  offset"))
-    print(format % ("----", "----------", "--------", "--------"))
-    for tag in tags:
-        entry = reader.tables[tag]
-        if ttf.flavor == "woff2":
-            # WOFF2 doesn't store table checksums, so they must be calculated
-            from fontTools.ttLib.sfnt import calcChecksum
-
-            data = entry.loadData(reader.transformBuffer)
-            checkSum = calcChecksum(data)
-        else:
-            checkSum = int(entry.checkSum)
-        if checkSum < 0:
-            checkSum = checkSum + 0x100000000
-        checksum = "0x%08X" % checkSum
-        print(format % (tag, checksum, entry.length, entry.offset))
-    print()
-    ttf.close()
-
-
-@Timer(log, "Done dumping TTX in %(time).3f seconds")
-def ttDump(input, output, options):
-    input_name = input
-    if input == "-":
-        input, input_name = sys.stdin.buffer, sys.stdin.name
-    output_name = output
-    if output == "-":
-        output, output_name = sys.stdout, sys.stdout.name
-    log.info('Dumping "%s" to "%s"...', input_name, output_name)
-    if options.unicodedata:
-        setUnicodeData(options.unicodedata)
-    ttf = TTFont(
-        input,
-        0,
-        ignoreDecompileErrors=options.ignoreDecompileErrors,
-        fontNumber=options.fontNumber,
-    )
-    ttf.saveXML(
-        output,
-        tables=options.onlyTables,
-        skipTables=options.skipTables,
-        splitTables=options.splitTables,
-        splitGlyphs=options.splitGlyphs,
-        disassembleInstructions=options.disassembleInstructions,
-        bitmapGlyphDataFormat=options.bitmapGlyphDataFormat,
-        newlinestr=options.newlinestr,
-    )
-    ttf.close()
-
-
-@Timer(log, "Done compiling TTX in %(time).3f seconds")
-def ttCompile(input, output, options):
-    input_name = input
-    if input == "-":
-        input, input_name = sys.stdin, sys.stdin.name
-    output_name = output
-    if output == "-":
-        output, output_name = sys.stdout.buffer, sys.stdout.name
-    log.info('Compiling "%s" to "%s"...' % (input_name, output))
-    if options.useZopfli:
-        from fontTools.ttLib import sfnt
-
-        sfnt.USE_ZOPFLI = True
-    ttf = TTFont(
-        options.mergeFile,
-        flavor=options.flavor,
-        recalcBBoxes=options.recalcBBoxes,
-        recalcTimestamp=options.recalcTimestamp,
-    )
-    ttf.importXML(input)
-
-    if options.recalcTimestamp is None and "head" in ttf and input is not sys.stdin:
-        # use TTX file modification time for head "modified" timestamp
-        mtime = os.path.getmtime(input)
-        ttf["head"].modified = timestampSinceEpoch(mtime)
-
-    ttf.save(output)
-
-
-def guessFileType(fileName):
-    if fileName == "-":
-        header = sys.stdin.buffer.peek(256)
-        ext = ""
-    else:
-        base, ext = os.path.splitext(fileName)
-        try:
-            with open(fileName, "rb") as f:
-                header = f.read(256)
-        except IOError:
-            return None
-
-    if header.startswith(b"\xef\xbb\xbf<?xml"):
-        header = header.lstrip(b"\xef\xbb\xbf")
-    cr, tp = getMacCreatorAndType(fileName)
-    if tp in ("sfnt", "FFIL"):
-        return "TTF"
-    if ext == ".dfont":
-        return "TTF"
-    head = Tag(header[:4])
-    if head == "OTTO":
-        return "OTF"
-    elif head == "ttcf":
-        return "TTC"
-    elif head in ("\0\1\0\0", "true"):
-        return "TTF"
-    elif head == "wOFF":
-        return "WOFF"
-    elif head == "wOF2":
-        return "WOFF2"
-    elif head == "<?xm":
-        # Use 'latin1' because that can't fail.
-        header = tostr(header, "latin1")
-        if opentypeheaderRE.search(header):
-            return "OTX"
-        else:
-            return "TTX"
-    return None
-
-
-def parseOptions(args):
-    rawOptions, files = getopt.getopt(
-        args,
-        "ld:o:fvqht:x:sgim:z:baey:",
-        [
-            "unicodedata=",
-            "recalc-timestamp",
-            "no-recalc-timestamp",
-            "flavor=",
-            "version",
-            "with-zopfli",
-            "newline=",
-        ],
-    )
-
-    options = Options(rawOptions, len(files))
-    jobs = []
-
-    if not files:
-        raise getopt.GetoptError("Must specify at least one input file")
-
-    for input in files:
-        if input != "-" and not os.path.isfile(input):
-            raise getopt.GetoptError('File not found: "%s"' % input)
-        tp = guessFileType(input)
-        if tp in ("OTF", "TTF", "TTC", "WOFF", "WOFF2"):
-            extension = ".ttx"
-            if options.listTables:
-                action = ttList
-            else:
-                action = ttDump
-        elif tp == "TTX":
-            extension = "." + options.flavor if options.flavor else ".ttf"
-            action = ttCompile
-        elif tp == "OTX":
-            extension = "." + options.flavor if options.flavor else ".otf"
-            action = ttCompile
-        else:
-            raise getopt.GetoptError('Unknown file type: "%s"' % input)
-
-        if options.outputFile:
-            output = options.outputFile
-        else:
-            if input == "-":
-                raise getopt.GetoptError("Must provide -o when reading from stdin")
-            output = makeOutputFileName(
-                input, options.outputDir, extension, options.overWrite
-            )
-            # 'touch' output file to avoid race condition in choosing file names
-            if action != ttList:
-                open(output, "a").close()
-        jobs.append((action, input, output))
-    return jobs, options
-
-
-def process(jobs, options):
-    for action, input, output in jobs:
-        action(input, output, options)
-
-
-def main(args=None):
-    """Convert OpenType fonts to XML and back"""
-    from fontTools import configLogger
-
-    if args is None:
-        args = sys.argv[1:]
-    try:
-        jobs, options = parseOptions(args)
-    except getopt.GetoptError as e:
-        print("%s\nERROR: %s" % (__doc__, e), file=sys.stderr)
-        sys.exit(2)
-
-    configLogger(level=options.logLevel)
-
-    try:
-        process(jobs, options)
-    except KeyboardInterrupt:
-        log.error("(Cancelled.)")
-        sys.exit(1)
-    except SystemExit:
-        raise
-    except TTLibError as e:
-        log.error(e)
-        sys.exit(1)
-    except:
-        log.exception("Unhandled exception has occurred")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    sys.exit(main())

spaces/DaleChen/AutoGPT/Dockerfile

@@ -1,38 +0,0 @@
-# Use an official Python base image from the Docker Hub
-FROM python:3.10-slim
-
-# Install git
-RUN apt-get -y update
-RUN apt-get -y install git chromium-driver
-
-# Install Xvfb and other dependencies for headless browser testing
-RUN apt-get update \
-    && apt-get install -y wget gnupg2 libgtk-3-0 libdbus-glib-1-2 dbus-x11 xvfb ca-certificates
-
-# Install Firefox / Chromium
-RUN wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - \
-    && echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google-chrome.list \
-    && apt-get update \
-    && apt-get install -y chromium firefox-esr
-
-# Set environment variables
-ENV PIP_NO_CACHE_DIR=yes \
-    PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1
-
-# Create a non-root user and set permissions
-RUN useradd --create-home appuser
-WORKDIR /home/appuser
-RUN chown appuser:appuser /home/appuser
-USER appuser
-
-# Copy the requirements.txt file and install the requirements
-COPY --chown=appuser:appuser requirements.txt .
-RUN sed -i '/Items below this point will not be included in the Docker Image/,$d' requirements.txt && \
-	pip install --no-cache-dir --user -r requirements.txt
-
-# Copy the application files
-COPY --chown=appuser:appuser autogpt/ ./autogpt
-
-# Set the entrypoint
-ENTRYPOINT ["python", "-m", "autogpt"]