Update parquet files (step 48 of 397)

spaces/1368565466ki/Satdia/models.py

@@ -1,533 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import modules
-import attentions
-import monotonic_align
-
-from torch.nn import Conv1d, ConvTranspose1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from commons import init_weights, get_padding
-
-
-class StochasticDurationPredictor(nn.Module):
-  def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0):
-    super().__init__()
-    filter_channels = in_channels # it needs to be removed from future version.
-    self.in_channels = in_channels
-    self.filter_channels = filter_channels
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-    self.n_flows = n_flows
-    self.gin_channels = gin_channels
-
-    self.log_flow = modules.Log()
-    self.flows = nn.ModuleList()
-    self.flows.append(modules.ElementwiseAffine(2))
-    for i in range(n_flows):
-      self.flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
-      self.flows.append(modules.Flip())
-
-    self.post_pre = nn.Conv1d(1, filter_channels, 1)
-    self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
-    self.post_convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
-    self.post_flows = nn.ModuleList()
-    self.post_flows.append(modules.ElementwiseAffine(2))
-    for i in range(4):
-      self.post_flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
-      self.post_flows.append(modules.Flip())
-
-    self.pre = nn.Conv1d(in_channels, filter_channels, 1)
-    self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
-    self.convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
-    if gin_channels != 0:
-      self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
-
-  def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
-    x = torch.detach(x)
-    x = self.pre(x)
-    if g is not None:
-      g = torch.detach(g)
-      x = x + self.cond(g)
-    x = self.convs(x, x_mask)
-    x = self.proj(x) * x_mask
-
-    if not reverse:
-      flows = self.flows
-      assert w is not None
-
-      logdet_tot_q = 0 
-      h_w = self.post_pre(w)
-      h_w = self.post_convs(h_w, x_mask)
-      h_w = self.post_proj(h_w) * x_mask
-      e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask
-      z_q = e_q
-      for flow in self.post_flows:
-        z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
-        logdet_tot_q += logdet_q
-      z_u, z1 = torch.split(z_q, [1, 1], 1) 
-      u = torch.sigmoid(z_u) * x_mask
-      z0 = (w - u) * x_mask
-      logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1,2])
-      logq = torch.sum(-0.5 * (math.log(2*math.pi) + (e_q**2)) * x_mask, [1,2]) - logdet_tot_q
-
-      logdet_tot = 0
-      z0, logdet = self.log_flow(z0, x_mask)
-      logdet_tot += logdet
-      z = torch.cat([z0, z1], 1)
-      for flow in flows:
-        z, logdet = flow(z, x_mask, g=x, reverse=reverse)
-        logdet_tot = logdet_tot + logdet
-      nll = torch.sum(0.5 * (math.log(2*math.pi) + (z**2)) * x_mask, [1,2]) - logdet_tot
-      return nll + logq # [b]
-    else:
-      flows = list(reversed(self.flows))
-      flows = flows[:-2] + [flows[-1]] # remove a useless vflow
-      z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale
-      for flow in flows:
-        z = flow(z, x_mask, g=x, reverse=reverse)
-      z0, z1 = torch.split(z, [1, 1], 1)
-      logw = z0
-      return logw
-
-
-class DurationPredictor(nn.Module):
-  def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
-    super().__init__()
-
-    self.in_channels = in_channels
-    self.filter_channels = filter_channels
-    self.kernel_size = kernel_size
-    self.p_dropout = p_dropout
-    self.gin_channels = gin_channels
-
-    self.drop = nn.Dropout(p_dropout)
-    self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size//2)
-    self.norm_1 = modules.LayerNorm(filter_channels)
-    self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
-    self.norm_2 = modules.LayerNorm(filter_channels)
-    self.proj = nn.Conv1d(filter_channels, 1, 1)
-
-    if gin_channels != 0:
-      self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
-  def forward(self, x, x_mask, g=None):
-    x = torch.detach(x)
-    if g is not None:
-      g = torch.detach(g)
-      x = x + self.cond(g)
-    x = self.conv_1(x * x_mask)
-    x = torch.relu(x)
-    x = self.norm_1(x)
-    x = self.drop(x)
-    x = self.conv_2(x * x_mask)
-    x = torch.relu(x)
-    x = self.norm_2(x)
-    x = self.drop(x)
-    x = self.proj(x * x_mask)
-    return x * x_mask
-
-
-class TextEncoder(nn.Module):
-  def __init__(self,
-      n_vocab,
-      out_channels,
-      hidden_channels,
-      filter_channels,
-      n_heads,
-      n_layers,
-      kernel_size,
-      p_dropout):
-    super().__init__()
-    self.n_vocab = n_vocab
-    self.out_channels = out_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.emb = nn.Embedding(n_vocab, hidden_channels)
-    nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5)
-
-    self.encoder = attentions.Encoder(
-      hidden_channels,
-      filter_channels,
-      n_heads,
-      n_layers,
-      kernel_size,
-      p_dropout)
-    self.proj= nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-  def forward(self, x, x_lengths):
-    x = self.emb(x) * math.sqrt(self.hidden_channels) # [b, t, h]
-    x = torch.transpose(x, 1, -1) # [b, h, t]
-    x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
-    x = self.encoder(x * x_mask, x_mask)
-    stats = self.proj(x) * x_mask
-
-    m, logs = torch.split(stats, self.out_channels, dim=1)
-    return x, m, logs, x_mask
-
-
-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 PosteriorEncoder(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 SynthesizerTrn(nn.Module):
-  """
-  Synthesizer for Training
-  """
-
-  def __init__(self, 
-    n_vocab,
-    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,
-    n_speakers=0,
-    gin_channels=0,
-    use_sdp=True,
-    **kwargs):
-
-    super().__init__()
-    self.n_vocab = n_vocab
-    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.n_speakers = n_speakers
-    self.gin_channels = gin_channels
-
-    self.use_sdp = use_sdp
-
-    self.enc_p = TextEncoder(n_vocab,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout)
-    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 = PosteriorEncoder(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 use_sdp:
-      self.dp = StochasticDurationPredictor(hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels)
-    else:
-      self.dp = DurationPredictor(hidden_channels, 256, 3, 0.5, gin_channels=gin_channels)
-
-    if n_speakers > 1:
-      self.emb_g = nn.Embedding(n_speakers, gin_channels)
-
-  def forward(self, x, x_lengths, y, y_lengths, sid=None):
-
-    x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
-    if self.n_speakers > 0:
-      g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
-    else:
-      g = None
-
-    z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
-    z_p = self.flow(z, y_mask, g=g)
-
-    with torch.no_grad():
-      # negative cross-entropy
-      s_p_sq_r = torch.exp(-2 * logs_p) # [b, d, t]
-      neg_cent1 = torch.sum(-0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True) # [b, 1, t_s]
-      neg_cent2 = torch.matmul(-0.5 * (z_p ** 2).transpose(1, 2), s_p_sq_r) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
-      neg_cent3 = torch.matmul(z_p.transpose(1, 2), (m_p * s_p_sq_r)) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
-      neg_cent4 = torch.sum(-0.5 * (m_p ** 2) * s_p_sq_r, [1], keepdim=True) # [b, 1, t_s]
-      neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
-
-      attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
-      attn = monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1)).unsqueeze(1).detach()
-
-    w = attn.sum(2)
-    if self.use_sdp:
-      l_length = self.dp(x, x_mask, w, g=g)
-      l_length = l_length / torch.sum(x_mask)
-    else:
-      logw_ = torch.log(w + 1e-6) * x_mask
-      logw = self.dp(x, x_mask, g=g)
-      l_length = torch.sum((logw - logw_)**2, [1,2]) / torch.sum(x_mask) # for averaging 
-
-    # expand prior
-    m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
-    logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
-
-    z_slice, ids_slice = commons.rand_slice_segments(z, y_lengths, self.segment_size)
-    o = self.dec(z_slice, g=g)
-    return o, l_length, attn, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
-  def infer(self, x, x_lengths, sid=None, noise_scale=1, length_scale=1, noise_scale_w=1., max_len=None):
-    x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
-    if self.n_speakers > 0:
-      g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
-    else:
-      g = None
-
-    if self.use_sdp:
-      logw = self.dp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w)
-    else:
-      logw = self.dp(x, x_mask, g=g)
-    w = torch.exp(logw) * x_mask * length_scale
-    w_ceil = torch.ceil(w)
-    y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
-    y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(x_mask.dtype)
-    attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
-    attn = commons.generate_path(w_ceil, attn_mask)
-
-    m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
-    logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
-
-    z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
-    z = self.flow(z_p, y_mask, g=g, reverse=True)
-    o = self.dec((z * y_mask)[:,:,:max_len], g=g)
-    return o, attn, y_mask, (z, z_p, m_p, logs_p)
-
-  def voice_conversion(self, y, y_lengths, sid_src, sid_tgt):
-    assert self.n_speakers > 0, "n_speakers have to be larger than 0."
-    g_src = self.emb_g(sid_src).unsqueeze(-1)
-    g_tgt = self.emb_g(sid_tgt).unsqueeze(-1)
-    z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g_src)
-    z_p = self.flow(z, y_mask, g=g_src)
-    z_hat = self.flow(z_p, y_mask, g=g_tgt, reverse=True)
-    o_hat = self.dec(z_hat * y_mask, g=g_tgt)
-    return o_hat, y_mask, (z, z_p, z_hat)
-

spaces/1acneusushi/gradio-2dmoleculeeditor/data/4K Video Downloader Pro How to Download Videos in 4K Resolution or Any Other Quality You Want.md

@@ -1,32 +0,0 @@
-<br />
-<h1>4K Video Downloader Pro: How to Download High-Quality Videos for Free</h1>
-<p>If you are looking for a way to download high-quality videos from YouTube and other online platforms, you might be interested in 4K Video Downloader Pro. This is a software that allows you to download videos in 4K resolution or any other quality you want. You can also download audio, subtitles, playlists, channels, and more. In this article, we will show you how to use 4K Video Downloader Pro and what are the benefits of using it.</p>
-<h2>What is 4K Video Downloader Pro?</h2>
-<p>4K Video Downloader Pro is a software that lets you download videos from various online platforms, such as YouTube, Vimeo, Facebook, TikTok, Instagram, and more. You can choose the quality and format of the video you want to download, from 4K to 8K, MP4 to MKV, 3D to 360°. You can also download audio only, subtitles, annotations, thumbnails, and metadata. You can also download entire playlists and channels with one click.</p>
-<h2>4k video downloader pro</h2><br /><p><b><b>Download</b> &#9889; <a href="https://byltly.com/2uKwSb">https://byltly.com/2uKwSb</a></b></p><br /><br />
-<p>4K Video Downloader Pro is cross-platform and works on Windows, macOS, and Linux. It has a user-friendly interface and a simple workflow. You just need to copy the link of the video you want to download and paste it into the software. Then you can choose the settings you want and start the download. You can also use the smart mode feature to apply your preferred settings to all downloads.</p>
-<h2>How to use 4K Video Downloader Pro?</h2>
-<p>To use 4K Video Downloader Pro, you need to buy the software from the official website <a href="https://www.4kdownload.com/products/videodownloader/">https://www.4kdownload.com/products/videodownloader/</a>. You can choose between a personal license or a business license depending on your needs. You can also try the free version of the software with some limitations.</p>
-<p>Once you have the software, you can follow these steps to download videos:</p>
-<ol>
-<li>Launch 4K Video Downloader Pro and click on the paste link button.</li>
-<li>Copy the link of the video you want to download from your browser and paste it into the software.</li>
-<li>Select the quality and format of the video you want to download. You can also choose to download subtitles, audio only, or extra files.</li>
-<li>Click on the download button and wait for the process to finish.</li>
-<li>Enjoy your downloaded video on your device or player of choice.</li>
-</ol>
-<h2>What are the benefits of using 4K Video Downloader Pro?</h2>
-<p>Using 4K Video Downloader Pro has some advantages that make it worth buying. Here are some of them:</p>
-<ul>
-<li>You can download high-quality videos in 4K resolution or any other quality you want.</li>
-<li>You can download videos from various online platforms, not just YouTube.</li>
-<li>You can download audio only, subtitles, playlists, channels, and more.</li>
-<li>You can use smart mode to apply your preferred settings to all downloads.</li>
-<li>You can use proxy servers to bypass geo-restrictions and access blocked videos.</li>
-<li>You can enjoy fast and reliable downloads without ads or interruptions.</li>
-<li>You can support the developers of the software and get updates and support.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>4K Video Downloader Pro is a software that allows you to download high-quality videos from YouTube and other online platforms for free. It has a user-friendly interface and a simple workflow. It also offers various features and options that make it a versatile and powerful tool. If you are interested in using 4K Video Downloader Pro, you can buy it from the official website and start downloading your favorite videos.</p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Bosch Kts 200 Keygen Download.md

@@ -1,25 +0,0 @@
-<br />
-<h1>Bosch KTS 200: A Compact and Reliable System Tester for ECU Diagnosis</h1>
-<p>If you are looking for a fast and easy way to diagnose the control units of various vehicles, you might want to consider the Bosch KTS 200. This handheld device is designed to offer reliable vehicle identification, complete ECU diagnosis, instant test sequence with easy-to-understand guidance, full test depth and comprehensive diagnosis functions, high market coverage, and regular software updates.</p>
-<h2>bosch kts 200 keygen download</h2><br /><p><b><b>Download</b> &bull; <a href="https://byltly.com/2uKzyv">https://byltly.com/2uKzyv</a></b></p><br /><br />
-<p>The Bosch KTS 200 uses the ESI[Tronic] software, which provides access to a vast database of vehicle models and systems. You can easily connect the device to the vehicle's OBD socket and perform a quick scan or a detailed diagnosis. The device has a 3.5 inch colour display that shows clear and intuitive menus and graphics. You can also print or save the diagnosis results for further analysis or documentation.</p>
-<p>The Bosch KTS 200 is lightweight and compact, making it ideal for mobile use or small workshops. It has a robust and ergonomic design that can withstand harsh conditions. It also has a rechargeable battery that allows you to use it without external power supply. The device comes with a USB cable, an OBD adapter cable, a carrying case, and an instruction manual.</p>
-<p>With the Bosch KTS 200, you can perform ECU diagnosis on various systems such as engine, ABS, airbag, transmission, immobilizer, climate control, instrument cluster, and more. You can also read and erase fault codes, view live data and freeze frames, perform actuator tests and adaptations, reset service intervals, and calibrate sensors.</p>
-<p>The Bosch KTS 200 is compatible with most European, Asian, and American vehicles from 1996 onwards. It supports various protocols such as ISO 9141-2, ISO 14230 (KWP), ISO 15765 (CAN), SAE J1850 (PWM/VPW), and more. It also supports various languages such as English, German, French, Spanish, Italian, Portuguese, Turkish, Polish, and more.</p>
-<p>If you want to get the most out of your Bosch KTS 200, you can also subscribe to the ESI[Tronic] online service, which provides you with regular software updates, technical information, wiring diagrams, troubleshooting guides, service bulletins, and more.</p>
-<p>The Bosch KTS 200 is a powerful and versatile system tester that can help you diagnose and repair various vehicle systems with ease and accuracy. It is a great entry-level device that offers maximum performance at an affordable price. To order yours today or to find out more about its features and benefits, visit <a href="http://www.adesystems.co.uk/garage-equipment/kts-diagnostic-equipment/kts-dcu/25/kts-200">www.adesystems.co.uk</a> or call us at 01234 567890.</p>
-
-<h2>How to Use the Bosch KTS 200 for ECU Diagnosis</h2>
-<p>Using the Bosch KTS 200 for ECU diagnosis is simple and straightforward. Here are the steps you need to follow:</p>
-<ol>
-<li>Turn on the device and select the language and the vehicle type.</li>
-<li>Connect the device to the vehicle's OBD socket using the OBD adapter cable.</li>
-<li>Wait for the device to identify the vehicle and display the available systems.</li>
-<li>Select the system you want to diagnose and press OK.</li>
-<li>Select the diagnosis function you want to perform, such as fault memory, live data, actuator test, adaptation, or service reset.</li>
-<li>Follow the on-screen instructions and guidance to complete the diagnosis.</li>
-<li>View, print, or save the diagnosis results as needed.</li>
-</ol>
-<p>The Bosch KTS 200 also has a help function that provides you with useful information and tips on how to use the device and perform various diagnosis functions. You can access the help function by pressing the F1 key at any time.</p> cec2833e83<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Ansys 12.1 Free Download.md

@@ -1,6 +0,0 @@
-<h2>Ansys 12.1 Free Download</h2><br /><p><b><b>Download Zip</b> &#9734;&#9734;&#9734; <a href="https://imgfil.com/2uy0mg">https://imgfil.com/2uy0mg</a></b></p><br /><br />
-
-Authorama.com features a nice selection of free books written in HTML and XHTML, which basically means that they ... Tutorial 18 (Using the VOF Model): Updated for ANSYS FLUENT 12.1 ... ANSYS FLUENT 14.0 Tutorial Guide | | download. 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1phancelerku/anime-remove-background/Demon Slayer Episode 2 APK - The Next Chapter of the Epic Action Game for Android.md

@@ -1,109 +0,0 @@
-<br />
-<h1>Demon Slayer Game APK: How to Download and Play the Best Anime Games on Your Android Device</h1>
- <h2>Introduction</h2>
- <p>If you are a fan of anime and manga, you have probably heard of Demon Slayer, one of the most popular and acclaimed series in recent years. Demon Slayer follows the story of Tanjiro Kamado, a young boy who becomes a demon slayer after his family is killed by demons and his sister Nezuko is turned into one. Along with his friends and allies, Tanjiro embarks on a quest to find a way to cure Nezuko and defeat the powerful demon lord Muzan Kibutsuji.</p>
- <p>But did you know that you can also enjoy the thrilling adventures of Demon Slayer on your Android device? That's right, there are several Demon Slayer games that you can download and play on your smartphone or tablet, thanks to the APK files that are available online. APK files are application packages that allow you to install apps that are not available on the official Google Play Store. In this article, we will show you how to download and play two of the best Demon Slayer games on your Android device: The Hinokami Chronicles and Rage of Demon King.</p>
-<h2>demon slayer game apk</h2><br /><p><b><b>DOWNLOAD</b> &#9734;&#9734;&#9734; <a href="https://jinyurl.com/2uNP9N">https://jinyurl.com/2uNP9N</a></b></p><br /><br />
- <h2>Demon Slayer Game APK: The Hinokami Chronicles</h2>
- <h3>What is The Hinokami Chronicles?</h3>
- <p>The Hinokami Chronicles is the official game of the Demon Slayer anime, developed by CyberConnect2 and published by Sega. It is a spectacular arena fighter that lets you relive the memorable moments of the anime, from the "Tanjiro Kamado, Unwavering Resolve Arc" to the "Mugen Train Arc". You can also play as your favorite characters from the series, such as Tanjiro, Nezuko, Zenitsu, Inosuke, Giyu, Shinobu, and more.</p>
- <h3>How to download and install The Hinokami Chronicles APK?</h3>
- <p>The Hinokami Chronicles is available for Nintendo Switch, PlayStation 4, PlayStation 5, Xbox One, Xbox Series X/S, and Steam. However, if you want to play it on your Android device, you will need to download and install the APK file from a reliable source. Here are the steps to do so:</p>
- <ol>
-<li>Go to <a href="(^1^)">https://demonslayer-hinokami.sega.com/</a> and click on "Buy Now".</li>
-<li>Select "Steam" as your platform and click on "Buy Now" again.</li>
-<li>You will be redirected to the Steam page of the game. Click on "Add to Cart" and complete your purchase.</li>
-<li>After you have bought the game, go to <a href="(^2^)">https://www.apkcombo.com/search/demon-slayer-the-hinokami-chronicles/</a> and download the latest version of the APK file.</li>
-<li>Once you have downloaded the APK file, go to your device's settings and enable "Unknown Sources" under security options.</li>
-<li>Locate the APK file on your device's storage and tap on it to install it.</li>
-<li>Launch the game and enjoy!</li>
-</ol>
- <h3>What are the features and gameplay of The Hinokami Chronicles?</h3>
- <p>The Hinokami Chronicles is a game that will immerse you in the world of Demon Slayer with its stunning graphics, original voice cast, and faithful adaptation of the anime's story. You can play in two modes: Solo Mode and Versus Mode. In Solo Mode, you can experience the story of the anime from different perspectives, such as Tanjiro, Nezuko, and other demon slayers. You can also unlock new characters, costumes, and skills as you progress. In Versus Mode, you can battle against other players online or offline, using your favorite characters and their unique abilities. You can also customize your own avatar and fight in various stages inspired by the anime.</p>
- <p>The gameplay of The Hinokami Chronicles is fast-paced and exciting, as you can use various combos, special moves, and ultimate attacks to defeat your enemies. You can also activate the "Boost Mode" to unleash your full potential and turn the tide of the battle. The game also features a dynamic camera system that follows the action from different angles, making you feel like you are watching the anime.</p>
- <h2>Demon Slayer Game APK: Rage of Demon King</h2>
- <h3>What is Rage of Demon King?</h3>
- <p>Rage of Demon King is another game based on the Demon Slayer anime, developed by NetEase Games and published by Aniplex. It is a role-playing game that lets you create your own character and join the Demon Slayer Corps. You can also interact with the characters from the anime, such as Tanjiro, Nezuko, Zenitsu, Inosuke, and more.</p>
- <h3>How to download and install Rage of Demon King APK?</h3>
- <p>Rage of Demon King is available for iOS and Android devices. However, if you want to play it on your Android device, you will need to download and install the APK file from a reliable source. Here are the steps to do so:</p>
- <ol>
-<li>Go to <a href="">https://www.tap.io/app/214168</a> and click on "Download APK".</li>
-<li>You will be redirected to a page where you can choose a mirror site to download the APK file.</li>
-<li>Once you have downloaded the APK file, go to your device's settings and enable "Unknown Sources" under security options.</li>
-<li>Locate the APK file on your device's storage and tap on it to install it.</li>
-<li>Launch the game and enjoy!</li>
-</ol>
- <h3>What are the features and gameplay of Rage of Demon King?</h3>
- <p>Rage of Demon King is a game that will let you explore the world of Demon Slayer with its rich graphics, immersive sound effects, and original voice cast. You can play in three modes: Story Mode, Adventure Mode, and Battle Mode. In Story Mode, you can follow the plot of the anime and participate in various events and missions. You can also collect items, upgrade your equipment, and learn new skills. In Adventure Mode, you can explore different regions and encounter various demons and enemies. You can also team up with other players and cooperate in challenging quests. In Battle Mode, you can compete against other players in real-time battles, using your skills and strategies.</p>
- <p>The gameplay of Rage of Demon King is engaging and fun, as you can customize your character's appearance, personality, and fighting style. You can also choose from different classes, such as swordsman, archer, mage, or healer. You can also summon different companions to assist you in combat, such as Nezuko, Chuntaro, or Yushiro. The game also features a social system that allows you to chat with other players, join guilds, and make friends.</p>
-<p>demon slayer game apk download<br />
-demon slayer game apk mod<br />
-demon slayer game apk offline<br />
-demon slayer game apk free<br />
-demon slayer game apk android<br />
-demon slayer game apk latest version<br />
-demon slayer game apk obb<br />
-demon slayer game apk for pc<br />
-demon slayer game apk hack<br />
-demon slayer game apk unlimited money<br />
-demon slayer game apk english<br />
-demon slayer game apk full<br />
-demon slayer game apk online<br />
-demon slayer game apk data<br />
-demon slayer game apk 2023<br />
-demon slayer game apk update<br />
-demon slayer game apk no verification<br />
-demon slayer game apk revdl<br />
-demon slayer game apk rexdl<br />
-demon slayer game apk pure<br />
-demon slayer game apk uptodown<br />
-demon slayer game apk mirror<br />
-demon slayer game apk mob.org<br />
-demon slayer game apk highly compressed<br />
-demon slayer game apk 1.0.5<br />
-demon slayer game apk the hinokami chronicles<br />
-demon slayer game apk rage of demon king<br />
-demon slayer game apk infinity train<br />
-demon slayer game apk kimetsu no yaiba<br />
-demon slayer game apk tanjiro kamado<br />
-demon slayer game apk nezuko kamado<br />
-demon slayer game apk zenitsu agatsuma<br />
-demon slayer game apk inosuke hashibira<br />
-demon slayer game apk giyu tomioka<br />
-demon slayer game apk shinobu kocho<br />
-demon slayer game apk kyojuro rengoku<br />
-demon slayer game apk muzan kibutsuji<br />
-demon slayer game apk akaza<br />
-demon slayer game apk enmu<br />
-demon slayer game apk rui<br />
-demon slayer game apk sabito and makomo<br />
-demon slayer game apk sakonji urokodaki <br />
-demon slayer game apk kanao tsuyuri <br />
-demon slayer game apk tengen uzui <br />
-demon slayer game apk mitsuri kanroji <br />
-demon slayer game apk muichiro tokito <br />
-demon slayer game apk gyutaro <br />
-demon slayer game apk daki <br />
-demon slayer game apk hantengu <br />
-demon slayer game apk gyokko</p>
- <h2>Conclusion</h2>
- <h3>Summary of the main points</h3>
- <p>In this article, we have shown you how to download and play two of the best Demon Slayer games on your Android device: The Hinokami Chronicles and Rage of Demon King. These games are based on the popular anime series that follows the adventures of Tanjiro Kamado and his friends as they fight against demons and try to save his sister Nezuko. These games are both entertaining and faithful to the anime's story, characters, and style.</p>
- <h3>Call to action and final thoughts</h3>
- <p>If you are a fan of Demon Slayer or anime in general, you should definitely try these games on your Android device. They will provide you with hours of fun and excitement as you relive the epic moments of the anime or create your own stories. You can download these games for free using the APK files that we have provided in this article. Just follow the simple steps that we have explained and enjoy!</p>
- <p>Thank you for reading this article. We hope that you have found it useful and informative. If you have any questions or feedback about these games or this article, please feel free to leave a comment below. We would love to hear from you!</p>
- <h2>Frequently Asked Questions</h2>
- <ol>
-<li><b>What is an APK file and how do I use it?</b></li>
-<li>An APK file is an application package that contains all the files and data needed to install and run an app on your Android device. You can use an APK file to install apps that are not available on the official Google Play Store, such as the Demon Slayer games that we have discussed in this article. To use an APK file, you need to download it from a trusted source, enable "Unknown Sources" on your device's settings, and tap on the file to install it.</li>
-<li><b>Are these Demon Slayer games safe and legal to download and play?</b></li>
-<li>Yes, these Demon Slayer games are safe and legal to download and play, as long as you get them from the official websites or reliable sources that we have provided in this article. These games are licensed by the creators of the anime and manga, and they do not contain any viruses or malware that could harm your device or data. However, you should always be careful when downloading any APK files from unknown or unverified sources, as they may contain harmful or illegal content.</li>
-<li><b>Do I need an internet connection to play these Demon Slayer games?</b></li>
-<li>Yes, you need an internet connection to play these Demon Slayer games, as they require online authentication and verification to run. You also need an internet connection to access some of the features and modes of these games, such as online multiplayer, updates, events, and more. However, you can also play some parts of these games offline, such as the story mode or the solo mode.</li>
-<li><b>Can I play these Demon Slayer games on other devices besides Android?</b></li>
-<li>Yes, you can play these Demon Slayer games on other devices besides Android, depending on the game. The Hinokami Chronicles is available for Nintendo Switch, PlayStation 4, PlayStation 5, Xbox One, Xbox Series X/S, and Steam. Rage of Demon King is available for iOS and Android devices. However, if you want to play these games on your Android device, you will need to download and install the APK files that we have provided in this article.</li>
-<li><b>What are some other Demon Slayer games that I can play on my Android device?</b></li>
-<li>Some other Demon Slayer games that you can play on your Android device are Demon Slayer: Kimetsu no Yaiba - Keppuu Kengeki Royale, a battle royale game that lets you fight as a demon slayer or a demon; Demon Slayer: Kimetsu no Yaiba - Puzzle of Memories, a puzzle game that lets you collect and match characters from the anime; and Demon Slayer: Kimetsu no Yaiba - The Card Game, a card game that lets you build your own deck and battle against other players.</li>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Free Download Red Alert 2 Yuri 39s Revenge For Windows 10 EXCLUSIVE.md

@@ -1,117 +0,0 @@
-
-<h1>How to Download and Play Red Alert 2 Yuri's Revenge for Windows 10</h1>
-<p>Red Alert 2 Yuri's Revenge is one of the most popular and beloved real-time strategy games of all time. Released in 2001 as an expansion pack to Red Alert 2, it adds a new faction, new units, new maps, new modes, and a new storyline to the original game. If you are a fan of classic RTS games, you might be wondering how you can download and play Red Alert 2 Yuri's Revenge for free on your Windows 10 PC. In this article, we will show you how to do that in a few simple steps.</p>
-<h2>free download red alert 2 yuri 39;s revenge for windows 10</h2><br /><p><b><b>Download</b> ===> <a href="https://jinyurl.com/2uNTJ0">https://jinyurl.com/2uNTJ0</a></b></p><br /><br />
-<h2>What is Red Alert 2 Yuri's Revenge?</h2>
-<h3>A brief introduction to the game and its plot</h3>
-<p>Red Alert 2 Yuri's Revenge is a real-time strategy game set in an alternate history where the Soviet Union and the Allies are locked in a global war. The game follows the events of Red Alert 2, where the Allies have defeated the Soviets with the help of a time machine. However, Yuri, the former head of the Soviet Psychic Corps, has secretly built his own army of mind-controlled soldiers and machines, and plans to use his psychic dominators to enslave the world. The player can choose to play as either the Allies, the Soviets, or Yuri's faction, each with their own unique units, buildings, technologies, and abilities.</p>
-<h3>The main features and gameplay modes of the game</h3>
-<p>Red Alert 2 Yuri's Revenge offers a variety of features and gameplay modes for players to enjoy. Some of them are:</p>
-<ul>
-<li>A single-player campaign mode with seven missions for each faction, featuring cinematic cutscenes and voice acting.</li>
-<li>A skirmish mode where players can customize their own battles against AI opponents or other players on LAN or online.</li>
-<li>A multiplayer mode where players can join or host online games with up to eight players on various maps and modes.</li>
-<li>A map editor where players can create their own maps and scenarios.</li>
-<li>A modding community where players can download and install fan-made mods that add new content or change the gameplay.</li>
-</ul>
-<h2>Why play Red Alert 2 Yuri's Revenge on Windows 10?</h2>
-<h3>The benefits of playing on a modern operating system</h3>
-<p>Playing Red Alert 2 Yuri's Revenge on Windows 10 has several advantages over playing it on older operating systems. Some of them are:</p>
-<p></p>
-<ul>
-<li>Better performance and stability. Windows 10 is more optimized and compatible with modern hardware and software than older versions of Windows. This means that you can run the game faster and smoother, and avoid crashes and errors.</li>
-<li>Better graphics and sound quality. Windows 10 supports higher resolutions and refresh rates, as well as better audio drivers and codecs than older versions of Windows. This means that you can enjoy the game with sharper visuals and clearer sounds.</li>
-<li>Better security and privacy. Windows 10 has more advanced and updated security features and settings than older versions of Windows. This means that you can protect your PC and your data from viruses, malware, hackers, and other threats.</li>
-</ul>
-<h3>The challenges and solutions of running an old game on Windows 10</h3>
-<p>Playing Red Alert 2 Yuri's Revenge on Windows 10 also has some challenges and drawbacks that need to be addressed. Some of them are:</p>
-<ul>
-<li>Compatibility issues. Red Alert 2 Yuri's Revenge was designed for Windows 95/98/ME/2000/XP, which means that it may not run properly or at all on Windows 10. This can cause problems such as black screens, missing textures, distorted colors, lagging, freezing, or crashing.</li>
-<li>Solution: To fix these issues, you need to run the game in compatibility mode for Windows XP Service Pack 3. To do this, right-click on the game's executable file or shortcut, select Properties, go to the Compatibility tab, check the box that says "Run this program in compatibility mode for:", and choose Windows XP Service Pack 3 from the drop-down menu. Click Apply and OK to save the changes.</li>
-<li>CD-ROM requirement. Red Alert 2 Yuri's Revenge requires the original CD-ROM of the game to be inserted in the CD drive in order to play. This can be inconvenient or impossible for some users who do not have a CD drive or have lost or damaged their CD.</li>
-<li>Solution: To bypass this requirement, you need to download and install a no-CD patch for the game. A no-CD patch is a modified version of the game's executable file that allows you to play without the CD. You can find various no-CD patches for Red Alert 2 Yuri's Revenge online, such as [this one]. Make sure to download the patch that matches your game version and language. To install the patch, simply copy and paste the patched executable file into your game folder, replacing the original one.</li>
-</ul>
-<h2>How to download Red Alert 2 Yuri's Revenge for free?</h2>
-<h3>The legal and ethical issues of downloading an old game for free</h3>
-<p>Before you download Red Alert 2 Yuri's Revenge for free, you should be aware of the legal and ethical implications of doing so. Red Alert 2 Yuri's Revenge is a copyrighted product of Electronic Arts (EA), which means that downloading it for free without their permission is technically illegal and could result in legal action or penalties. Moreover, downloading it for free could also be considered unethical and unfair to the developers and publishers who invested their time, money, and effort into creating and distributing the game.</p>
-<p>However, there are some arguments that could justify downloading an old game for free, such as:</p>
-<ul>
-<li>The game is no longer available for purchase or download from official sources, making it impossible or difficult for users to obtain it legally.</li>
-<li>The game is considered abandonware, meaning that it has been abandoned by its developers and publishers who no longer support or care about it.</li>
-<li>The game is part of the cultural heritage of gaming and should be preserved and accessible for future generations.</li>
-<li>The game is downloaded for personal use only and not for commercial or malicious purposes.</li>
-</ul>
-<p>Ultimately, downloading Red Alert 2 Yuri's Revenge for free is a personal choice that depends on your own moral values and judgment. We do not condone or encourage piracy, but we also do not judge or criticize those who choose to do so.</p>
-<h3>The best sources and methods of downloading the game safely and securely</h3>
-<p>If you decide to download Red Alert 2 Yuri's Revenge for free, you should be careful about where and how you do it. There are many websites and platforms that offer free downloads of old games, but not all of them are trustworthy or reliable. Some of them may contain viruses, malware, spyware, adware, or other unwanted or harmful programs that could damage your PC or compromise your data. Some of them may also provide incomplete, corrupted, or fake files that could ruin your gaming experience.</p>
-<p>To avoid these risks, you should follow these tips when downloading Red Alert 2 Yuri's Revenge for free:</p>
-<ul>
-<li>Use a reputable and verified website or platform that has positive reviews and feedback from other users. Some examples are [Old-Games.com], [MyAbandonware.com], [Ab andonia.com], and [GOG.com].</li>
-<li>Use a reliable and updated antivirus or anti-malware software to scan the downloaded files before opening or installing them. Some examples are [Avast], [Malwarebytes], [Norton], and [Kaspersky].</li>
-<li>Use a secure and fast internet connection to download the files without interruptions or errors. Avoid using public or unsecured Wi-Fi networks that could expose your data to hackers or snoopers.</li>
-<li>Use a VPN (virtual private network) service to hide your IP address and encrypt your online traffic. This can help you bypass geo-restrictions, avoid ISP throttling, and protect your privacy and anonymity. Some examples are [ExpressVPN], [NordVPN], [Surfshark], and [CyberGhost].</li>
-</ul>
-<h2>How to install and play Red Alert 2 Yuri's Revenge on Windows 10?</h2>
-<h3>The system requirements and compatibility issues of the game</h3>
-<p>Before you install and play Red Alert 2 Yuri's Revenge on Windows 10, you should make sure that your PC meets the minimum system requirements of the game. According to the official website of EA, these are:</p>
-<table>
-<tr><th>Component</th><th>Minimum Requirement</th></tr>
-<tr><td>Operating System</td><td>Windows 95/98/ME/2000/XP</td></tr>
-<tr><td>Processor</td><td>Pentium II 266 MHz or higher</td></tr>
-<tr><td>Memory</td><td>64 MB RAM</td></tr>
-<tr><td>Hard Disk Space</td><td>200 MB free space</td></tr>
-<tr><td>Video Card</td><td>2 MB PCI or AGP video card with Direct3D support</td></tr>
-<tr><td>Sound Card</td><td>DirectX 8.0 compatible sound card</td></tr>
-<tr><td>CD-ROM Drive</td><td>4x speed or faster CD-ROM drive</td></tr>
-<tr><td>Input Device</td><td>Keyboard and mouse</td></tr>
-<tr><td>Internet Connection</td><td>56 Kbps modem or faster for online play</td></tr>
-</table>
-<p>As you can see, these requirements are very low by today's standards, which means that most modern PCs should be able to run the game without any problems. However, as we mentioned earlier, there may be some compatibility issues that prevent the game from running properly or at all on Windows 10. To fix these issues, you need to follow the steps and tips that we discussed in the previous section.</p>
-<h3>The steps and tips of installing and launching the game</h3>
-<p>To install and play Red Alert 2 Yuri's Revenge on Windows 10, you need to follow these steps:</p>
-<ol>
-<li>Download Red Alert 2 Yuri's Revenge from one of the sources that we recommended in the previous section. Make sure to download the full version of the game, not a demo or a trial.</li>
-<li>Extract the downloaded files using a file archiver program such as [WinRAR] or [7-Zip]. You should get a folder containing the game files.</li>
-<li>Run the setup.exe file inside the folder to start the installation process. Follow the on-screen instructions to complete the installation.</li>
-<li>If you downloaded a no-CD patch for the game, copy and paste it into your game folder, replacing the original executable file.</li>
-<li>If you want to apply any patches or mods to the game, download and install them according to their instructions.</li>
-<li>Right-click on the game's executable file or shortcut, select Properties, go to the Compatibility tab, check the box that says "Run this program in compatibility mode for:", and choose Windows XP Service Pack 3 from the drop-down menu. Click Apply and OK to save the changes.</li>
-<li>Double-click on the game's executable file or shortcut to launch the game. Enjoy!</li>
-</ol>
-<h3>The recommended patches and mods to enhance the game experience</h3>
-<p>If you want to improve your gaming experience with Red Alert 2 Yuri's Revenge, you can try some of these patches and mods that add new features, fix bugs, balance gameplay, or change graphics:</p>
-<ul>
-<li>[CnCNet] is a patch that enables online multiplayer for Red Alert 2 Yuri's Revenge and other classic C&C games. It also adds new maps, modes, options, and enhancements to the game.</li>
-<li>[Ares] is a mod that expands the modding capabilities of Red Alert 2 Yuri's Revenge. It allows modders to create new units, buildings, weapons, effects, and features to the game.</li>
-<li>[Mental Omega] is a mod that adds a new storyline, new factions, new units, new missions, new music, and new gameplay elements to Red Alert 2 Yuri's Revenge. It is considered one of the best and most comprehensive mods for the game.</li>
-<li>[Yuri's Revenge: CnCD2K] is a mod that combines Red Alert 2 Yuri's Revenge with Dune 2000, another classic RTS game. It adds new factions, units, buildings, maps, and modes from Dune 2000 to the game.</li>
-<li>[Red Resurrection] is a mod that revamps and rebalances Red Alert 2 Yuri's Revenge. It adds new units, buildings, technologies, maps, modes, and features to the game.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>Red Alert 2 Yuri's Revenge is a classic RTS game that deserves to be played and enjoyed by old and new fans alike. If you want to download and play it for free on your Windows 10 PC, you can follow the steps and tips that we have provided in this article. We hope that this article has been helpful and informative for you. Now go ahead and command your army to victory!</p>
-<h2>FAQs</h2>
-<h3>Q1: Is Red Alert 2 Yuri's Revenge a standalone game or an expansion pack?</h3>
-<p>A1: Red Alert 2 Yuri's Revenge is an expansion pack to Red Alert 2, which means that you need to have the original game installed on your PC in order to play it. However, some sources may provide a complete version of the game that includes both Red Alert 2 and Yuri's Revenge in one package.</p>
-<h3>Q2: How many factions and units are there in Red Alert 2 Yuri's Revenge?</h3>
-<p>A2: Red Alert 2 Yuri's Revenge has three factions: the Allies, the Soviets, and Yuri's faction. Each faction has its own unique units, buildings, technologies, and abilities. There are over 100 units in total in the game, including infantry, vehicles, aircraft, naval vessels, and special units.</p>
-<h3>Q3: How can I play Red Alert 2 Yuri's Revenge online with other players?</h3>
-<p>A3: You can play Red Alert 2 Yuri's Revenge online with other players by using a patch such as [CnCNet], which enables online multiplayer for the game. You can join or host online games with up to eight players on various maps and modes. You can also chat with other players and join clans and tournaments.</p>
-<h3>Q4: What are some of the best strategies and tips for playing Red Alert 2 Yuri's Revenge?</h3>
-<p>A4: Some of the best strategies and tips for playing Red Alert 2 Yuri's Revenge are:</p>
-<ul>
-<li>Know your faction's strengths and weaknesses. Each faction has its own advantages and disadvantages in terms of units, buildings, technologies, and abilities. For example, the Allies have superior air power and mobility, but lack heavy armor and firepower. The Soviets have powerful tanks and artillery, but are slow and vulnerable to air attacks. Yuri's faction has mind control and psychic weapons, but are expensive and fragile.</li>
-<li>Know your enemy's faction and tactics. You should always scout your enemy's base and units to see what they are planning and how they are playing. You should also adapt your strategy according to your enemy's faction and tactics. For example, if your enemy is using a lot of infantry, you should use anti-infantry units or weapons. If your enemy is using a lot of air units, you should use anti-air units or weapons.</li>
-<li>Manage your resources and economy. You should always collect as much ore as possible to fund your army and base. You should also build refineries near ore fields to speed up ore collection. You should also build power plants to supply energy to your buildings and units. You should also build barracks, war factories, airfields, naval yards, tech buildings, and defense structures to produce and protect your army and base.</li>
-<li>Use your special abilities wisely. Each faction has its own special abilities that can turn the tide of battle. For example, the Allies have the Chronosphere that can teleport units across the map, the Soviets have the Iron Curtain that can make units invulnerable for a short time, and Yuri's faction has the Psychic Dominator that can unleash a devastating blast on a target area. You should use these abilities at the right time and place to surprise, weaken, or destroy your enemy.</li>
-<li>Use your superweapons sparingly. Each faction has its own superweapons that can cause massive damage to the enemy base or units. For example, the Allies have the Weather Control Device that can create a lightning storm, the Soviets have the Nuclear Missile Silo that can launch a nuclear missile, and Yuri's faction has the Genetic Mutator that can mutate enemy units into brutes. You should use these superweapons only when necessary or when you have a clear advantage, as they have long cooldown times and can be countered by enemy defenses or abilities.</li>
-</ul>
-<h3>Q5: Where can I find more information and resources about Red Alert 2 Yuri's Revenge?</h3>
-<p>A5: If you want to learn more about Red Alert 2 Yuri's Revenge, you can visit some of these websites and platforms that provide information and resources about the game:</p>
-<ul>
-<li>[The official website of EA] is where you can find the official news, updates, and support for the game.</li>
-<li>[The C&C Wiki] is where you can find detailed information and trivia about the game's factions, units, buildings, missions, characters, and lore.</li>
-<li>[The C&C Community] is where you can find forums, guides, tutorials, videos, streams, and blogs about the game and other C&C games.</li>
-<li>[The ModDB] is where you can find hundreds of fan-made mods that add new content or change the gameplay of the game.</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />

spaces/2ndelement/voicevox/get_cost_candidates.py

@@ -1,91 +0,0 @@
-"""
-voicevox_engine/part_of_speech_data.pyのcost_candidatesを計算するプログラムです。
-引数のnaist_jdic_pathには、open_jtalkのsrc/mecab-naist-jdic/naist-jdic.csvを指定してください。
-
-実行例:
-python get_cost_candidates.py --naist_jdic_path=/path/to/naist-jdic.csv \
-    --pos=名詞 \
-    --pos_detail_1=固有名詞 \
-    --pos_detail_2=一般 \
-    --pos_detail_3=*
-
-cost_candidatesの値の詳細は以下の通りです。
-- 1番目の値はnaist_jdic内の同一品詞の最小コストから1を引いたもの、11番目の値は最大コストに1を足したものです。
-- 2番目の値はnaist_jdic内の同一品詞のコストの下位1%、10番目の値は99%の値です。
-- 6番目の値はnaist_jdic内の同一品詞のコストの最頻値です。
-- 2番目から6番目、6番目から10番目までの値は一定割合で増加するようになっています。
-"""
-
-import argparse
-import statistics
-from pathlib import Path
-from typing import List
-
-import numpy as np
-
-
-def get_candidates(
-    naist_jdic_path: Path,
-    pos: str,
-    pos_detail_1: str,
-    pos_detail_2: str,
-    pos_detail_3: str,
-) -> List[int]:
-    costs = []
-    with naist_jdic_path.open(encoding="utf-8") as f:
-        for line in f:
-            (
-                _,
-                _,
-                _,
-                _cost,
-                _pos,
-                _pos_detail_1,
-                _pos_detail_2,
-                _pos_detail_3,
-                _,
-                _,
-                _,
-                _,
-                _,
-                _,
-                _,
-            ) = line.split(",")
-            if (_pos, _pos_detail_1, _pos_detail_2, _pos_detail_3) == (
-                pos,
-                pos_detail_1,
-                pos_detail_2,
-                pos_detail_3,
-            ):
-                costs.append(int(_cost))
-    assert len(costs) > 0
-    cost_min = min(costs) - 1
-    cost_1per = np.quantile(costs, 0.01).astype(np.int64)
-    cost_mode = statistics.mode(costs)
-    cost_99per = np.quantile(costs, 0.99).astype(np.int64)
-    cost_max = max(costs) + 1
-    return (
-        [cost_min]
-        + [int(cost_1per + (cost_mode - cost_1per) * i / 4) for i in range(5)]
-        + [int(cost_mode + (cost_99per - cost_mode) * i / 4) for i in range(1, 5)]
-        + [cost_max]
-    )
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--naist_jdic_path", type=Path)
-    parser.add_argument("--pos", type=str)
-    parser.add_argument("--pos_detail_1", type=str)
-    parser.add_argument("--pos_detail_2", type=str)
-    parser.add_argument("--pos_detail_3", type=str)
-    args = parser.parse_args()
-    print(
-        get_candidates(
-            naist_jdic_path=args.naist_jdic_path,
-            pos=args.pos,
-            pos_detail_1=args.pos_detail_1,
-            pos_detail_2=args.pos_detail_2,
-            pos_detail_3=args.pos_detail_3,
-        )
-    )

spaces/7hao/bingo/src/lib/hooks/use-bing.ts

@@ -1,173 +0,0 @@
-'use client'
-
-import { useState, useCallback, useEffect, useMemo } from 'react'
-import { useAtom, useAtomValue } from 'jotai'
-import { chatFamily, bingConversationStyleAtom, GreetMessages, hashAtom, voiceAtom } from '@/state'
-import { setConversationMessages } from './chat-history'
-import { ChatMessageModel, BotId, FileItem } from '@/lib/bots/bing/types'
-import { nanoid } from '../utils'
-import { TTS } from '../bots/bing/tts'
-
-export function useBing(botId: BotId = 'bing') {
-  const chatAtom = useMemo(() => chatFamily({ botId, page: 'singleton' }), [botId])
-  const [enableTTS] = useAtom(voiceAtom)
-  const speaker = useMemo(() => new TTS(), [])
-  const [hash, setHash] = useAtom(hashAtom)
-  const bingConversationStyle = useAtomValue(bingConversationStyleAtom)
-  const [chatState, setChatState] = useAtom(chatAtom)
-  const [input, setInput] = useState('')
-  const [attachmentList, setAttachmentList] = useState<FileItem[]>([])
-
-  const updateMessage = useCallback(
-    (messageId: string, updater: (message: ChatMessageModel) => void) => {
-      setChatState((draft) => {
-        const message = draft.messages.find((m) => m.id === messageId)
-        if (message) {
-          updater(message)
-        }
-      })
-    },
-    [setChatState],
-  )
-
-  const sendMessage = useCallback(
-    async (input: string, options = {}) => {
-      const botMessageId = nanoid()
-      const imageUrl = attachmentList?.[0]?.status === 'loaded' ? attachmentList[0].url : undefined
-      setChatState((draft) => {
-        const text = imageUrl ? `${input}\n\n![image](${imageUrl})` : input
-        draft.messages.push({ id: nanoid(), text, author: 'user' }, { id: botMessageId, text: '', author: 'bot' })
-        setAttachmentList([])
-      })
-      const abortController = new AbortController()
-      setChatState((draft) => {
-        draft.generatingMessageId = botMessageId
-        draft.abortController = abortController
-      })
-      speaker.reset()
-      await chatState.bot.sendMessage({
-        prompt: input,
-        imageUrl: /\?bcid=([^&]+)/.test(imageUrl ?? '') ? `https://www.bing.com/images/blob?bcid=${RegExp.$1}` : imageUrl,
-        options: {
-          ...options,
-          bingConversationStyle,
-        },
-        signal: abortController.signal,
-        onEvent(event) {
-          if (event.type === 'UPDATE_ANSWER') {
-            updateMessage(botMessageId, (message) => {
-              if (event.data.text.length > message.text.length) {
-                message.text = event.data.text
-              }
-
-              if (event.data.spokenText && enableTTS) {
-                speaker.speak(event.data.spokenText)
-              }
-
-              message.throttling = event.data.throttling || message.throttling
-              message.sourceAttributions = event.data.sourceAttributions || message.sourceAttributions
-              message.suggestedResponses = event.data.suggestedResponses || message.suggestedResponses
-            })
-          } else if (event.type === 'ERROR') {
-            updateMessage(botMessageId, (message) => {
-              message.error = event.error
-            })
-            setChatState((draft) => {
-              draft.abortController = undefined
-              draft.generatingMessageId = ''
-            })
-          } else if (event.type === 'DONE') {
-            setChatState((draft) => {
-              draft.abortController = undefined
-              draft.generatingMessageId = ''
-            })
-          }
-        },
-      })
-    },
-    [botId, attachmentList, chatState.bot, setChatState, updateMessage],
-  )
-
-  const uploadImage = useCallback(async (imgUrl: string) => {
-    setAttachmentList([{ url: imgUrl, status: 'loading' }])
-    const response = await chatState.bot.uploadImage(imgUrl, bingConversationStyle)
-    if (response?.blobId) {
-      setAttachmentList([{ url: `/api/blob?bcid=${response.blobId}`, status: 'loaded' }])
-    } else {
-      setAttachmentList([{ url: imgUrl, status: 'error' }])
-    }
-  }, [chatState.bot])
-
-  const resetConversation = useCallback(() => {
-    chatState.bot.resetConversation()
-    speaker.abort()
-    setChatState((draft) => {
-      draft.abortController = undefined
-      draft.generatingMessageId = ''
-      draft.messages = [{ author: 'bot', text: GreetMessages[Math.floor(GreetMessages.length * Math.random())], id: nanoid() }]
-      draft.conversationId = nanoid()
-    })
-  }, [chatState.bot, setChatState])
-
-  const stopGenerating = useCallback(() => {
-    chatState.abortController?.abort()
-    if (chatState.generatingMessageId) {
-      updateMessage(chatState.generatingMessageId, (message) => {
-        if (!message.text && !message.error) {
-          message.text = 'Cancelled'
-        }
-      })
-    }
-    setChatState((draft) => {
-      draft.generatingMessageId = ''
-    })
-  }, [chatState.abortController, chatState.generatingMessageId, setChatState, updateMessage])
-
-  useEffect(() => {
-    if (chatState.messages.length) {
-      setConversationMessages(botId, chatState.conversationId, chatState.messages)
-    }
-  }, [botId, chatState.conversationId, chatState.messages])
-
-  useEffect(() => {
-    if (hash === 'reset') {
-      resetConversation()
-      setHash('')
-    }
-  }, [hash, setHash])
-
-  const chat = useMemo(
-    () => ({
-      botId,
-      bot: chatState.bot,
-      isSpeaking: speaker.isSpeaking,
-      messages: chatState.messages,
-      sendMessage,
-      setInput,
-      input,
-      resetConversation,
-      generating: !!chatState.generatingMessageId,
-      stopGenerating,
-      uploadImage,
-      setAttachmentList,
-      attachmentList,
-    }),
-    [
-      botId,
-      bingConversationStyle,
-      chatState.bot,
-      chatState.generatingMessageId,
-      chatState.messages,
-      speaker.isSpeaking,
-      setInput,
-      input,
-      setAttachmentList,
-      attachmentList,
-      resetConversation,
-      sendMessage,
-      stopGenerating,
-    ],
-  )
-
-  return chat
-}

spaces/AI-ANK/blackmirroroffice/app.py

@@ -1,43 +0,0 @@
-import gradio as gr
-import requests
-
-# Dictionary of actors, their corresponding video URLs, and image URLs
-ACTOR_VIDEOS = {
-    "Original": {
-        "video_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/videos/office.mp4",
-        "image_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/images/ms.jpg",
-    },
-    "John Cena": {
-        "video_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/videos/1jcf.mp4",
-        "image_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/images/1jc.jpg",
-    },
-    "Joaquin Phoenix": {
-        "video_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/videos/1jpf.mp4",
-        "image_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/images/1jp.jpg",
-    },
-    "Mr Beast": {
-        "video_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/videos/1mrbf.mp4",
-        "image_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/images/1mrb.jpg",
-    },
-    "Bob Odenkirk": {
-        "video_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/videos/1sgf.mp4",
-        "image_url": "https://cdn.jsdelivr.net/gh/AI-ANK/bmjoanisawful@main/images/1sg.jpg",
-    },
-}
-
-# Function to change video based on actor selection
-def change_video(actor_name):
-    video_url = ACTOR_VIDEOS[actor_name]["video_url"]
-    return f'<video width="100%" controls autoplay><source src="{video_url}" type="video/mp4"></video>'
-
-# Create Gradio Interface
-iface = gr.Interface(
-    fn=change_video, 
-    inputs=gr.Radio(choices=list(ACTOR_VIDEOS.keys()), label="Choose Your Actor"),
-    outputs=gr.HTML(label="Your Video"),
-    live=True,
-    title="Black Mirror Meets The Office: Michael Scott Is Awful",
-    description="Choose an actor below and watch them step into the shoes of Michael Scott"
-)
-
-iface.launch()

spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/tts/portaspeech/portaspeech_flow.py

@@ -1,75 +0,0 @@
-import torch
-import torch.distributions as dist
-from torch import nn
-from text_to_speech.modules.commons.normalizing_flow.glow_modules import Glow
-from text_to_speech.modules.tts.portaspeech.portaspeech import PortaSpeech
-
-
-class PortaSpeechFlow(PortaSpeech):
-    def __init__(self, ph_dict_size, word_dict_size, hparams, out_dims=None):
-        super().__init__(ph_dict_size, word_dict_size, hparams, out_dims)
-        cond_hs = 80
-        if hparams.get('use_txt_cond', True):
-            cond_hs = cond_hs + hparams['hidden_size']
-        if hparams.get('use_latent_cond', False):
-            cond_hs = cond_hs + hparams['latent_size']
-        if hparams['use_cond_proj']:
-            self.g_proj = nn.Conv1d(cond_hs, 160, 5, padding=2)
-            cond_hs = 160
-        self.post_flow = Glow(
-            80, hparams['post_glow_hidden'], hparams['post_glow_kernel_size'], 1,
-            hparams['post_glow_n_blocks'], hparams['post_glow_n_block_layers'],
-            n_split=4, n_sqz=2,
-            gin_channels=cond_hs,
-            share_cond_layers=hparams['post_share_cond_layers'],
-            share_wn_layers=hparams['share_wn_layers'],
-            sigmoid_scale=hparams['sigmoid_scale']
-        )
-        self.prior_dist = dist.Normal(0, 1)
-
-    def forward(self, txt_tokens, word_tokens, ph2word, word_len, mel2word=None, mel2ph=None,
-                spk_embed=None, spk_id=None, pitch=None, infer=False, tgt_mels=None,
-                forward_post_glow=True, two_stage=True, global_step=None, **kwargs):
-        is_training = self.training
-        train_fvae = not (forward_post_glow and two_stage)
-        if not train_fvae:
-            self.eval()
-        with torch.set_grad_enabled(mode=train_fvae):
-            ret = super(PortaSpeechFlow, self).forward(
-                txt_tokens, word_tokens, ph2word, word_len, mel2word, mel2ph,
-                spk_embed, spk_id, pitch, infer, tgt_mels, global_step, **kwargs)
-        if (forward_post_glow or not two_stage) and self.hparams['use_post_flow']:
-            self.run_post_glow(tgt_mels, infer, is_training, ret)
-        return ret
-
-    def run_post_glow(self, tgt_mels, infer, is_training, ret):
-        x_recon = ret['mel_out'].transpose(1, 2)
-        g = x_recon
-        B, _, T = g.shape
-        if self.hparams.get('use_txt_cond', True):
-            g = torch.cat([g, ret['decoder_inp'].transpose(1, 2)], 1)
-        if self.hparams.get('use_latent_cond', False):
-            g_z = ret['z_p'][:, :, :, None].repeat(1, 1, 1, 4).reshape(B, -1, T)
-            g = torch.cat([g, g_z], 1)
-        if self.hparams['use_cond_proj']:
-            g = self.g_proj(g)
-        prior_dist = self.prior_dist
-        if not infer:
-            if is_training:
-                self.post_flow.train()
-            nonpadding = ret['nonpadding'].transpose(1, 2)
-            y_lengths = nonpadding.sum(-1)
-            if self.hparams['detach_postflow_input']:
-                g = g.detach()
-            tgt_mels = tgt_mels.transpose(1, 2)
-            z_postflow, ldj = self.post_flow(tgt_mels, nonpadding, g=g)
-            ldj = ldj / y_lengths / 80
-            ret['z_pf'], ret['ldj_pf'] = z_postflow, ldj
-            ret['postflow'] = -prior_dist.log_prob(z_postflow).mean() - ldj.mean()
-            if torch.isnan(ret['postflow']):
-                ret['postflow'] = None
-        else:
-            nonpadding = torch.ones_like(x_recon[:, :1, :])
-            z_post = torch.randn(x_recon.shape).to(g.device) * self.hparams['noise_scale']
-            x_recon, _ = self.post_flow(z_post, nonpadding, g, reverse=True)
-            ret['mel_out'] = x_recon.transpose(1, 2)

spaces/AISuperheroes/10SL-RealTimeDSDashboard-Live-AIUIUX/README.md

@@ -1,13 +0,0 @@
----
-title: 10SL RealTimeDSDashboard Live AIUIUX
-emoji: ⏩
-colorFrom: indigo
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AIZero2HeroBootcamp/StaticHTML5Playcanvas/style.css

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

spaces/AJRFan/dreambooth-training/train_dreambooth.py

@@ -1,818 +0,0 @@
-import argparse
-import itertools
-import math
-import os
-from pathlib import Path
-from typing import Optional
-import subprocess
-import sys
-
-import torch
-import torch.nn.functional as F
-import torch.utils.checkpoint
-from torch.utils.data import Dataset
-
-from accelerate import Accelerator
-from accelerate.logging import get_logger
-from accelerate.utils import set_seed
-from diffusers import AutoencoderKL, DDPMScheduler, StableDiffusionPipeline, UNet2DConditionModel
-from diffusers.optimization import get_scheduler
-from huggingface_hub import HfFolder, Repository, whoami
-from PIL import Image
-from torchvision import transforms
-from tqdm.auto import tqdm
-from transformers import CLIPTextModel, CLIPTokenizer
-
-
-logger = get_logger(__name__)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Simple example of a training script.")
-    parser.add_argument(
-        "--pretrained_model_name_or_path",
-        type=str,
-        default=None,
-        #required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models.",
-    )
-    parser.add_argument(
-        "--tokenizer_name",
-        type=str,
-        default=None,
-        help="Pretrained tokenizer name or path if not the same as model_name",
-    )
-    parser.add_argument(
-        "--instance_data_dir",
-        type=str,
-        default=None,
-        #required=True,
-        help="A folder containing the training data of instance images.",
-    )
-    parser.add_argument(
-        "--class_data_dir",
-        type=str,
-        default=None,
-        required=False,
-        help="A folder containing the training data of class images.",
-    )
-    parser.add_argument(
-        "--instance_prompt",
-        type=str,
-        default=None,
-        help="The prompt with identifier specifying the instance",
-    )
-    parser.add_argument(
-        "--class_prompt",
-        type=str,
-        default="",
-        help="The prompt to specify images in the same class as provided instance images.",
-    )
-    parser.add_argument(
-        "--with_prior_preservation",
-        default=False,
-        action="store_true",
-        help="Flag to add prior preservation loss.",
-    )
-    parser.add_argument("--prior_loss_weight", type=float, default=1.0, help="The weight of prior preservation loss.")
-    parser.add_argument(
-        "--num_class_images",
-        type=int,
-        default=100,
-        help=(
-            "Minimal class images for prior preservation loss. If not have enough images, additional images will be"
-            " sampled with class_prompt."
-        ),
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default="",
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
-    parser.add_argument(
-        "--resolution",
-        type=int,
-        default=512,
-        help=(
-            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
-            " resolution"
-        ),
-    )
-    parser.add_argument(
-        "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution"
-    )
-    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
-    parser.add_argument(
-        "--train_batch_size", type=int, default=4, help="Batch size (per device) for the training dataloader."
-    )
-    parser.add_argument(
-        "--sample_batch_size", type=int, default=4, help="Batch size (per device) for sampling images."
-    )
-    parser.add_argument("--num_train_epochs", type=int, default=1)
-    parser.add_argument(
-        "--max_train_steps",
-        type=int,
-        default=None,
-        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
-    )
-    parser.add_argument(
-        "--gradient_accumulation_steps",
-        type=int,
-        default=1,
-        help="Number of updates steps to accumulate before performing a backward/update pass.",
-    )
-    parser.add_argument(
-        "--gradient_checkpointing",
-        action="store_true",
-        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
-    )
-    parser.add_argument(
-        "--learning_rate",
-        type=float,
-        default=5e-6,
-        help="Initial learning rate (after the potential warmup period) to use.",
-    )
-    parser.add_argument(
-        "--scale_lr",
-        action="store_true",
-        default=False,
-        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
-    )
-    parser.add_argument(
-        "--lr_scheduler",
-        type=str,
-        default="constant",
-        help=(
-            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
-            ' "constant", "constant_with_warmup"]'
-        ),
-    )
-    parser.add_argument(
-        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
-    )
-    parser.add_argument(
-        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
-    )
-    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
-    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
-    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
-    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
-    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
-    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
-    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
-    parser.add_argument(
-        "--hub_model_id",
-        type=str,
-        default=None,
-        help="The name of the repository to keep in sync with the local `output_dir`.",
-    )
-    parser.add_argument(
-        "--logging_dir",
-        type=str,
-        default="logs",
-        help=(
-            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
-            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
-        ),
-    )
-    parser.add_argument(
-        "--mixed_precision",
-        type=str,
-        default="no",
-        choices=["no", "fp16", "bf16"],
-        help=(
-            "Whether to use mixed precision. Choose"
-            "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."
-            "and an Nvidia Ampere GPU."
-        ),
-    )
-
-    parser.add_argument(
-        "--save_n_steps",
-        type=int,
-        default=1,
-        help=("Save the model every n global_steps"),
-    )
-    
-    
-    parser.add_argument(
-        "--save_starting_step",
-        type=int,
-        default=1,
-        help=("The step from which it starts saving intermediary checkpoints"),
-    )
-    
-    parser.add_argument(
-        "--stop_text_encoder_training",
-        type=int,
-        default=1000000,
-        help=("The step at which the text_encoder is no longer trained"),
-    )
-
-
-    parser.add_argument(
-        "--image_captions_filename",
-        action="store_true",
-        help="Get captions from filename",
-    )    
-    
-    
-    parser.add_argument(
-        "--dump_only_text_encoder",
-        action="store_true",
-        default=False,        
-        help="Dump only text encoder",
-    )
-
-    parser.add_argument(
-        "--train_only_unet",
-        action="store_true",
-        default=False,        
-        help="Train only the unet",
-    )
-    
-    parser.add_argument(
-        "--Session_dir",
-        type=str,
-        default="",     
-        help="Current session directory",
-    )    
-
-    
-    
-
-    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
-
-    args = parser.parse_args()
-    env_local_rank = int(os.environ.get("LOCAL_RANK", -1))
-    if env_local_rank != -1 and env_local_rank != args.local_rank:
-        args.local_rank = env_local_rank
-
-    #if args.instance_data_dir is None:
-    #    raise ValueError("You must specify a train data directory.")
-
-    #if args.with_prior_preservation:
-    #    if args.class_data_dir is None:
-    #        raise ValueError("You must specify a data directory for class images.")
-    #    if args.class_prompt is None:
-    #        raise ValueError("You must specify prompt for class images.")
-
-    return args
-
-
-class DreamBoothDataset(Dataset):
-    """
-    A dataset to prepare the instance and class images with the prompts for fine-tuning the model.
-    It pre-processes the images and the tokenizes prompts.
-    """
-
-    def __init__(
-        self,
-        instance_data_root,
-        instance_prompt,
-        tokenizer,
-        args,
-        class_data_root=None,
-        class_prompt=None,
-        size=512,
-        center_crop=False,
-    ):
-        self.size = size
-        self.center_crop = center_crop
-        self.tokenizer = tokenizer
-        self.image_captions_filename = None
-
-        self.instance_data_root = Path(instance_data_root)
-        if not self.instance_data_root.exists():
-            raise ValueError("Instance images root doesn't exists.")
-
-        self.instance_images_path = list(Path(instance_data_root).iterdir())
-        self.num_instance_images = len(self.instance_images_path)
-        self.instance_prompt = instance_prompt
-        self._length = self.num_instance_images
-
-        if args.image_captions_filename:
-            self.image_captions_filename = True
-        
-        if class_data_root is not None:
-            self.class_data_root = Path(class_data_root)
-            self.class_data_root.mkdir(parents=True, exist_ok=True)
-            self.class_images_path = list(self.class_data_root.iterdir())
-            self.num_class_images = len(self.class_images_path)
-            self._length = max(self.num_class_images, self.num_instance_images)
-            self.class_prompt = class_prompt
-        else:
-            self.class_data_root = None
-
-        self.image_transforms = transforms.Compose(
-            [
-                transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR),
-                transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size),
-                transforms.ToTensor(),
-                transforms.Normalize([0.5], [0.5]),
-            ]
-        )
-
-    def __len__(self):
-        return self._length
-
-    def __getitem__(self, index):
-        example = {}
-        path = self.instance_images_path[index % self.num_instance_images]
-        instance_image = Image.open(path)
-        if not instance_image.mode == "RGB":
-            instance_image = instance_image.convert("RGB")
-            
-        instance_prompt = self.instance_prompt
-        
-        if self.image_captions_filename:
-            filename = Path(path).stem
-            pt=''.join([i for i in filename if not i.isdigit()])
-            pt=pt.replace("_"," ")
-            pt=pt.replace("(","")
-            pt=pt.replace(")","")
-            instance_prompt = pt
-            sys.stdout.write(" " +instance_prompt+" ")
-            sys.stdout.flush()
-
-
-        example["instance_images"] = self.image_transforms(instance_image)
-        example["instance_prompt_ids"] = self.tokenizer(
-            instance_prompt,
-            padding="do_not_pad",
-            truncation=True,
-            max_length=self.tokenizer.model_max_length,
-        ).input_ids
-
-        if self.class_data_root:
-            class_image = Image.open(self.class_images_path[index % self.num_class_images])
-            if not class_image.mode == "RGB":
-                class_image = class_image.convert("RGB")
-            example["class_images"] = self.image_transforms(class_image)
-            example["class_prompt_ids"] = self.tokenizer(
-                self.class_prompt,
-                padding="do_not_pad",
-                truncation=True,
-                max_length=self.tokenizer.model_max_length,
-            ).input_ids
-
-        return example
-
-
-
-class PromptDataset(Dataset):
-    "A simple dataset to prepare the prompts to generate class images on multiple GPUs."
-
-    def __init__(self, prompt, num_samples):
-        self.prompt = prompt
-        self.num_samples = num_samples
-
-    def __len__(self):
-        return self.num_samples
-
-    def __getitem__(self, index):
-        example = {}
-        example["prompt"] = self.prompt
-        example["index"] = index
-        return example
-
-
-def get_full_repo_name(model_id: str, organization: Optional[str] = None, token: Optional[str] = None):
-    if token is None:
-        token = HfFolder.get_token()
-    if organization is None:
-        username = whoami(token)["name"]
-        return f"{username}/{model_id}"
-    else:
-        return f"{organization}/{model_id}"
-
-def merge_two_dicts(starting_dict: dict, updater_dict: dict) -> dict:
-    """
-    Starts from base starting dict and then adds the remaining key values from updater replacing the values from
-    the first starting/base dict with the second updater dict.
-
-    For later: how does d = {**d1, **d2} replace collision?
-
-    :param starting_dict:
-    :param updater_dict:
-    :return:
-    """
-    new_dict: dict = starting_dict.copy()   # start with keys and values of starting_dict
-    new_dict.update(updater_dict)    # modifies starting_dict with keys and values of updater_dict
-    return new_dict
-
-def merge_args(args1: argparse.Namespace, args2: argparse.Namespace) -> argparse.Namespace:
-    """
-
-    ref: https://stackoverflow.com/questions/56136549/how-can-i-merge-two-argparse-namespaces-in-python-2-x
-    :param args1:
-    :param args2:
-    :return:
-    """
-    # - the merged args
-    # The vars() function returns the __dict__ attribute to values of the given object e.g {field:value}.
-    merged_key_values_for_namespace: dict = merge_two_dicts(vars(args1), vars(args2))
-    args = argparse.Namespace(**merged_key_values_for_namespace)
-    return args
-
-def run_training(args_imported):
-    args_default = parse_args()
-    args = merge_args(args_default, args_imported)
-    print(args)
-    logging_dir = Path(args.output_dir, args.logging_dir)
-    i=args.save_starting_step
-    accelerator = Accelerator(
-        gradient_accumulation_steps=args.gradient_accumulation_steps,
-        mixed_precision=args.mixed_precision,
-        log_with="tensorboard",
-        logging_dir=logging_dir,
-    )
-
-    # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate
-    # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models.
-    # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate.
-    if args.train_text_encoder and args.gradient_accumulation_steps > 1 and accelerator.num_processes > 1:
-        raise ValueError(
-            "Gradient accumulation is not supported when training the text encoder in distributed training. "
-            "Please set gradient_accumulation_steps to 1. This feature will be supported in the future."
-        )
-
-    if args.seed is not None:
-        set_seed(args.seed)
-
-    if args.with_prior_preservation:
-        class_images_dir = Path(args.class_data_dir)
-        if not class_images_dir.exists():
-            class_images_dir.mkdir(parents=True)
-        cur_class_images = len(list(class_images_dir.iterdir()))
-
-        if cur_class_images < args.num_class_images:
-            torch_dtype = torch.float16 if accelerator.device.type == "cuda" else torch.float32
-            pipeline = StableDiffusionPipeline.from_pretrained(
-                args.pretrained_model_name_or_path, torch_dtype=torch_dtype
-            )
-            pipeline.set_progress_bar_config(disable=True)
-
-            num_new_images = args.num_class_images - cur_class_images
-            logger.info(f"Number of class images to sample: {num_new_images}.")
-
-            sample_dataset = PromptDataset(args.class_prompt, num_new_images)
-            sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
-
-            sample_dataloader = accelerator.prepare(sample_dataloader)
-            pipeline.to(accelerator.device)
-
-            for example in tqdm(
-                sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
-            ):
-                with torch.autocast("cuda"):                
-                    images = pipeline(example["prompt"]).images
-
-                for i, image in enumerate(images):
-                    image.save(class_images_dir / f"{example['index'][i] + cur_class_images}.jpg")
-
-            del pipeline
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-
-    # Handle the repository creation
-    if accelerator.is_main_process:
-        if args.push_to_hub:
-            if args.hub_model_id is None:
-                repo_name = get_full_repo_name(Path(args.output_dir).name, token=args.hub_token)
-            else:
-                repo_name = args.hub_model_id
-            repo = Repository(args.output_dir, clone_from=repo_name)
-
-            with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore:
-                if "step_*" not in gitignore:
-                    gitignore.write("step_*\n")
-                if "epoch_*" not in gitignore:
-                    gitignore.write("epoch_*\n")
-        elif args.output_dir is not None:
-            os.makedirs(args.output_dir, exist_ok=True)
-
-    # Load the tokenizer
-    if args.tokenizer_name:
-        tokenizer = CLIPTokenizer.from_pretrained(args.tokenizer_name)
-    elif args.pretrained_model_name_or_path:
-        tokenizer = CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder="tokenizer")
-
-    # Load models and create wrapper for stable diffusion
-    if args.train_only_unet:
-      if os.path.exists(str(args.output_dir+"/text_encoder_trained")):
-        text_encoder = CLIPTextModel.from_pretrained(args.output_dir, subfolder="text_encoder_trained")
-      elif os.path.exists(str(args.output_dir+"/text_encoder")):
-        text_encoder = CLIPTextModel.from_pretrained(args.output_dir, subfolder="text_encoder")
-      else:
-        text_encoder = CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="text_encoder")
-    else:
-      text_encoder = CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="text_encoder")
-    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae")
-    unet = UNet2DConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="unet")
-
-    vae.requires_grad_(False)
-    if not args.train_text_encoder:
-        text_encoder.requires_grad_(False)
-
-    if args.gradient_checkpointing:
-        unet.enable_gradient_checkpointing()
-        if args.train_text_encoder:
-            text_encoder.gradient_checkpointing_enable()
-
-    if args.scale_lr:
-        args.learning_rate = (
-            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
-        )
-
-    # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs
-    if args.use_8bit_adam:
-        try:
-            import bitsandbytes as bnb
-        except ImportError:
-            raise ImportError(
-                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
-            )
-
-        optimizer_class = bnb.optim.AdamW8bit
-    else:
-        optimizer_class = torch.optim.AdamW
-
-    params_to_optimize = (
-        itertools.chain(unet.parameters(), text_encoder.parameters()) if args.train_text_encoder else unet.parameters()
-    )
-    optimizer = optimizer_class(
-        params_to_optimize,
-        lr=args.learning_rate,
-        betas=(args.adam_beta1, args.adam_beta2),
-        weight_decay=args.adam_weight_decay,
-        eps=args.adam_epsilon,
-    )
-
-    noise_scheduler = DDPMScheduler(
-        beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", num_train_timesteps=1000
-    )
-
-    train_dataset = DreamBoothDataset(
-        instance_data_root=args.instance_data_dir,
-        instance_prompt=args.instance_prompt,
-        class_data_root=args.class_data_dir if args.with_prior_preservation else None,
-        class_prompt=args.class_prompt,
-        tokenizer=tokenizer,
-        size=args.resolution,
-        center_crop=args.center_crop,
-        args=args,
-    )
-
-    def collate_fn(examples):
-        input_ids = [example["instance_prompt_ids"] for example in examples]
-        pixel_values = [example["instance_images"] for example in examples]
-
-        # Concat class and instance examples for prior preservation.
-        # We do this to avoid doing two forward passes.
-        if args.with_prior_preservation:
-            input_ids += [example["class_prompt_ids"] for example in examples]
-            pixel_values += [example["class_images"] for example in examples]
-
-        pixel_values = torch.stack(pixel_values)
-        pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
-
-        input_ids = tokenizer.pad({"input_ids": input_ids}, padding=True, return_tensors="pt").input_ids
-
-        batch = {
-            "input_ids": input_ids,
-            "pixel_values": pixel_values,
-        }
-        return batch
-
-    train_dataloader = torch.utils.data.DataLoader(
-        train_dataset, batch_size=args.train_batch_size, shuffle=True, collate_fn=collate_fn
-    )
-
-    # Scheduler and math around the number of training steps.
-    overrode_max_train_steps = False
-    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
-    if args.max_train_steps is None:
-        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
-        overrode_max_train_steps = True
-
-    lr_scheduler = get_scheduler(
-        args.lr_scheduler,
-        optimizer=optimizer,
-        num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps,
-        num_training_steps=args.max_train_steps * args.gradient_accumulation_steps,
-    )
-
-    if args.train_text_encoder:
-        unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
-            unet, text_encoder, optimizer, train_dataloader, lr_scheduler
-        )
-    else:
-        unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
-            unet, optimizer, train_dataloader, lr_scheduler
-        )
-
-    weight_dtype = torch.float32
-    if args.mixed_precision == "fp16":
-        weight_dtype = torch.float16
-    elif args.mixed_precision == "bf16":
-        weight_dtype = torch.bfloat16
-
-    # Move text_encode and vae to gpu.
-    # For mixed precision training we cast the text_encoder and vae weights to half-precision
-    # as these models are only used for inference, keeping weights in full precision is not required.
-    vae.to(accelerator.device, dtype=weight_dtype)
-    if not args.train_text_encoder:
-        text_encoder.to(accelerator.device, dtype=weight_dtype)
-
-    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
-    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
-    if overrode_max_train_steps:
-        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
-    # Afterwards we recalculate our number of training epochs
-    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
-
-    # We need to initialize the trackers we use, and also store our configuration.
-    # The trackers initializes automatically on the main process.
-    if accelerator.is_main_process:
-        accelerator.init_trackers("dreambooth", config=vars(args))
-
-    def bar(prg):
-       br='|'+'█' * prg + ' ' * (25-prg)+'|'
-       return br
-
-    # Train!
-    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
-
-    logger.info("***** Running training *****")
-    logger.info(f"  Num examples = {len(train_dataset)}")
-    logger.info(f"  Num batches each epoch = {len(train_dataloader)}")
-    logger.info(f"  Num Epochs = {args.num_train_epochs}")
-    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
-    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
-    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
-    logger.info(f"  Total optimization steps = {args.max_train_steps}")
-    # Only show the progress bar once on each machine.
-    progress_bar = tqdm(range(args.max_train_steps), disable=not accelerator.is_local_main_process)
-    global_step = 0
-
-    for epoch in range(args.num_train_epochs):
-        unet.train()
-        if args.train_text_encoder:
-            text_encoder.train()
-        for step, batch in enumerate(train_dataloader):
-            with accelerator.accumulate(unet):
-                # Convert images to latent space
-                latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
-                latents = latents * 0.18215
-
-                # Sample noise that we'll add to the latents
-                noise = torch.randn_like(latents)
-                bsz = latents.shape[0]
-                # Sample a random timestep for each image
-                timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device)
-                timesteps = timesteps.long()
-
-                # Add noise to the latents according to the noise magnitude at each timestep
-                # (this is the forward diffusion process)
-                noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
-
-                # Get the text embedding for conditioning
-                encoder_hidden_states = text_encoder(batch["input_ids"])[0]
-
-                # Predict the noise residual
-                noise_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
-                if args.with_prior_preservation:
-                    # Chunk the noise and noise_pred into two parts and compute the loss on each part separately.
-                    noise_pred, noise_pred_prior = torch.chunk(noise_pred, 2, dim=0)
-                    noise, noise_prior = torch.chunk(noise, 2, dim=0)
-
-                    # Compute instance loss
-                    loss = F.mse_loss(noise_pred.float(), noise.float(), reduction="none").mean([1, 2, 3]).mean()
-
-                    # Compute prior loss
-                    prior_loss = F.mse_loss(noise_pred_prior.float(), noise_prior.float(), reduction="mean")
-
-                    # Add the prior loss to the instance loss.
-                    loss = loss + args.prior_loss_weight * prior_loss
-                else:
-                    loss = F.mse_loss(noise_pred.float(), noise.float(), reduction="mean")
-
-                accelerator.backward(loss)
-                if accelerator.sync_gradients:
-                    params_to_clip = (
-                        itertools.chain(unet.parameters(), text_encoder.parameters())
-                        if args.train_text_encoder
-                        else unet.parameters()
-                    )
-                    accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
-                optimizer.step()
-                lr_scheduler.step()
-                optimizer.zero_grad()
-
-            # Checks if the accelerator has performed an optimization step behind the scenes
-            if accelerator.sync_gradients:
-                progress_bar.update(1)
-                global_step += 1
-
-            fll=round((global_step*100)/args.max_train_steps)
-            fll=round(fll/4)
-            pr=bar(fll)
-            
-            logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
-            progress_bar.set_postfix(**logs)
-            progress_bar.set_description_str("Progress:"+pr)
-            accelerator.log(logs, step=global_step)
-
-            if global_step >= args.max_train_steps:
-                break
-
-            if args.train_text_encoder and global_step == args.stop_text_encoder_training and global_step >= 30:
-              if accelerator.is_main_process:
-                print(" " +" Freezing the text_encoder ..."+" ")                
-                frz_dir=args.output_dir + "/text_encoder_frozen"
-                if os.path.exists(frz_dir):
-                  subprocess.call('rm -r '+ frz_dir, shell=True)
-                os.mkdir(frz_dir)
-                pipeline = StableDiffusionPipeline.from_pretrained(
-                    args.pretrained_model_name_or_path,
-                    unet=accelerator.unwrap_model(unet),
-                    text_encoder=accelerator.unwrap_model(text_encoder),
-                )
-                pipeline.text_encoder.save_pretrained(frz_dir)
-                         
-            if args.save_n_steps >= 200:
-               if global_step < args.max_train_steps-100 and global_step+1==i:
-                  ckpt_name = "_step_" + str(global_step+1)
-                  save_dir = Path(args.output_dir+ckpt_name)
-                  save_dir=str(save_dir)
-                  save_dir=save_dir.replace(" ", "_")                    
-                  if not os.path.exists(save_dir):
-                     os.mkdir(save_dir)
-                  inst=save_dir[16:]
-                  inst=inst.replace(" ", "_")
-                  print(" SAVING CHECKPOINT: "+args.Session_dir+"/"+inst+".ckpt")
-                  # Create the pipeline using the trained modules and save it.
-                  if accelerator.is_main_process:
-                     pipeline = StableDiffusionPipeline.from_pretrained(
-                           args.pretrained_model_name_or_path,
-                           unet=accelerator.unwrap_model(unet),
-                           text_encoder=accelerator.unwrap_model(text_encoder),
-                     )
-                     pipeline.save_pretrained(save_dir)
-                     frz_dir=args.output_dir + "/text_encoder_frozen"                    
-                     if args.train_text_encoder and os.path.exists(frz_dir):
-                        subprocess.call('rm -r '+save_dir+'/text_encoder/*.*', shell=True)
-                        subprocess.call('cp -f '+frz_dir +'/*.* '+ save_dir+'/text_encoder', shell=True)                     
-                     chkpth=args.Session_dir+"/"+inst+".ckpt"
-                     subprocess.call('python /content/diffusers/scripts/convert_diffusers_to_original_stable_diffusion.py --model_path ' + save_dir + ' --checkpoint_path ' + chkpth + ' --half', shell=True)
-                     i=i+args.save_n_steps
-            
-        accelerator.wait_for_everyone()
-
-    # Create the pipeline using using the trained modules and save it.
-    if accelerator.is_main_process:
-      if args.dump_only_text_encoder:
-         txt_dir=args.output_dir + "/text_encoder_trained"
-         if not os.path.exists(txt_dir):
-           os.mkdir(txt_dir)
-         pipeline = StableDiffusionPipeline.from_pretrained(
-             args.pretrained_model_name_or_path,
-             unet=accelerator.unwrap_model(unet),
-             text_encoder=accelerator.unwrap_model(text_encoder),
-         )
-         pipeline.text_encoder.save_pretrained(txt_dir)       
-
-      elif args.train_only_unet:
-        pipeline = StableDiffusionPipeline.from_pretrained(
-            args.pretrained_model_name_or_path,
-            unet=accelerator.unwrap_model(unet),
-            text_encoder=accelerator.unwrap_model(text_encoder),
-        )
-        pipeline.save_pretrained(args.output_dir)
-        txt_dir=args.output_dir + "/text_encoder_trained"
-        subprocess.call('rm -r '+txt_dir, shell=True)
-     
-      else:
-        pipeline = StableDiffusionPipeline.from_pretrained(
-            args.pretrained_model_name_or_path,
-            unet=accelerator.unwrap_model(unet),
-            text_encoder=accelerator.unwrap_model(text_encoder),
-        )
-        frz_dir=args.output_dir + "/text_encoder_frozen"
-        pipeline.save_pretrained(args.output_dir)
-        if args.train_text_encoder and os.path.exists(frz_dir):
-           subprocess.call('mv -f '+frz_dir +'/*.* '+ args.output_dir+'/text_encoder', shell=True)
-           subprocess.call('rm -r '+ frz_dir, shell=True) 
-
-        if args.push_to_hub:
-            repo.push_to_hub(commit_message="End of training", blocking=False, auto_lfs_prune=True)
-
-    accelerator.end_training()
-
-if __name__ == "__main__":
-    pass
-    #main()

spaces/Abhilashvj/planogram-compliance/utils/metrics.py

@@ -1,465 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Model validation metrics
-"""
-
-import math
-import warnings
-from pathlib import Path
-
-import matplotlib.pyplot as plt
-import numpy as np
-import torch
-
-from utils import TryExcept, threaded
-
-
-def fitness(x):
-    # Model fitness as a weighted combination of metrics
-    w = [0.0, 0.0, 0.1, 0.9]  # weights for [P, R, [email protected], [email protected]:0.95]
-    return (x[:, :4] * w).sum(1)
-
-
-def smooth(y, f=0.05):
-    # Box filter of fraction f
-    nf = (
-        round(len(y) * f * 2) // 2 + 1
-    )  # number of filter elements (must be odd)
-    p = np.ones(nf // 2)  # ones padding
-    yp = np.concatenate((p * y[0], y, p * y[-1]), 0)  # y padded
-    return np.convolve(yp, np.ones(nf) / nf, mode="valid")  # y-smoothed
-
-
-def ap_per_class(
-    tp,
-    conf,
-    pred_cls,
-    target_cls,
-    plot=False,
-    save_dir=".",
-    names=(),
-    eps=1e-16,
-    prefix="",
-):
-    """Compute the average precision, given the recall and precision curves.
-    Source: https://github.com/rafaelpadilla/Object-Detection-Metrics.
-    # Arguments
-        tp:  True positives (nparray, nx1 or nx10).
-        conf:  Objectness value from 0-1 (nparray).
-        pred_cls:  Predicted object classes (nparray).
-        target_cls:  True object classes (nparray).
-        plot:  Plot precision-recall curve at [email protected]
-        save_dir:  Plot save directory
-    # Returns
-        The average precision as computed in py-faster-rcnn.
-    """
-
-    # Sort by objectness
-    i = np.argsort(-conf)
-    tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]
-
-    # Find unique classes
-    unique_classes, nt = np.unique(target_cls, return_counts=True)
-    nc = unique_classes.shape[0]  # number of classes, number of detections
-
-    # Create Precision-Recall curve and compute AP for each class
-    px, py = np.linspace(0, 1, 1000), []  # for plotting
-    ap, p, r = (
-        np.zeros((nc, tp.shape[1])),
-        np.zeros((nc, 1000)),
-        np.zeros((nc, 1000)),
-    )
-    for ci, c in enumerate(unique_classes):
-        i = pred_cls == c
-        n_l = nt[ci]  # number of labels
-        n_p = i.sum()  # number of predictions
-        if n_p == 0 or n_l == 0:
-            continue
-
-        # Accumulate FPs and TPs
-        fpc = (1 - tp[i]).cumsum(0)
-        tpc = tp[i].cumsum(0)
-
-        # Recall
-        recall = tpc / (n_l + eps)  # recall curve
-        r[ci] = np.interp(
-            -px, -conf[i], recall[:, 0], left=0
-        )  # negative x, xp because xp decreases
-
-        # Precision
-        precision = tpc / (tpc + fpc)  # precision curve
-        p[ci] = np.interp(
-            -px, -conf[i], precision[:, 0], left=1
-        )  # p at pr_score
-
-        # AP from recall-precision curve
-        for j in range(tp.shape[1]):
-            ap[ci, j], mpre, mrec = compute_ap(recall[:, j], precision[:, j])
-            if plot and j == 0:
-                py.append(np.interp(px, mrec, mpre))  # precision at [email protected]
-
-    # Compute F1 (harmonic mean of precision and recall)
-    f1 = 2 * p * r / (p + r + eps)
-    names = [
-        v for k, v in names.items() if k in unique_classes
-    ]  # list: only classes that have data
-    names = dict(enumerate(names))  # to dict
-    if plot:
-        plot_pr_curve(
-            px, py, ap, Path(save_dir) / f"{prefix}PR_curve.png", names
-        )
-        plot_mc_curve(
-            px,
-            f1,
-            Path(save_dir) / f"{prefix}F1_curve.png",
-            names,
-            ylabel="F1",
-        )
-        plot_mc_curve(
-            px,
-            p,
-            Path(save_dir) / f"{prefix}P_curve.png",
-            names,
-            ylabel="Precision",
-        )
-        plot_mc_curve(
-            px,
-            r,
-            Path(save_dir) / f"{prefix}R_curve.png",
-            names,
-            ylabel="Recall",
-        )
-
-    i = smooth(f1.mean(0), 0.1).argmax()  # max F1 index
-    p, r, f1 = p[:, i], r[:, i], f1[:, i]
-    tp = (r * nt).round()  # true positives
-    fp = (tp / (p + eps) - tp).round()  # false positives
-    return tp, fp, p, r, f1, ap, unique_classes.astype(int)
-
-
-def compute_ap(recall, precision):
-    """Compute the average precision, given the recall and precision curves
-    # Arguments
-        recall:    The recall curve (list)
-        precision: The precision curve (list)
-    # Returns
-        Average precision, precision curve, recall curve
-    """
-
-    # Append sentinel values to beginning and end
-    mrec = np.concatenate(([0.0], recall, [1.0]))
-    mpre = np.concatenate(([1.0], precision, [0.0]))
-
-    # Compute the precision envelope
-    mpre = np.flip(np.maximum.accumulate(np.flip(mpre)))
-
-    # Integrate area under curve
-    method = "interp"  # methods: 'continuous', 'interp'
-    if method == "interp":
-        x = np.linspace(0, 1, 101)  # 101-point interp (COCO)
-        ap = np.trapz(np.interp(x, mrec, mpre), x)  # integrate
-    else:  # 'continuous'
-        i = np.where(mrec[1:] != mrec[:-1])[
-            0
-        ]  # points where x axis (recall) changes
-        ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])  # area under curve
-
-    return ap, mpre, mrec
-
-
-class ConfusionMatrix:
-    # Updated version of https://github.com/kaanakan/object_detection_confusion_matrix
-    def __init__(self, nc, conf=0.25, iou_thres=0.45):
-        self.matrix = np.zeros((nc + 1, nc + 1))
-        self.nc = nc  # number of classes
-        self.conf = conf
-        self.iou_thres = iou_thres
-
-    def process_batch(self, detections, labels):
-        """
-        Return intersection-over-union (Jaccard index) of boxes.
-        Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
-        Arguments:
-            detections (Array[N, 6]), x1, y1, x2, y2, conf, class
-            labels (Array[M, 5]), class, x1, y1, x2, y2
-        Returns:
-            None, updates confusion matrix accordingly
-        """
-        if detections is None:
-            gt_classes = labels.int()
-            for gc in gt_classes:
-                self.matrix[self.nc, gc] += 1  # background FN
-            return
-
-        detections = detections[detections[:, 4] > self.conf]
-        gt_classes = labels[:, 0].int()
-        detection_classes = detections[:, 5].int()
-        iou = box_iou(labels[:, 1:], detections[:, :4])
-
-        x = torch.where(iou > self.iou_thres)
-        if x[0].shape[0]:
-            matches = (
-                torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1)
-                .cpu()
-                .numpy()
-            )
-            if x[0].shape[0] > 1:
-                matches = matches[matches[:, 2].argsort()[::-1]]
-                matches = matches[
-                    np.unique(matches[:, 1], return_index=True)[1]
-                ]
-                matches = matches[matches[:, 2].argsort()[::-1]]
-                matches = matches[
-                    np.unique(matches[:, 0], return_index=True)[1]
-                ]
-        else:
-            matches = np.zeros((0, 3))
-
-        n = matches.shape[0] > 0
-        m0, m1, _ = matches.transpose().astype(int)
-        for i, gc in enumerate(gt_classes):
-            j = m0 == i
-            if n and sum(j) == 1:
-                self.matrix[detection_classes[m1[j]], gc] += 1  # correct
-            else:
-                self.matrix[self.nc, gc] += 1  # true background
-
-        if n:
-            for i, dc in enumerate(detection_classes):
-                if not any(m1 == i):
-                    self.matrix[dc, self.nc] += 1  # predicted background
-
-    def tp_fp(self):
-        tp = self.matrix.diagonal()  # true positives
-        fp = self.matrix.sum(1) - tp  # false positives
-        # fn = self.matrix.sum(0) - tp  # false negatives (missed detections)
-        return tp[:-1], fp[:-1]  # remove background class
-
-    @TryExcept("WARNING ⚠️ ConfusionMatrix plot failure")
-    def plot(self, normalize=True, save_dir="", names=()):
-        import seaborn as sn
-
-        array = self.matrix / (
-            (self.matrix.sum(0).reshape(1, -1) + 1e-9) if normalize else 1
-        )  # normalize columns
-        array[array < 0.005] = np.nan  # don't annotate (would appear as 0.00)
-
-        fig, ax = plt.subplots(1, 1, figsize=(12, 9), tight_layout=True)
-        nc, nn = self.nc, len(names)  # number of classes, names
-        sn.set(font_scale=1.0 if nc < 50 else 0.8)  # for label size
-        labels = (0 < nn < 99) and (nn == nc)  # apply names to ticklabels
-        ticklabels = (names + ["background"]) if labels else "auto"
-        with warnings.catch_warnings():
-            warnings.simplefilter(
-                "ignore"
-            )  # suppress empty matrix RuntimeWarning: All-NaN slice encountered
-            sn.heatmap(
-                array,
-                ax=ax,
-                annot=nc < 30,
-                annot_kws={"size": 8},
-                cmap="Blues",
-                fmt=".2f",
-                square=True,
-                vmin=0.0,
-                xticklabels=ticklabels,
-                yticklabels=ticklabels,
-            ).set_facecolor((1, 1, 1))
-        ax.set_ylabel("True")
-        ax.set_ylabel("Predicted")
-        ax.set_title("Confusion Matrix")
-        fig.savefig(Path(save_dir) / "confusion_matrix.png", dpi=250)
-        plt.close(fig)
-
-    def print(self):
-        for i in range(self.nc + 1):
-            print(" ".join(map(str, self.matrix[i])))
-
-
-def bbox_iou(
-    box1, box2, xywh=True, GIoU=False, DIoU=False, CIoU=False, eps=1e-7
-):
-    # Returns Intersection over Union (IoU) of box1(1,4) to box2(n,4)
-
-    # Get the coordinates of bounding boxes
-    if xywh:  # transform from xywh to xyxy
-        (x1, y1, w1, h1), (x2, y2, w2, h2) = box1.chunk(4, -1), box2.chunk(
-            4, -1
-        )
-        w1_, h1_, w2_, h2_ = w1 / 2, h1 / 2, w2 / 2, h2 / 2
-        b1_x1, b1_x2, b1_y1, b1_y2 = x1 - w1_, x1 + w1_, y1 - h1_, y1 + h1_
-        b2_x1, b2_x2, b2_y1, b2_y2 = x2 - w2_, x2 + w2_, y2 - h2_, y2 + h2_
-    else:  # x1, y1, x2, y2 = box1
-        b1_x1, b1_y1, b1_x2, b1_y2 = box1.chunk(4, -1)
-        b2_x1, b2_y1, b2_x2, b2_y2 = box2.chunk(4, -1)
-        w1, h1 = b1_x2 - b1_x1, (b1_y2 - b1_y1).clamp(eps)
-        w2, h2 = b2_x2 - b2_x1, (b2_y2 - b2_y1).clamp(eps)
-
-    # Intersection area
-    inter = (b1_x2.minimum(b2_x2) - b1_x1.maximum(b2_x1)).clamp(0) * (
-        b1_y2.minimum(b2_y2) - b1_y1.maximum(b2_y1)
-    ).clamp(0)
-
-    # Union Area
-    union = w1 * h1 + w2 * h2 - inter + eps
-
-    # IoU
-    iou = inter / union
-    if CIoU or DIoU or GIoU:
-        cw = b1_x2.maximum(b2_x2) - b1_x1.minimum(
-            b2_x1
-        )  # convex (smallest enclosing box) width
-        ch = b1_y2.maximum(b2_y2) - b1_y1.minimum(b2_y1)  # convex height
-        if (
-            CIoU or DIoU
-        ):  # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1
-            c2 = cw**2 + ch**2 + eps  # convex diagonal squared
-            rho2 = (
-                (b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2
-                + (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2
-            ) / 4  # center dist ** 2
-            if (
-                CIoU
-            ):  # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47
-                v = (4 / math.pi**2) * (
-                    torch.atan(w2 / h2) - torch.atan(w1 / h1)
-                ).pow(2)
-                with torch.no_grad():
-                    alpha = v / (v - iou + (1 + eps))
-                return iou - (rho2 / c2 + v * alpha)  # CIoU
-            return iou - rho2 / c2  # DIoU
-        c_area = cw * ch + eps  # convex area
-        return (
-            iou - (c_area - union) / c_area
-        )  # GIoU https://arxiv.org/pdf/1902.09630.pdf
-    return iou  # IoU
-
-
-def box_iou(box1, box2, eps=1e-7):
-    # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py
-    """
-    Return intersection-over-union (Jaccard index) of boxes.
-    Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
-    Arguments:
-        box1 (Tensor[N, 4])
-        box2 (Tensor[M, 4])
-    Returns:
-        iou (Tensor[N, M]): the NxM matrix containing the pairwise
-            IoU values for every element in boxes1 and boxes2
-    """
-
-    # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)
-    (a1, a2), (b1, b2) = box1.unsqueeze(1).chunk(2, 2), box2.unsqueeze(
-        0
-    ).chunk(2, 2)
-    inter = (torch.min(a2, b2) - torch.max(a1, b1)).clamp(0).prod(2)
-
-    # IoU = inter / (area1 + area2 - inter)
-    return inter / ((a2 - a1).prod(2) + (b2 - b1).prod(2) - inter + eps)
-
-
-def bbox_ioa(box1, box2, eps=1e-7):
-    """Returns the intersection over box2 area given box1, box2. Boxes are x1y1x2y2
-    box1:       np.array of shape(4)
-    box2:       np.array of shape(nx4)
-    returns:    np.array of shape(n)
-    """
-
-    # Get the coordinates of bounding boxes
-    b1_x1, b1_y1, b1_x2, b1_y2 = box1
-    b2_x1, b2_y1, b2_x2, b2_y2 = box2.T
-
-    # Intersection area
-    inter_area = (np.minimum(b1_x2, b2_x2) - np.maximum(b1_x1, b2_x1)).clip(
-        0
-    ) * (np.minimum(b1_y2, b2_y2) - np.maximum(b1_y1, b2_y1)).clip(0)
-
-    # box2 area
-    box2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1) + eps
-
-    # Intersection over box2 area
-    return inter_area / box2_area
-
-
-def wh_iou(wh1, wh2, eps=1e-7):
-    # Returns the nxm IoU matrix. wh1 is nx2, wh2 is mx2
-    wh1 = wh1[:, None]  # [N,1,2]
-    wh2 = wh2[None]  # [1,M,2]
-    inter = torch.min(wh1, wh2).prod(2)  # [N,M]
-    return inter / (
-        wh1.prod(2) + wh2.prod(2) - inter + eps
-    )  # iou = inter / (area1 + area2 - inter)
-
-
-# Plots ----------------------------------------------------------------------------------------------------------------
-
-
-@threaded
-def plot_pr_curve(px, py, ap, save_dir=Path("pr_curve.png"), names=()):
-    # Precision-recall curve
-    fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
-    py = np.stack(py, axis=1)
-
-    if 0 < len(names) < 21:  # display per-class legend if < 21 classes
-        for i, y in enumerate(py.T):
-            ax.plot(
-                px, y, linewidth=1, label=f"{names[i]} {ap[i, 0]:.3f}"
-            )  # plot(recall, precision)
-    else:
-        ax.plot(px, py, linewidth=1, color="grey")  # plot(recall, precision)
-
-    ax.plot(
-        px,
-        py.mean(1),
-        linewidth=3,
-        color="blue",
-        label="all classes %.3f [email protected]" % ap[:, 0].mean(),
-    )
-    ax.set_xlabel("Recall")
-    ax.set_ylabel("Precision")
-    ax.set_xlim(0, 1)
-    ax.set_ylim(0, 1)
-    ax.legend(bbox_to_anchor=(1.04, 1), loc="upper left")
-    ax.set_title("Precision-Recall Curve")
-    fig.savefig(save_dir, dpi=250)
-    plt.close(fig)
-
-
-@threaded
-def plot_mc_curve(
-    px,
-    py,
-    save_dir=Path("mc_curve.png"),
-    names=(),
-    xlabel="Confidence",
-    ylabel="Metric",
-):
-    # Metric-confidence curve
-    fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
-
-    if 0 < len(names) < 21:  # display per-class legend if < 21 classes
-        for i, y in enumerate(py):
-            ax.plot(
-                px, y, linewidth=1, label=f"{names[i]}"
-            )  # plot(confidence, metric)
-    else:
-        ax.plot(
-            px, py.T, linewidth=1, color="grey"
-        )  # plot(confidence, metric)
-
-    y = smooth(py.mean(0), 0.05)
-    ax.plot(
-        px,
-        y,
-        linewidth=3,
-        color="blue",
-        label=f"all classes {y.max():.2f} at {px[y.argmax()]:.3f}",
-    )
-    ax.set_xlabel(xlabel)
-    ax.set_ylabel(ylabel)
-    ax.set_xlim(0, 1)
-    ax.set_ylim(0, 1)
-    ax.legend(bbox_to_anchor=(1.04, 1), loc="upper left")
-    ax.set_title(f"{ylabel}-Confidence Curve")
-    fig.savefig(save_dir, dpi=250)
-    plt.close(fig)

spaces/Adapter/T2I-Adapter/ldm/modules/extra_condition/openpose/util.py

@@ -1,203 +0,0 @@
-import math
-
-import cv2
-import matplotlib
-import numpy as np
-
-
-def padRightDownCorner(img, stride, padValue):
-    h = img.shape[0]
-    w = img.shape[1]
-
-    pad = 4 * [None]
-    pad[0] = 0  # up
-    pad[1] = 0  # left
-    pad[2] = 0 if (h % stride == 0) else stride - (h % stride)  # down
-    pad[3] = 0 if (w % stride == 0) else stride - (w % stride)  # right
-
-    img_padded = img
-    pad_up = np.tile(img_padded[0:1, :, :] * 0 + padValue, (pad[0], 1, 1))
-    img_padded = np.concatenate((pad_up, img_padded), axis=0)
-    pad_left = np.tile(img_padded[:, 0:1, :] * 0 + padValue, (1, pad[1], 1))
-    img_padded = np.concatenate((pad_left, img_padded), axis=1)
-    pad_down = np.tile(img_padded[-2:-1, :, :] * 0 + padValue, (pad[2], 1, 1))
-    img_padded = np.concatenate((img_padded, pad_down), axis=0)
-    pad_right = np.tile(img_padded[:, -2:-1, :] * 0 + padValue, (1, pad[3], 1))
-    img_padded = np.concatenate((img_padded, pad_right), axis=1)
-
-    return img_padded, pad
-
-
-# transfer caffe model to pytorch which will match the layer name
-def transfer(model, model_weights):
-    transfered_model_weights = {}
-    for weights_name in model.state_dict().keys():
-        transfered_model_weights[weights_name] = model_weights['.'.join(weights_name.split('.')[1:])]
-    return transfered_model_weights
-
-
-# draw the body keypoint and lims
-def draw_bodypose(canvas, candidate, subset):
-    stickwidth = 4
-    limbSeq = [[2, 3], [2, 6], [3, 4], [4, 5], [6, 7], [7, 8], [2, 9], [9, 10], \
-               [10, 11], [2, 12], [12, 13], [13, 14], [2, 1], [1, 15], [15, 17], \
-               [1, 16], [16, 18], [3, 17], [6, 18]]
-
-    colors = [[255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0], [85, 255, 0], [0, 255, 0], \
-              [0, 255, 85], [0, 255, 170], [0, 255, 255], [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255], \
-              [170, 0, 255], [255, 0, 255], [255, 0, 170], [255, 0, 85]]
-    for i in range(18):
-        for n in range(len(subset)):
-            index = int(subset[n][i])
-            if index == -1:
-                continue
-            x, y = candidate[index][0:2]
-            cv2.circle(canvas, (int(x), int(y)), 4, colors[i], thickness=-1)
-    for i in range(17):
-        for n in range(len(subset)):
-            index = subset[n][np.array(limbSeq[i]) - 1]
-            if -1 in index:
-                continue
-            cur_canvas = canvas.copy()
-            Y = candidate[index.astype(int), 0]
-            X = candidate[index.astype(int), 1]
-            mX = np.mean(X)
-            mY = np.mean(Y)
-            length = ((X[0] - X[1])**2 + (Y[0] - Y[1])**2)**0.5
-            angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
-            polygon = cv2.ellipse2Poly((int(mY), int(mX)), (int(length / 2), stickwidth), int(angle), 0, 360, 1)
-            cv2.fillConvexPoly(cur_canvas, polygon, colors[i])
-            canvas = cv2.addWeighted(canvas, 0.4, cur_canvas, 0.6, 0)
-    # plt.imsave("preview.jpg", canvas[:, :, [2, 1, 0]])
-    # plt.imshow(canvas[:, :, [2, 1, 0]])
-    return canvas
-
-
-# image drawed by opencv is not good.
-def draw_handpose(canvas, all_hand_peaks, show_number=False):
-    edges = [[0, 1], [1, 2], [2, 3], [3, 4], [0, 5], [5, 6], [6, 7], [7, 8], [0, 9], [9, 10], \
-             [10, 11], [11, 12], [0, 13], [13, 14], [14, 15], [15, 16], [0, 17], [17, 18], [18, 19], [19, 20]]
-
-    for peaks in all_hand_peaks:
-        for ie, e in enumerate(edges):
-            if np.sum(np.all(peaks[e], axis=1) == 0) == 0:
-                x1, y1 = peaks[e[0]]
-                x2, y2 = peaks[e[1]]
-                cv2.line(
-                    canvas, (x1, y1), (x2, y2),
-                    matplotlib.colors.hsv_to_rgb([ie / float(len(edges)), 1.0, 1.0]) * 255,
-                    thickness=2)
-
-        for i, keyponit in enumerate(peaks):
-            x, y = keyponit
-            cv2.circle(canvas, (x, y), 4, (0, 0, 255), thickness=-1)
-            if show_number:
-                cv2.putText(canvas, str(i), (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 0), lineType=cv2.LINE_AA)
-    return canvas
-
-
-# detect hand according to body pose keypoints
-# please refer to https://github.com/CMU-Perceptual-Computing-Lab/openpose/blob/master/src/openpose/hand/handDetector.cpp
-def handDetect(candidate, subset, oriImg):
-    # right hand: wrist 4, elbow 3, shoulder 2
-    # left hand: wrist 7, elbow 6, shoulder 5
-    ratioWristElbow = 0.33
-    detect_result = []
-    image_height, image_width = oriImg.shape[0:2]
-    for person in subset.astype(int):
-        # if any of three not detected
-        has_left = np.sum(person[[5, 6, 7]] == -1) == 0
-        has_right = np.sum(person[[2, 3, 4]] == -1) == 0
-        if not (has_left or has_right):
-            continue
-        hands = []
-        #left hand
-        if has_left:
-            left_shoulder_index, left_elbow_index, left_wrist_index = person[[5, 6, 7]]
-            x1, y1 = candidate[left_shoulder_index][:2]
-            x2, y2 = candidate[left_elbow_index][:2]
-            x3, y3 = candidate[left_wrist_index][:2]
-            hands.append([x1, y1, x2, y2, x3, y3, True])
-        # right hand
-        if has_right:
-            right_shoulder_index, right_elbow_index, right_wrist_index = person[[2, 3, 4]]
-            x1, y1 = candidate[right_shoulder_index][:2]
-            x2, y2 = candidate[right_elbow_index][:2]
-            x3, y3 = candidate[right_wrist_index][:2]
-            hands.append([x1, y1, x2, y2, x3, y3, False])
-
-        for x1, y1, x2, y2, x3, y3, is_left in hands:
-            # pos_hand = pos_wrist + ratio * (pos_wrist - pos_elbox) = (1 + ratio) * pos_wrist - ratio * pos_elbox
-            # handRectangle.x = posePtr[wrist*3] + ratioWristElbow * (posePtr[wrist*3] - posePtr[elbow*3]);
-            # handRectangle.y = posePtr[wrist*3+1] + ratioWristElbow * (posePtr[wrist*3+1] - posePtr[elbow*3+1]);
-            # const auto distanceWristElbow = getDistance(poseKeypoints, person, wrist, elbow);
-            # const auto distanceElbowShoulder = getDistance(poseKeypoints, person, elbow, shoulder);
-            # handRectangle.width = 1.5f * fastMax(distanceWristElbow, 0.9f * distanceElbowShoulder);
-            x = x3 + ratioWristElbow * (x3 - x2)
-            y = y3 + ratioWristElbow * (y3 - y2)
-            distanceWristElbow = math.sqrt((x3 - x2)**2 + (y3 - y2)**2)
-            distanceElbowShoulder = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
-            width = 1.5 * max(distanceWristElbow, 0.9 * distanceElbowShoulder)
-            # x-y refers to the center --> offset to topLeft point
-            # handRectangle.x -= handRectangle.width / 2.f;
-            # handRectangle.y -= handRectangle.height / 2.f;
-            x -= width / 2
-            y -= width / 2  # width = height
-            # overflow the image
-            if x < 0: x = 0
-            if y < 0: y = 0
-            width1 = width
-            width2 = width
-            if x + width > image_width: width1 = image_width - x
-            if y + width > image_height: width2 = image_height - y
-            width = min(width1, width2)
-            # the max hand box value is 20 pixels
-            if width >= 20:
-                detect_result.append([int(x), int(y), int(width), is_left])
-    '''
-    return value: [[x, y, w, True if left hand else False]].
-    width=height since the network require squared input.
-    x, y is the coordinate of top left
-    '''
-    return detect_result
-
-
-# get max index of 2d array
-def npmax(array):
-    arrayindex = array.argmax(1)
-    arrayvalue = array.max(1)
-    i = arrayvalue.argmax()
-    j = arrayindex[i]
-    return i, j
-
-
-def HWC3(x):
-    assert x.dtype == np.uint8
-    if x.ndim == 2:
-        x = x[:, :, None]
-    assert x.ndim == 3
-    H, W, C = x.shape
-    assert C == 1 or C == 3 or C == 4
-    if C == 3:
-        return x
-    if C == 1:
-        return np.concatenate([x, x, x], axis=2)
-    if C == 4:
-        color = x[:, :, 0:3].astype(np.float32)
-        alpha = x[:, :, 3:4].astype(np.float32) / 255.0
-        y = color * alpha + 255.0 * (1.0 - alpha)
-        y = y.clip(0, 255).astype(np.uint8)
-        return y
-
-
-def resize_image(input_image, resolution):
-    H, W, C = input_image.shape
-    H = float(H)
-    W = float(W)
-    k = float(resolution) / min(H, W)
-    H *= k
-    W *= k
-    H = int(np.round(H / 64.0)) * 64
-    W = int(np.round(W / 64.0)) * 64
-    img = cv2.resize(input_image, (W, H), interpolation=cv2.INTER_LANCZOS4 if k > 1 else cv2.INTER_AREA)
-    return img

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/facebook/Facebook.d.ts

@@ -1,2 +0,0 @@
-import Base from '../base/Base';
-export default class Facebook extends Base { }

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/hiddenedit/HiddenEdit.js

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

spaces/AlexWang/lama/saicinpainting/training/modules/fake_fakes.py

@@ -1,47 +0,0 @@
-import torch
-from kornia import SamplePadding
-from kornia.augmentation import RandomAffine, CenterCrop
-
-
-class FakeFakesGenerator:
-    def __init__(self, aug_proba=0.5, img_aug_degree=30, img_aug_translate=0.2):
-        self.grad_aug = RandomAffine(degrees=360,
-                                     translate=0.2,
-                                     padding_mode=SamplePadding.REFLECTION,
-                                     keepdim=False,
-                                     p=1)
-        self.img_aug = RandomAffine(degrees=img_aug_degree,
-                                    translate=img_aug_translate,
-                                    padding_mode=SamplePadding.REFLECTION,
-                                    keepdim=True,
-                                    p=1)
-        self.aug_proba = aug_proba
-
-    def __call__(self, input_images, masks):
-        blend_masks = self._fill_masks_with_gradient(masks)
-        blend_target = self._make_blend_target(input_images)
-        result = input_images * (1 - blend_masks) + blend_target * blend_masks
-        return result, blend_masks
-
-    def _make_blend_target(self, input_images):
-        batch_size = input_images.shape[0]
-        permuted = input_images[torch.randperm(batch_size)]
-        augmented = self.img_aug(input_images)
-        is_aug = (torch.rand(batch_size, device=input_images.device)[:, None, None, None] < self.aug_proba).float()
-        result = augmented * is_aug + permuted * (1 - is_aug)
-        return result
-
-    def _fill_masks_with_gradient(self, masks):
-        batch_size, _, height, width = masks.shape
-        grad = torch.linspace(0, 1, steps=width * 2, device=masks.device, dtype=masks.dtype) \
-            .view(1, 1, 1, -1).expand(batch_size, 1, height * 2, width * 2)
-        grad = self.grad_aug(grad)
-        grad = CenterCrop((height, width))(grad)
-        grad *= masks
-
-        grad_for_min = grad + (1 - masks) * 10
-        grad -= grad_for_min.view(batch_size, -1).min(-1).values[:, None, None, None]
-        grad /= grad.view(batch_size, -1).max(-1).values[:, None, None, None] + 1e-6
-        grad.clamp_(min=0, max=1)
-
-        return grad

spaces/Amr453/Transcription/app.py

@@ -1,109 +0,0 @@
-import whisper
-import gradio as gr
-import datetime
-
-import subprocess
-
-import torch
-import pyannote.audio
-from pyannote.audio.pipelines.speaker_verification import PretrainedSpeakerEmbedding
-
-from pyannote.audio import Audio
-from pyannote.core import Segment
-
-import wave
-import contextlib
-
-from sklearn.cluster import AgglomerativeClustering
-import numpy as np
-
-model = whisper.load_model("large-v2")
-embedding_model = PretrainedSpeakerEmbedding( 
-    "speechbrain/spkrec-ecapa-voxceleb",
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-)
-
-def transcribe(audio, num_speakers):
-  path, error = convert_to_wav(audio)
-  if error is not None:
-    return error
-
-  duration = get_duration(path)
-  if duration > 4 * 60 * 60:
-    return "Audio duration too long"
-
-  result = model.transcribe(path)
-  segments = result["segments"]
-
-  num_speakers = min(max(round(num_speakers), 1), len(segments))
-  if len(segments) == 1:
-    segments[0]['speaker'] = 'SPEAKER 1'
-  else:
-    embeddings = make_embeddings(path, segments, duration)
-    add_speaker_labels(segments, embeddings, num_speakers)
-  output = get_output(segments)
-  return output
-
-def convert_to_wav(path):
-  if path[-3:] != 'wav':
-    new_path = '.'.join(path.split('.')[:-1]) + '.wav'
-    try:
-      subprocess.call(['ffmpeg', '-i', path, new_path, '-y'])
-    except:
-      return path, 'Error: Could not convert file to .wav'
-    path = new_path
-  return path, None
-
-def get_duration(path):
-  with contextlib.closing(wave.open(path,'r')) as f:
-    frames = f.getnframes()
-    rate = f.getframerate()
-    return frames / float(rate)
-
-def make_embeddings(path, segments, duration):
-  embeddings = np.zeros(shape=(len(segments), 192))
-  for i, segment in enumerate(segments):
-    embeddings[i] = segment_embedding(path, segment, duration)
-  return np.nan_to_num(embeddings)
-
-audio = Audio()
-
-def segment_embedding(path, segment, duration):
-  start = segment["start"]
-  # Whisper overshoots the end timestamp in the last segment
-  end = min(duration, segment["end"])
-  clip = Segment(start, end)
-  waveform, sample_rate = audio.crop(path, clip)
-  return embedding_model(waveform[None])
-
-def add_speaker_labels(segments, embeddings, num_speakers):
-  clustering = AgglomerativeClustering(num_speakers).fit(embeddings)
-  labels = clustering.labels_
-  for i in range(len(segments)):
-    segments[i]["speaker"] = 'SPEAKER ' + str(labels[i] + 1)
-
-def time(secs):
-  return datetime.timedelta(seconds=round(secs))
-
-def get_output(segments):
-  output = ''
-  for (i, segment) in enumerate(segments):
-    if i == 0 or segments[i - 1]["speaker"] != segment["speaker"]:
-      if i != 0:
-        output += '\n\n'
-      output += segment["speaker"] + ' ' + str(time(segment["start"])) + '\n\n'
-    output += segment["text"][1:] + ' '
-  return output
-
-gr.Interface(
-    title = 'Whisper with Speaker Recognition', 
-    fn=transcribe, 
-    inputs=[
-        gr.inputs.Audio(source="upload", type="filepath"),
-        gr.inputs.Number(default=2, label="Number of Speakers")
-
-    ],
-    outputs=[
-        gr.outputs.Textbox(label='Transcript')
-    ]
-  ).launch()

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/latent_diffusion/test_latent_diffusion_uncond.py

@@ -1,116 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# 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 unittest
-
-import numpy as np
-import torch
-from transformers import CLIPTextConfig, CLIPTextModel
-
-from diffusers import DDIMScheduler, LDMPipeline, UNet2DModel, VQModel
-from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device
-
-
-enable_full_determinism()
-
-
-class LDMPipelineFastTests(unittest.TestCase):
-    @property
-    def dummy_uncond_unet(self):
-        torch.manual_seed(0)
-        model = UNet2DModel(
-            block_out_channels=(32, 64),
-            layers_per_block=2,
-            sample_size=32,
-            in_channels=3,
-            out_channels=3,
-            down_block_types=("DownBlock2D", "AttnDownBlock2D"),
-            up_block_types=("AttnUpBlock2D", "UpBlock2D"),
-        )
-        return model
-
-    @property
-    def dummy_vq_model(self):
-        torch.manual_seed(0)
-        model = VQModel(
-            block_out_channels=[32, 64],
-            in_channels=3,
-            out_channels=3,
-            down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],
-            up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],
-            latent_channels=3,
-        )
-        return model
-
-    @property
-    def dummy_text_encoder(self):
-        torch.manual_seed(0)
-        config = CLIPTextConfig(
-            bos_token_id=0,
-            eos_token_id=2,
-            hidden_size=32,
-            intermediate_size=37,
-            layer_norm_eps=1e-05,
-            num_attention_heads=4,
-            num_hidden_layers=5,
-            pad_token_id=1,
-            vocab_size=1000,
-        )
-        return CLIPTextModel(config)
-
-    def test_inference_uncond(self):
-        unet = self.dummy_uncond_unet
-        scheduler = DDIMScheduler()
-        vae = self.dummy_vq_model
-
-        ldm = LDMPipeline(unet=unet, vqvae=vae, scheduler=scheduler)
-        ldm.to(torch_device)
-        ldm.set_progress_bar_config(disable=None)
-
-        generator = torch.manual_seed(0)
-        image = ldm(generator=generator, num_inference_steps=2, output_type="numpy").images
-
-        generator = torch.manual_seed(0)
-        image_from_tuple = ldm(generator=generator, num_inference_steps=2, output_type="numpy", return_dict=False)[0]
-
-        image_slice = image[0, -3:, -3:, -1]
-        image_from_tuple_slice = image_from_tuple[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 64, 64, 3)
-        expected_slice = np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172])
-        tolerance = 1e-2 if torch_device != "mps" else 3e-2
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < tolerance
-        assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < tolerance
-
-
-@slow
-@require_torch
-class LDMPipelineIntegrationTests(unittest.TestCase):
-    def test_inference_uncond(self):
-        ldm = LDMPipeline.from_pretrained("CompVis/ldm-celebahq-256")
-        ldm.to(torch_device)
-        ldm.set_progress_bar_config(disable=None)
-
-        generator = torch.manual_seed(0)
-        image = ldm(generator=generator, num_inference_steps=5, output_type="numpy").images
-
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 256, 256, 3)
-        expected_slice = np.array([0.4399, 0.44975, 0.46825, 0.474, 0.4359, 0.4581, 0.45095, 0.4341, 0.4447])
-        tolerance = 1e-2 if torch_device != "mps" else 3e-2
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < tolerance

spaces/Andy1621/uniformer_image_segmentation/configs/mobilenet_v2/fcn_m-v2-d8_512x1024_80k_cityscapes.py

@@ -1,12 +0,0 @@
-_base_ = '../fcn/fcn_r101-d8_512x1024_80k_cityscapes.py'
-model = dict(
-    pretrained='mmcls://mobilenet_v2',
-    backbone=dict(
-        _delete_=True,
-        type='MobileNetV2',
-        widen_factor=1.,
-        strides=(1, 2, 2, 1, 1, 1, 1),
-        dilations=(1, 1, 1, 2, 2, 4, 4),
-        out_indices=(1, 2, 4, 6)),
-    decode_head=dict(in_channels=320),
-    auxiliary_head=dict(in_channels=96))

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/docs/Audio-Notification.md

@@ -1,14 +0,0 @@
-# Audio notification
-
-If your computer takes a long time to generate each response for the model that you are using, you can enable an audio notification for when the response is completed. This feature was kindly contributed by HappyWorldGames in [#1277](https://github.com/oobabooga/text-generation-webui/pull/1277).
-
-### Installation
-
-Simply place a file called "notification.mp3" in the same folder as `server.py`. Here you can find some examples:
-
-* https://pixabay.com/sound-effects/search/ding/?duration=0-30
-* https://pixabay.com/sound-effects/search/notification/?duration=0-30
-
-Source: https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/1126
-
-This file will be automatically detected the next time you start the web UI.

spaces/AquaSuisei/ChatGPTXE/modules/openai_func.py

@@ -1,65 +0,0 @@
-import requests
-import logging
-from modules.presets import (
-    timeout_all,
-    USAGE_API_URL,
-    BALANCE_API_URL,
-    standard_error_msg,
-    connection_timeout_prompt,
-    error_retrieve_prompt,
-    read_timeout_prompt
-)
-
-from . import shared
-from modules.config import retrieve_proxy
-import os, datetime
-
-def get_billing_data(openai_api_key, billing_url):
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {openai_api_key}"
-    }
-
-    timeout = timeout_all
-    with retrieve_proxy():
-        response = requests.get(
-            billing_url,
-            headers=headers,
-            timeout=timeout,
-        )
-
-    if response.status_code == 200:
-        data = response.json()
-        return data
-    else:
-        raise Exception(f"API request failed with status code {response.status_code}: {response.text}")
-
-
-def get_usage(openai_api_key):
-    try:
-        curr_time = datetime.datetime.now()
-        last_day_of_month = get_last_day_of_month(curr_time).strftime("%Y-%m-%d")
-        first_day_of_month = curr_time.replace(day=1).strftime("%Y-%m-%d")
-        usage_url = f"{shared.state.usage_api_url}?start_date={first_day_of_month}&end_date={last_day_of_month}"
-        try:
-            usage_data = get_billing_data(openai_api_key, usage_url)
-        except Exception as e:
-            logging.error(f"获取API使用情况失败:"+str(e))
-            return f"**获取API使用情况失败**"
-        rounded_usage = "{:.5f}".format(usage_data['total_usage']/100)
-        return f"**本月使用金额** \u3000 ${rounded_usage}"
-    except requests.exceptions.ConnectTimeout:
-        status_text = standard_error_msg + connection_timeout_prompt + error_retrieve_prompt
-        return status_text
-    except requests.exceptions.ReadTimeout:
-        status_text = standard_error_msg + read_timeout_prompt + error_retrieve_prompt
-        return status_text
-    except Exception as e:
-        logging.error(f"获取API使用情况失败:"+str(e))
-        return standard_error_msg + error_retrieve_prompt
-
-def get_last_day_of_month(any_day):
-    # The day 28 exists in every month. 4 days later, it's always next month
-    next_month = any_day.replace(day=28) + datetime.timedelta(days=4)
-    # subtracting the number of the current day brings us back one month
-    return next_month - datetime.timedelta(days=next_month.day)

spaces/Ariharasudhan/YoloV5/utils/flask_rest_api/restapi.py

@@ -1,48 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Run a Flask REST API exposing one or more YOLOv5s models
-"""
-
-import argparse
-import io
-
-import torch
-from flask import Flask, request
-from PIL import Image
-
-app = Flask(__name__)
-models = {}
-
-DETECTION_URL = "/v1/object-detection/<model>"
-
-
-@app.route(DETECTION_URL, methods=["POST"])
-def predict(model):
-    if request.method != "POST":
-        return
-
-    if request.files.get("image"):
-        # Method 1
-        # with request.files["image"] as f:
-        #     im = Image.open(io.BytesIO(f.read()))
-
-        # Method 2
-        im_file = request.files["image"]
-        im_bytes = im_file.read()
-        im = Image.open(io.BytesIO(im_bytes))
-
-        if model in models:
-            results = models[model](im, size=640)  # reduce size=320 for faster inference
-            return results.pandas().xyxy[0].to_json(orient="records")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Flask API exposing YOLOv5 model")
-    parser.add_argument("--port", default=5000, type=int, help="port number")
-    parser.add_argument('--model', nargs='+', default=['yolov5s'], help='model(s) to run, i.e. --model yolov5n yolov5s')
-    opt = parser.parse_args()
-
-    for m in opt.model:
-        models[m] = torch.hub.load("ultralytics/yolov5", m, force_reload=True, skip_validation=True)
-
-    app.run(host="0.0.0.0", port=opt.port)  # debug=True causes Restarting with stat

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

@@ -1,31 +0,0 @@
-"""
-For types associated with installation schemes.
-
-For a general overview of available schemes and their context, see
-https://docs.python.org/3/install/index.html#alternate-installation.
-"""
-
-
-SCHEME_KEYS = ["platlib", "purelib", "headers", "scripts", "data"]
-
-
-class Scheme:
-    """A Scheme holds paths which are used as the base directories for
-    artifacts associated with a Python package.
-    """
-
-    __slots__ = SCHEME_KEYS
-
-    def __init__(
-        self,
-        platlib: str,
-        purelib: str,
-        headers: str,
-        scripts: str,
-        data: str,
-    ) -> None:
-        self.platlib = platlib
-        self.purelib = purelib
-        self.headers = headers
-        self.scripts = scripts
-        self.data = data

spaces/AutoLLM/AutoAgents/README-main.md

@@ -1,103 +0,0 @@
-# AutoAgents
-
-<p align="center"><img src="https://raw.githubusercontent.com/AutoLLM/AutoAgents/assets/images/logo.png?raw=true" width=400/></p>
-
-Unlock complex question answering in LLMs with enhanced chain-of-thought reasoning and information-seeking capabilities.
-
-## 👉	Overview
-
-The purpose of this project is to extend LLMs ability to answer more complex questions through chain-of-thought reasoning and information-seeking actions.
-
-We are excited to release the initial version of AutoAgents, a proof-of-concept on what can be achieved with only well-written prompts. This is the initial step towards our first big milestone, releasing and open-sourcing the AutoAgents 7B model!
- 
-Come try out our [Huggingface Space](https://huggingface.co/spaces/AutoLLM/AutoAgents)!
-
-
-
-## 🤖 The AutoAgents Project
-
-This project demonstrates LLMs capability to execute a complex user goal: understand a user's goal, generate a plan, use proper tools, and deliver a final result.
-
-For simplicity, our first attempt starts with a Web Search Agent.
-
-
-
-## 💫 How it works:
-
-<p align="left"><img src="https://raw.githubusercontent.com/AutoLLM/AutoAgents/assets/images/agent.png" width=830/></p>
-
-
-
-## 📔 Examples
-
-Ask your AutoAgent to do what a real person would do using the internet:
-
-For example:
-
-*1. Recommend a kid friendly movie that is playing at a theater near Sunnyvale. Give me the showtimes and a link to purchase the tickets*
-
-*2. What is the average age of the past three president when they took office*
-
-*3. What is the mortgage rate right now and how does that compare to the past two years*
-
-
-
-## 💁 Roadmap
-
-* ~~HuggingFace Space demo using OpenAI models~~ [LINK](https://huggingface.co/spaces/AutoLLM/AutoAgents)
-* AutoAgents [7B] Model
-  * Initial Release:
-    * Finetune and release a 7B parameter fine-tuned search model
-* AutoAgents Dataset
-  * A high-quality dataset for a diverse set of search scenarios (why quality and diversity?<sup>[1](https://arxiv.org/abs/2305.11206)</sup>)
-* Reduce Model Inference Overhead
-* Affordance Modeling <sup>[2](https://en.wikipedia.org/wiki/Affordance)</sup>
-* Extend Support to Additional Tools
-* Customizable Document Search set (e.g. personal documents)
-* Support Multi-turn Dialogue
-* Advanced Flow Control in Plan Execution
-
-We are actively developing a few interesting things, check back here or follow us on [Twitter](https://twitter.com/AutoLLM) for any new development.
- 
-If you are interested in any other problems, feel free to shoot us an issue.
-
-
-
-## 🧭 How to use this repo?
-
-This repo contains the entire code to run the search agent from your local browser. All you need is an OpenAI API key to begin.
-
-To run the search agent locally:
-
-1. Clone the repo and change the directory
-
-  ```bash
-  git clone https://github.com/AutoLLM/AutoAgents.git
-  cd AutoAgents
-  ```
-
-2. Install the dependencies
-
-  ```bash
-  pip install -r requirements.txt
-  ```
-
-3. Install the `autoagents` package
-
-  ```bash
-  pip install -e .
-  ```
-
-4. Make sure you have your OpenAI API key set as an environment variable. Alternatively, you can also feed it through the input text-box on the sidebar.
-
-  ```bash
-  export OPENAI_API_KEY=sk-xxxxxx
-  ```
-
-5. Run the Streamlit app
-
-  ```bash
-  streamlit run autoagents/spaces/app.py
-  ```
-
-This should open a browser window where you can type your search query.

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/utils/filesystem.py

@@ -1,153 +0,0 @@
-import fnmatch
-import os
-import os.path
-import random
-import sys
-from contextlib import contextmanager
-from tempfile import NamedTemporaryFile
-from typing import Any, BinaryIO, Generator, List, Union, cast
-
-from pip._vendor.tenacity import retry, stop_after_delay, wait_fixed
-
-from pip._internal.utils.compat import get_path_uid
-from pip._internal.utils.misc import format_size
-
-
-def check_path_owner(path: str) -> bool:
-    # If we don't have a way to check the effective uid of this process, then
-    # we'll just assume that we own the directory.
-    if sys.platform == "win32" or not hasattr(os, "geteuid"):
-        return True
-
-    assert os.path.isabs(path)
-
-    previous = None
-    while path != previous:
-        if os.path.lexists(path):
-            # Check if path is writable by current user.
-            if os.geteuid() == 0:
-                # Special handling for root user in order to handle properly
-                # cases where users use sudo without -H flag.
-                try:
-                    path_uid = get_path_uid(path)
-                except OSError:
-                    return False
-                return path_uid == 0
-            else:
-                return os.access(path, os.W_OK)
-        else:
-            previous, path = path, os.path.dirname(path)
-    return False  # assume we don't own the path
-
-
-@contextmanager
-def adjacent_tmp_file(path: str, **kwargs: Any) -> Generator[BinaryIO, None, None]:
-    """Return a file-like object pointing to a tmp file next to path.
-
-    The file is created securely and is ensured to be written to disk
-    after the context reaches its end.
-
-    kwargs will be passed to tempfile.NamedTemporaryFile to control
-    the way the temporary file will be opened.
-    """
-    with NamedTemporaryFile(
-        delete=False,
-        dir=os.path.dirname(path),
-        prefix=os.path.basename(path),
-        suffix=".tmp",
-        **kwargs,
-    ) as f:
-        result = cast(BinaryIO, f)
-        try:
-            yield result
-        finally:
-            result.flush()
-            os.fsync(result.fileno())
-
-
-# Tenacity raises RetryError by default, explicitly raise the original exception
-_replace_retry = retry(reraise=True, stop=stop_after_delay(1), wait=wait_fixed(0.25))
-
-replace = _replace_retry(os.replace)
-
-
-# test_writable_dir and _test_writable_dir_win are copied from Flit,
-# with the author's agreement to also place them under pip's license.
-def test_writable_dir(path: str) -> bool:
-    """Check if a directory is writable.
-
-    Uses os.access() on POSIX, tries creating files on Windows.
-    """
-    # If the directory doesn't exist, find the closest parent that does.
-    while not os.path.isdir(path):
-        parent = os.path.dirname(path)
-        if parent == path:
-            break  # Should never get here, but infinite loops are bad
-        path = parent
-
-    if os.name == "posix":
-        return os.access(path, os.W_OK)
-
-    return _test_writable_dir_win(path)
-
-
-def _test_writable_dir_win(path: str) -> bool:
-    # os.access doesn't work on Windows: http://bugs.python.org/issue2528
-    # and we can't use tempfile: http://bugs.python.org/issue22107
-    basename = "accesstest_deleteme_fishfingers_custard_"
-    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789"
-    for _ in range(10):
-        name = basename + "".join(random.choice(alphabet) for _ in range(6))
-        file = os.path.join(path, name)
-        try:
-            fd = os.open(file, os.O_RDWR | os.O_CREAT | os.O_EXCL)
-        except FileExistsError:
-            pass
-        except PermissionError:
-            # This could be because there's a directory with the same name.
-            # But it's highly unlikely there's a directory called that,
-            # so we'll assume it's because the parent dir is not writable.
-            # This could as well be because the parent dir is not readable,
-            # due to non-privileged user access.
-            return False
-        else:
-            os.close(fd)
-            os.unlink(file)
-            return True
-
-    # This should never be reached
-    raise OSError("Unexpected condition testing for writable directory")
-
-
-def find_files(path: str, pattern: str) -> List[str]:
-    """Returns a list of absolute paths of files beneath path, recursively,
-    with filenames which match the UNIX-style shell glob pattern."""
-    result: List[str] = []
-    for root, _, files in os.walk(path):
-        matches = fnmatch.filter(files, pattern)
-        result.extend(os.path.join(root, f) for f in matches)
-    return result
-
-
-def file_size(path: str) -> Union[int, float]:
-    # If it's a symlink, return 0.
-    if os.path.islink(path):
-        return 0
-    return os.path.getsize(path)
-
-
-def format_file_size(path: str) -> str:
-    return format_size(file_size(path))
-
-
-def directory_size(path: str) -> Union[int, float]:
-    size = 0.0
-    for root, _dirs, files in os.walk(path):
-        for filename in files:
-            file_path = os.path.join(root, filename)
-            size += file_size(file_path)
-    return size
-
-
-def format_directory_size(path: str) -> str:
-    return format_size(directory_size(path))

spaces/Big-Web/MMSD/env/Scripts/activate.bat

@@ -1,34 +0,0 @@
-@echo off
-
-rem This file is UTF-8 encoded, so we need to update the current code page while executing it
-for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do (
-    set _OLD_CODEPAGE=%%a
-)
-if defined _OLD_CODEPAGE (
-    "%SystemRoot%\System32\chcp.com" 65001 > nul
-)
-
-set VIRTUAL_ENV=C:\Users\cajul\Documents\Big Web Labs\Code\monet\MMSD\env
-
-if not defined PROMPT set PROMPT=$P$G
-
-if defined _OLD_VIRTUAL_PROMPT set PROMPT=%_OLD_VIRTUAL_PROMPT%
-if defined _OLD_VIRTUAL_PYTHONHOME set PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%
-
-set _OLD_VIRTUAL_PROMPT=%PROMPT%
-set PROMPT=(env) %PROMPT%
-
-if defined PYTHONHOME set _OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%
-set PYTHONHOME=
-
-if defined _OLD_VIRTUAL_PATH set PATH=%_OLD_VIRTUAL_PATH%
-if not defined _OLD_VIRTUAL_PATH set _OLD_VIRTUAL_PATH=%PATH%
-
-set PATH=%VIRTUAL_ENV%\Scripts;%PATH%
-set VIRTUAL_ENV_PROMPT=(env) 
-
-:END
-if defined _OLD_CODEPAGE (
-    "%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul
-    set _OLD_CODEPAGE=
-)

spaces/CNXT/TXT2PiX/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/runwayml/stable-diffusion-v1-5").launch()

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/dev/packaging/pkg_helpers.bash

@@ -1,52 +0,0 @@
-#!/bin/bash -e
-
-# Function to retry functions that sometimes timeout or have flaky failures
-retry () {
-    $*  || (sleep 1 && $*) || (sleep 2 && $*) || (sleep 4 && $*) || (sleep 8 && $*)
-}
-# Install with pip a bit more robustly than the default
-pip_install() {
-  retry pip install --progress-bar off "$@"
-}
-
-
-setup_cuda() {
-  # Now work out the CUDA settings
-  # Like other torch domain libraries, we choose common GPU architectures only.
-  export FORCE_CUDA=1
-  case "$CU_VERSION" in
-    cu101)
-      export CUDA_HOME=/usr/local/cuda-10.1/
-      export TORCH_CUDA_ARCH_LIST="3.5;3.7;5.0;5.2;6.0+PTX;6.1+PTX;7.0+PTX;7.5+PTX"
-      ;;
-    cu100)
-      export CUDA_HOME=/usr/local/cuda-10.0/
-      export TORCH_CUDA_ARCH_LIST="3.5;3.7;5.0;5.2;6.0+PTX;6.1+PTX;7.0+PTX;7.5+PTX"
-      ;;
-    cu92)
-      export CUDA_HOME=/usr/local/cuda-9.2/
-      export TORCH_CUDA_ARCH_LIST="3.5;3.7;5.0;5.2;6.0+PTX;6.1+PTX;7.0+PTX"
-      ;;
-    cpu)
-      unset FORCE_CUDA
-      export CUDA_VISIBLE_DEVICES=
-      ;;
-    *)
-      echo "Unrecognized CU_VERSION=$CU_VERSION"
-      exit 1
-      ;;
-  esac
-}
-
-setup_wheel_python() {
-  case "$PYTHON_VERSION" in
-    3.6) python_abi=cp36-cp36m ;;
-    3.7) python_abi=cp37-cp37m ;;
-    3.8) python_abi=cp38-cp38 ;;
-    *)
-      echo "Unrecognized PYTHON_VERSION=$PYTHON_VERSION"
-      exit 1
-      ;;
-  esac
-  export PATH="/opt/python/$python_abi/bin:$PATH"
-}

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

@@ -1,23 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-
-// this system inherits assign_value
-#include <thrust/system/detail/sequential/assign_value.h>
-

spaces/ChandraMohanNayal/AutoGPT/autogpt/speech/eleven_labs.py

@@ -1,86 +0,0 @@
-"""ElevenLabs speech module"""
-import os
-
-import requests
-from playsound import playsound
-
-from autogpt.config import Config
-from autogpt.speech.base import VoiceBase
-
-PLACEHOLDERS = {"your-voice-id"}
-
-
-class ElevenLabsSpeech(VoiceBase):
-    """ElevenLabs speech class"""
-
-    def _setup(self) -> None:
-        """Set up the voices, API key, etc.
-
-        Returns:
-            None: None
-        """
-
-        cfg = Config()
-        default_voices = ["ErXwobaYiN019PkySvjV", "EXAVITQu4vr4xnSDxMaL"]
-        voice_options = {
-            "Rachel": "21m00Tcm4TlvDq8ikWAM",
-            "Domi": "AZnzlk1XvdvUeBnXmlld",
-            "Bella": "EXAVITQu4vr4xnSDxMaL",
-            "Antoni": "ErXwobaYiN019PkySvjV",
-            "Elli": "MF3mGyEYCl7XYWbV9V6O",
-            "Josh": "TxGEqnHWrfWFTfGW9XjX",
-            "Arnold": "VR6AewLTigWG4xSOukaG",
-            "Adam": "pNInz6obpgDQGcFmaJgB",
-            "Sam": "yoZ06aMxZJJ28mfd3POQ",
-        }
-        self._headers = {
-            "Content-Type": "application/json",
-            "xi-api-key": cfg.elevenlabs_api_key,
-        }
-        self._voices = default_voices.copy()
-        if cfg.elevenlabs_voice_1_id in voice_options:
-            cfg.elevenlabs_voice_1_id = voice_options[cfg.elevenlabs_voice_1_id]
-        if cfg.elevenlabs_voice_2_id in voice_options:
-            cfg.elevenlabs_voice_2_id = voice_options[cfg.elevenlabs_voice_2_id]
-        self._use_custom_voice(cfg.elevenlabs_voice_1_id, 0)
-        self._use_custom_voice(cfg.elevenlabs_voice_2_id, 1)
-
-    def _use_custom_voice(self, voice, voice_index) -> None:
-        """Use a custom voice if provided and not a placeholder
-
-        Args:
-            voice (str): The voice ID
-            voice_index (int): The voice index
-
-        Returns:
-            None: None
-        """
-        # Placeholder values that should be treated as empty
-        if voice and voice not in PLACEHOLDERS:
-            self._voices[voice_index] = voice
-
-    def _speech(self, text: str, voice_index: int = 0) -> bool:
-        """Speak text using elevenlabs.io's API
-
-        Args:
-            text (str): The text to speak
-            voice_index (int, optional): The voice to use. Defaults to 0.
-
-        Returns:
-            bool: True if the request was successful, False otherwise
-        """
-        tts_url = (
-            f"https://api.elevenlabs.io/v1/text-to-speech/{self._voices[voice_index]}"
-        )
-        response = requests.post(tts_url, headers=self._headers, json={"text": text})
-
-        if response.status_code == 200:
-            with open("speech.mpeg", "wb") as f:
-                f.write(response.content)
-            playsound("speech.mpeg", True)
-            os.remove("speech.mpeg")
-            return True
-        else:
-            print("Request failed with status code:", response.status_code)
-            print("Response content:", response.content)
-            return False

spaces/CormacMc/projectsub6/README.md

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

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/aiohttp/web_request.py

@@ -1,882 +0,0 @@
-import asyncio
-import datetime
-import io
-import re
-import socket
-import string
-import tempfile
-import types
-import warnings
-from http.cookies import SimpleCookie
-from types import MappingProxyType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Iterator,
-    Mapping,
-    MutableMapping,
-    Optional,
-    Pattern,
-    Tuple,
-    Union,
-    cast,
-)
-from urllib.parse import parse_qsl
-
-import attr
-from multidict import CIMultiDict, CIMultiDictProxy, MultiDict, MultiDictProxy
-from yarl import URL
-
-from . import hdrs
-from .abc import AbstractStreamWriter
-from .helpers import (
-    DEBUG,
-    ETAG_ANY,
-    LIST_QUOTED_ETAG_RE,
-    ChainMapProxy,
-    ETag,
-    HeadersMixin,
-    parse_http_date,
-    reify,
-    sentinel,
-)
-from .http_parser import RawRequestMessage
-from .http_writer import HttpVersion
-from .multipart import BodyPartReader, MultipartReader
-from .streams import EmptyStreamReader, StreamReader
-from .typedefs import (
-    DEFAULT_JSON_DECODER,
-    Final,
-    JSONDecoder,
-    LooseHeaders,
-    RawHeaders,
-    StrOrURL,
-)
-from .web_exceptions import HTTPRequestEntityTooLarge
-from .web_response import StreamResponse
-
-__all__ = ("BaseRequest", "FileField", "Request")
-
-
-if TYPE_CHECKING:  # pragma: no cover
-    from .web_app import Application
-    from .web_protocol import RequestHandler
-    from .web_urldispatcher import UrlMappingMatchInfo
-
-
-@attr.s(auto_attribs=True, frozen=True, slots=True)
-class FileField:
-    name: str
-    filename: str
-    file: io.BufferedReader
-    content_type: str
-    headers: "CIMultiDictProxy[str]"
-
-
-_TCHAR: Final[str] = string.digits + string.ascii_letters + r"!#$%&'*+.^_`|~-"
-# '-' at the end to prevent interpretation as range in a char class
-
-_TOKEN: Final[str] = rf"[{_TCHAR}]+"
-
-_QDTEXT: Final[str] = r"[{}]".format(
-    r"".join(chr(c) for c in (0x09, 0x20, 0x21) + tuple(range(0x23, 0x7F)))
-)
-# qdtext includes 0x5C to escape 0x5D ('\]')
-# qdtext excludes obs-text (because obsoleted, and encoding not specified)
-
-_QUOTED_PAIR: Final[str] = r"\\[\t !-~]"
-
-_QUOTED_STRING: Final[str] = r'"(?:{quoted_pair}|{qdtext})*"'.format(
-    qdtext=_QDTEXT, quoted_pair=_QUOTED_PAIR
-)
-
-_FORWARDED_PAIR: Final[
-    str
-] = r"({token})=({token}|{quoted_string})(:\d{{1,4}})?".format(
-    token=_TOKEN, quoted_string=_QUOTED_STRING
-)
-
-_QUOTED_PAIR_REPLACE_RE: Final[Pattern[str]] = re.compile(r"\\([\t !-~])")
-# same pattern as _QUOTED_PAIR but contains a capture group
-
-_FORWARDED_PAIR_RE: Final[Pattern[str]] = re.compile(_FORWARDED_PAIR)
-
-############################################################
-# HTTP Request
-############################################################
-
-
-class BaseRequest(MutableMapping[str, Any], HeadersMixin):
-
-    POST_METHODS = {
-        hdrs.METH_PATCH,
-        hdrs.METH_POST,
-        hdrs.METH_PUT,
-        hdrs.METH_TRACE,
-        hdrs.METH_DELETE,
-    }
-
-    ATTRS = HeadersMixin.ATTRS | frozenset(
-        [
-            "_message",
-            "_protocol",
-            "_payload_writer",
-            "_payload",
-            "_headers",
-            "_method",
-            "_version",
-            "_rel_url",
-            "_post",
-            "_read_bytes",
-            "_state",
-            "_cache",
-            "_task",
-            "_client_max_size",
-            "_loop",
-            "_transport_sslcontext",
-            "_transport_peername",
-        ]
-    )
-
-    def __init__(
-        self,
-        message: RawRequestMessage,
-        payload: StreamReader,
-        protocol: "RequestHandler",
-        payload_writer: AbstractStreamWriter,
-        task: "asyncio.Task[None]",
-        loop: asyncio.AbstractEventLoop,
-        *,
-        client_max_size: int = 1024**2,
-        state: Optional[Dict[str, Any]] = None,
-        scheme: Optional[str] = None,
-        host: Optional[str] = None,
-        remote: Optional[str] = None,
-    ) -> None:
-        if state is None:
-            state = {}
-        self._message = message
-        self._protocol = protocol
-        self._payload_writer = payload_writer
-
-        self._payload = payload
-        self._headers = message.headers
-        self._method = message.method
-        self._version = message.version
-        self._cache: Dict[str, Any] = {}
-        url = message.url
-        if url.is_absolute():
-            # absolute URL is given,
-            # override auto-calculating url, host, and scheme
-            # all other properties should be good
-            self._cache["url"] = url
-            self._cache["host"] = url.host
-            self._cache["scheme"] = url.scheme
-            self._rel_url = url.relative()
-        else:
-            self._rel_url = message.url
-        self._post: Optional[MultiDictProxy[Union[str, bytes, FileField]]] = None
-        self._read_bytes: Optional[bytes] = None
-
-        self._state = state
-        self._task = task
-        self._client_max_size = client_max_size
-        self._loop = loop
-
-        transport = self._protocol.transport
-        assert transport is not None
-        self._transport_sslcontext = transport.get_extra_info("sslcontext")
-        self._transport_peername = transport.get_extra_info("peername")
-
-        if scheme is not None:
-            self._cache["scheme"] = scheme
-        if host is not None:
-            self._cache["host"] = host
-        if remote is not None:
-            self._cache["remote"] = remote
-
-    def clone(
-        self,
-        *,
-        method: str = sentinel,
-        rel_url: StrOrURL = sentinel,
-        headers: LooseHeaders = sentinel,
-        scheme: str = sentinel,
-        host: str = sentinel,
-        remote: str = sentinel,
-    ) -> "BaseRequest":
-        """Clone itself with replacement some attributes.
-
-        Creates and returns a new instance of Request object. If no parameters
-        are given, an exact copy is returned. If a parameter is not passed, it
-        will reuse the one from the current request object.
-        """
-        if self._read_bytes:
-            raise RuntimeError("Cannot clone request " "after reading its content")
-
-        dct: Dict[str, Any] = {}
-        if method is not sentinel:
-            dct["method"] = method
-        if rel_url is not sentinel:
-            new_url = URL(rel_url)
-            dct["url"] = new_url
-            dct["path"] = str(new_url)
-        if headers is not sentinel:
-            # a copy semantic
-            dct["headers"] = CIMultiDictProxy(CIMultiDict(headers))
-            dct["raw_headers"] = tuple(
-                (k.encode("utf-8"), v.encode("utf-8")) for k, v in headers.items()
-            )
-
-        message = self._message._replace(**dct)
-
-        kwargs = {}
-        if scheme is not sentinel:
-            kwargs["scheme"] = scheme
-        if host is not sentinel:
-            kwargs["host"] = host
-        if remote is not sentinel:
-            kwargs["remote"] = remote
-
-        return self.__class__(
-            message,
-            self._payload,
-            self._protocol,
-            self._payload_writer,
-            self._task,
-            self._loop,
-            client_max_size=self._client_max_size,
-            state=self._state.copy(),
-            **kwargs,
-        )
-
-    @property
-    def task(self) -> "asyncio.Task[None]":
-        return self._task
-
-    @property
-    def protocol(self) -> "RequestHandler":
-        return self._protocol
-
-    @property
-    def transport(self) -> Optional[asyncio.Transport]:
-        if self._protocol is None:
-            return None
-        return self._protocol.transport
-
-    @property
-    def writer(self) -> AbstractStreamWriter:
-        return self._payload_writer
-
-    @reify
-    def message(self) -> RawRequestMessage:
-        warnings.warn("Request.message is deprecated", DeprecationWarning, stacklevel=3)
-        return self._message
-
-    @reify
-    def rel_url(self) -> URL:
-        return self._rel_url
-
-    @reify
-    def loop(self) -> asyncio.AbstractEventLoop:
-        warnings.warn(
-            "request.loop property is deprecated", DeprecationWarning, stacklevel=2
-        )
-        return self._loop
-
-    # MutableMapping API
-
-    def __getitem__(self, key: str) -> Any:
-        return self._state[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self._state[key] = value
-
-    def __delitem__(self, key: str) -> None:
-        del self._state[key]
-
-    def __len__(self) -> int:
-        return len(self._state)
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(self._state)
-
-    ########
-
-    @reify
-    def secure(self) -> bool:
-        """A bool indicating if the request is handled with SSL."""
-        return self.scheme == "https"
-
-    @reify
-    def forwarded(self) -> Tuple[Mapping[str, str], ...]:
-        """A tuple containing all parsed Forwarded header(s).
-
-        Makes an effort to parse Forwarded headers as specified by RFC 7239:
-
-        - It adds one (immutable) dictionary per Forwarded 'field-value', ie
-          per proxy. The element corresponds to the data in the Forwarded
-          field-value added by the first proxy encountered by the client. Each
-          subsequent item corresponds to those added by later proxies.
-        - It checks that every value has valid syntax in general as specified
-          in section 4: either a 'token' or a 'quoted-string'.
-        - It un-escapes found escape sequences.
-        - It does NOT validate 'by' and 'for' contents as specified in section
-          6.
-        - It does NOT validate 'host' contents (Host ABNF).
-        - It does NOT validate 'proto' contents for valid URI scheme names.
-
-        Returns a tuple containing one or more immutable dicts
-        """
-        elems = []
-        for field_value in self._message.headers.getall(hdrs.FORWARDED, ()):
-            length = len(field_value)
-            pos = 0
-            need_separator = False
-            elem: Dict[str, str] = {}
-            elems.append(types.MappingProxyType(elem))
-            while 0 <= pos < length:
-                match = _FORWARDED_PAIR_RE.match(field_value, pos)
-                if match is not None:  # got a valid forwarded-pair
-                    if need_separator:
-                        # bad syntax here, skip to next comma
-                        pos = field_value.find(",", pos)
-                    else:
-                        name, value, port = match.groups()
-                        if value[0] == '"':
-                            # quoted string: remove quotes and unescape
-                            value = _QUOTED_PAIR_REPLACE_RE.sub(r"\1", value[1:-1])
-                        if port:
-                            value += port
-                        elem[name.lower()] = value
-                        pos += len(match.group(0))
-                        need_separator = True
-                elif field_value[pos] == ",":  # next forwarded-element
-                    need_separator = False
-                    elem = {}
-                    elems.append(types.MappingProxyType(elem))
-                    pos += 1
-                elif field_value[pos] == ";":  # next forwarded-pair
-                    need_separator = False
-                    pos += 1
-                elif field_value[pos] in " \t":
-                    # Allow whitespace even between forwarded-pairs, though
-                    # RFC 7239 doesn't. This simplifies code and is in line
-                    # with Postel's law.
-                    pos += 1
-                else:
-                    # bad syntax here, skip to next comma
-                    pos = field_value.find(",", pos)
-        return tuple(elems)
-
-    @reify
-    def scheme(self) -> str:
-        """A string representing the scheme of the request.
-
-        Hostname is resolved in this order:
-
-        - overridden value by .clone(scheme=new_scheme) call.
-        - type of connection to peer: HTTPS if socket is SSL, HTTP otherwise.
-
-        'http' or 'https'.
-        """
-        if self._transport_sslcontext:
-            return "https"
-        else:
-            return "http"
-
-    @reify
-    def method(self) -> str:
-        """Read only property for getting HTTP method.
-
-        The value is upper-cased str like 'GET', 'POST', 'PUT' etc.
-        """
-        return self._method
-
-    @reify
-    def version(self) -> HttpVersion:
-        """Read only property for getting HTTP version of request.
-
-        Returns aiohttp.protocol.HttpVersion instance.
-        """
-        return self._version
-
-    @reify
-    def host(self) -> str:
-        """Hostname of the request.
-
-        Hostname is resolved in this order:
-
-        - overridden value by .clone(host=new_host) call.
-        - HOST HTTP header
-        - socket.getfqdn() value
-        """
-        host = self._message.headers.get(hdrs.HOST)
-        if host is not None:
-            return host
-        return socket.getfqdn()
-
-    @reify
-    def remote(self) -> Optional[str]:
-        """Remote IP of client initiated HTTP request.
-
-        The IP is resolved in this order:
-
-        - overridden value by .clone(remote=new_remote) call.
-        - peername of opened socket
-        """
-        if self._transport_peername is None:
-            return None
-        if isinstance(self._transport_peername, (list, tuple)):
-            return str(self._transport_peername[0])
-        return str(self._transport_peername)
-
-    @reify
-    def url(self) -> URL:
-        url = URL.build(scheme=self.scheme, host=self.host)
-        return url.join(self._rel_url)
-
-    @reify
-    def path(self) -> str:
-        """The URL including *PATH INFO* without the host or scheme.
-
-        E.g., ``/app/blog``
-        """
-        return self._rel_url.path
-
-    @reify
-    def path_qs(self) -> str:
-        """The URL including PATH_INFO and the query string.
-
-        E.g, /app/blog?id=10
-        """
-        return str(self._rel_url)
-
-    @reify
-    def raw_path(self) -> str:
-        """The URL including raw *PATH INFO* without the host or scheme.
-
-        Warning, the path is unquoted and may contains non valid URL characters
-
-        E.g., ``/my%2Fpath%7Cwith%21some%25strange%24characters``
-        """
-        return self._message.path
-
-    @reify
-    def query(self) -> "MultiDictProxy[str]":
-        """A multidict with all the variables in the query string."""
-        return MultiDictProxy(self._rel_url.query)
-
-    @reify
-    def query_string(self) -> str:
-        """The query string in the URL.
-
-        E.g., id=10
-        """
-        return self._rel_url.query_string
-
-    @reify
-    def headers(self) -> "CIMultiDictProxy[str]":
-        """A case-insensitive multidict proxy with all headers."""
-        return self._headers
-
-    @reify
-    def raw_headers(self) -> RawHeaders:
-        """A sequence of pairs for all headers."""
-        return self._message.raw_headers
-
-    @reify
-    def if_modified_since(self) -> Optional[datetime.datetime]:
-        """The value of If-Modified-Since HTTP header, or None.
-
-        This header is represented as a `datetime` object.
-        """
-        return parse_http_date(self.headers.get(hdrs.IF_MODIFIED_SINCE))
-
-    @reify
-    def if_unmodified_since(self) -> Optional[datetime.datetime]:
-        """The value of If-Unmodified-Since HTTP header, or None.
-
-        This header is represented as a `datetime` object.
-        """
-        return parse_http_date(self.headers.get(hdrs.IF_UNMODIFIED_SINCE))
-
-    @staticmethod
-    def _etag_values(etag_header: str) -> Iterator[ETag]:
-        """Extract `ETag` objects from raw header."""
-        if etag_header == ETAG_ANY:
-            yield ETag(
-                is_weak=False,
-                value=ETAG_ANY,
-            )
-        else:
-            for match in LIST_QUOTED_ETAG_RE.finditer(etag_header):
-                is_weak, value, garbage = match.group(2, 3, 4)
-                # Any symbol captured by 4th group means
-                # that the following sequence is invalid.
-                if garbage:
-                    break
-
-                yield ETag(
-                    is_weak=bool(is_weak),
-                    value=value,
-                )
-
-    @classmethod
-    def _if_match_or_none_impl(
-        cls, header_value: Optional[str]
-    ) -> Optional[Tuple[ETag, ...]]:
-        if not header_value:
-            return None
-
-        return tuple(cls._etag_values(header_value))
-
-    @reify
-    def if_match(self) -> Optional[Tuple[ETag, ...]]:
-        """The value of If-Match HTTP header, or None.
-
-        This header is represented as a `tuple` of `ETag` objects.
-        """
-        return self._if_match_or_none_impl(self.headers.get(hdrs.IF_MATCH))
-
-    @reify
-    def if_none_match(self) -> Optional[Tuple[ETag, ...]]:
-        """The value of If-None-Match HTTP header, or None.
-
-        This header is represented as a `tuple` of `ETag` objects.
-        """
-        return self._if_match_or_none_impl(self.headers.get(hdrs.IF_NONE_MATCH))
-
-    @reify
-    def if_range(self) -> Optional[datetime.datetime]:
-        """The value of If-Range HTTP header, or None.
-
-        This header is represented as a `datetime` object.
-        """
-        return parse_http_date(self.headers.get(hdrs.IF_RANGE))
-
-    @reify
-    def keep_alive(self) -> bool:
-        """Is keepalive enabled by client?"""
-        return not self._message.should_close
-
-    @reify
-    def cookies(self) -> Mapping[str, str]:
-        """Return request cookies.
-
-        A read-only dictionary-like object.
-        """
-        raw = self.headers.get(hdrs.COOKIE, "")
-        parsed: SimpleCookie[str] = SimpleCookie(raw)
-        return MappingProxyType({key: val.value for key, val in parsed.items()})
-
-    @reify
-    def http_range(self) -> slice:
-        """The content of Range HTTP header.
-
-        Return a slice instance.
-
-        """
-        rng = self._headers.get(hdrs.RANGE)
-        start, end = None, None
-        if rng is not None:
-            try:
-                pattern = r"^bytes=(\d*)-(\d*)$"
-                start, end = re.findall(pattern, rng)[0]
-            except IndexError:  # pattern was not found in header
-                raise ValueError("range not in acceptable format")
-
-            end = int(end) if end else None
-            start = int(start) if start else None
-
-            if start is None and end is not None:
-                # end with no start is to return tail of content
-                start = -end
-                end = None
-
-            if start is not None and end is not None:
-                # end is inclusive in range header, exclusive for slice
-                end += 1
-
-                if start >= end:
-                    raise ValueError("start cannot be after end")
-
-            if start is end is None:  # No valid range supplied
-                raise ValueError("No start or end of range specified")
-
-        return slice(start, end, 1)
-
-    @reify
-    def content(self) -> StreamReader:
-        """Return raw payload stream."""
-        return self._payload
-
-    @property
-    def has_body(self) -> bool:
-        """Return True if request's HTTP BODY can be read, False otherwise."""
-        warnings.warn(
-            "Deprecated, use .can_read_body #2005", DeprecationWarning, stacklevel=2
-        )
-        return not self._payload.at_eof()
-
-    @property
-    def can_read_body(self) -> bool:
-        """Return True if request's HTTP BODY can be read, False otherwise."""
-        return not self._payload.at_eof()
-
-    @reify
-    def body_exists(self) -> bool:
-        """Return True if request has HTTP BODY, False otherwise."""
-        return type(self._payload) is not EmptyStreamReader
-
-    async def release(self) -> None:
-        """Release request.
-
-        Eat unread part of HTTP BODY if present.
-        """
-        while not self._payload.at_eof():
-            await self._payload.readany()
-
-    async def read(self) -> bytes:
-        """Read request body if present.
-
-        Returns bytes object with full request content.
-        """
-        if self._read_bytes is None:
-            body = bytearray()
-            while True:
-                chunk = await self._payload.readany()
-                body.extend(chunk)
-                if self._client_max_size:
-                    body_size = len(body)
-                    if body_size >= self._client_max_size:
-                        raise HTTPRequestEntityTooLarge(
-                            max_size=self._client_max_size, actual_size=body_size
-                        )
-                if not chunk:
-                    break
-            self._read_bytes = bytes(body)
-        return self._read_bytes
-
-    async def text(self) -> str:
-        """Return BODY as text using encoding from .charset."""
-        bytes_body = await self.read()
-        encoding = self.charset or "utf-8"
-        return bytes_body.decode(encoding)
-
-    async def json(self, *, loads: JSONDecoder = DEFAULT_JSON_DECODER) -> Any:
-        """Return BODY as JSON."""
-        body = await self.text()
-        return loads(body)
-
-    async def multipart(self) -> MultipartReader:
-        """Return async iterator to process BODY as multipart."""
-        return MultipartReader(self._headers, self._payload)
-
-    async def post(self) -> "MultiDictProxy[Union[str, bytes, FileField]]":
-        """Return POST parameters."""
-        if self._post is not None:
-            return self._post
-        if self._method not in self.POST_METHODS:
-            self._post = MultiDictProxy(MultiDict())
-            return self._post
-
-        content_type = self.content_type
-        if content_type not in (
-            "",
-            "application/x-www-form-urlencoded",
-            "multipart/form-data",
-        ):
-            self._post = MultiDictProxy(MultiDict())
-            return self._post
-
-        out: MultiDict[Union[str, bytes, FileField]] = MultiDict()
-
-        if content_type == "multipart/form-data":
-            multipart = await self.multipart()
-            max_size = self._client_max_size
-
-            field = await multipart.next()
-            while field is not None:
-                size = 0
-                field_ct = field.headers.get(hdrs.CONTENT_TYPE)
-
-                if isinstance(field, BodyPartReader):
-                    assert field.name is not None
-
-                    # Note that according to RFC 7578, the Content-Type header
-                    # is optional, even for files, so we can't assume it's
-                    # present.
-                    # https://tools.ietf.org/html/rfc7578#section-4.4
-                    if field.filename:
-                        # store file in temp file
-                        tmp = tempfile.TemporaryFile()
-                        chunk = await field.read_chunk(size=2**16)
-                        while chunk:
-                            chunk = field.decode(chunk)
-                            tmp.write(chunk)
-                            size += len(chunk)
-                            if 0 < max_size < size:
-                                tmp.close()
-                                raise HTTPRequestEntityTooLarge(
-                                    max_size=max_size, actual_size=size
-                                )
-                            chunk = await field.read_chunk(size=2**16)
-                        tmp.seek(0)
-
-                        if field_ct is None:
-                            field_ct = "application/octet-stream"
-
-                        ff = FileField(
-                            field.name,
-                            field.filename,
-                            cast(io.BufferedReader, tmp),
-                            field_ct,
-                            field.headers,
-                        )
-                        out.add(field.name, ff)
-                    else:
-                        # deal with ordinary data
-                        value = await field.read(decode=True)
-                        if field_ct is None or field_ct.startswith("text/"):
-                            charset = field.get_charset(default="utf-8")
-                            out.add(field.name, value.decode(charset))
-                        else:
-                            out.add(field.name, value)
-                        size += len(value)
-                        if 0 < max_size < size:
-                            raise HTTPRequestEntityTooLarge(
-                                max_size=max_size, actual_size=size
-                            )
-                else:
-                    raise ValueError(
-                        "To decode nested multipart you need " "to use custom reader",
-                    )
-
-                field = await multipart.next()
-        else:
-            data = await self.read()
-            if data:
-                charset = self.charset or "utf-8"
-                out.extend(
-                    parse_qsl(
-                        data.rstrip().decode(charset),
-                        keep_blank_values=True,
-                        encoding=charset,
-                    )
-                )
-
-        self._post = MultiDictProxy(out)
-        return self._post
-
-    def get_extra_info(self, name: str, default: Any = None) -> Any:
-        """Extra info from protocol transport"""
-        protocol = self._protocol
-        if protocol is None:
-            return default
-
-        transport = protocol.transport
-        if transport is None:
-            return default
-
-        return transport.get_extra_info(name, default)
-
-    def __repr__(self) -> str:
-        ascii_encodable_path = self.path.encode("ascii", "backslashreplace").decode(
-            "ascii"
-        )
-        return "<{} {} {} >".format(
-            self.__class__.__name__, self._method, ascii_encodable_path
-        )
-
-    def __eq__(self, other: object) -> bool:
-        return id(self) == id(other)
-
-    def __bool__(self) -> bool:
-        return True
-
-    async def _prepare_hook(self, response: StreamResponse) -> None:
-        return
-
-    def _cancel(self, exc: BaseException) -> None:
-        self._payload.set_exception(exc)
-
-
-class Request(BaseRequest):
-
-    ATTRS = BaseRequest.ATTRS | frozenset(["_match_info"])
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-
-        # matchdict, route_name, handler
-        # or information about traversal lookup
-
-        # initialized after route resolving
-        self._match_info: Optional[UrlMappingMatchInfo] = None
-
-    if DEBUG:
-
-        def __setattr__(self, name: str, val: Any) -> None:
-            if name not in self.ATTRS:
-                warnings.warn(
-                    "Setting custom {}.{} attribute "
-                    "is discouraged".format(self.__class__.__name__, name),
-                    DeprecationWarning,
-                    stacklevel=2,
-                )
-            super().__setattr__(name, val)
-
-    def clone(
-        self,
-        *,
-        method: str = sentinel,
-        rel_url: StrOrURL = sentinel,
-        headers: LooseHeaders = sentinel,
-        scheme: str = sentinel,
-        host: str = sentinel,
-        remote: str = sentinel,
-    ) -> "Request":
-        ret = super().clone(
-            method=method,
-            rel_url=rel_url,
-            headers=headers,
-            scheme=scheme,
-            host=host,
-            remote=remote,
-        )
-        new_ret = cast(Request, ret)
-        new_ret._match_info = self._match_info
-        return new_ret
-
-    @reify
-    def match_info(self) -> "UrlMappingMatchInfo":
-        """Result of route resolving."""
-        match_info = self._match_info
-        assert match_info is not None
-        return match_info
-
-    @property
-    def app(self) -> "Application":
-        """Application instance."""
-        match_info = self._match_info
-        assert match_info is not None
-        return match_info.current_app
-
-    @property
-    def config_dict(self) -> ChainMapProxy:
-        match_info = self._match_info
-        assert match_info is not None
-        lst = match_info.apps
-        app = self.app
-        idx = lst.index(app)
-        sublist = list(reversed(lst[: idx + 1]))
-        return ChainMapProxy(sublist)
-
-    async def _prepare_hook(self, response: StreamResponse) -> None:
-        match_info = self._match_info
-        if match_info is None:
-            return
-        for app in match_info._apps:
-            await app.on_response_prepare.send(self, response)

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/G__l_a_t.py

@@ -1,234 +0,0 @@
-from fontTools.misc import sstruct
-from fontTools.misc.fixedTools import floatToFixedToStr
-from fontTools.misc.textTools import safeEval
-
-# from itertools import *
-from functools import partial
-from . import DefaultTable
-from . import grUtils
-import struct
-
-
-Glat_format_0 = """
-    >        # big endian
-    version: 16.16F
-"""
-
-Glat_format_3 = """
-    >
-    version: 16.16F
-    compression:L    # compression scheme or reserved 
-"""
-
-Glat_format_1_entry = """
-    >
-    attNum:     B    # Attribute number of first attribute
-    num:        B    # Number of attributes in this run
-"""
-Glat_format_23_entry = """
-    >
-    attNum:     H    # Attribute number of first attribute
-    num:        H    # Number of attributes in this run
-"""
-
-Glat_format_3_octabox_metrics = """
-    >
-    subboxBitmap:   H    # Which subboxes exist on 4x4 grid
-    diagNegMin:     B    # Defines minimum negatively-sloped diagonal (si)
-    diagNegMax:     B    # Defines maximum negatively-sloped diagonal (sa)
-    diagPosMin:     B    # Defines minimum positively-sloped diagonal (di)
-    diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
-"""
-
-Glat_format_3_subbox_entry = """
-    >
-    left:           B    # xi
-    right:          B    # xa
-    bottom:         B    # yi
-    top:            B    # ya
-    diagNegMin:     B    # Defines minimum negatively-sloped diagonal (si)
-    diagNegMax:     B    # Defines maximum negatively-sloped diagonal (sa)
-    diagPosMin:     B    # Defines minimum positively-sloped diagonal (di)
-    diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
-"""
-
-
-class _Object:
-    pass
-
-
-class _Dict(dict):
-    pass
-
-
-class table_G__l_a_t(DefaultTable.DefaultTable):
-    """
-    Support Graphite Glat tables
-    """
-
-    def __init__(self, tag=None):
-        DefaultTable.DefaultTable.__init__(self, tag)
-        self.scheme = 0
-
-    def decompile(self, data, ttFont):
-        sstruct.unpack2(Glat_format_0, data, self)
-        self.version = float(floatToFixedToStr(self.version, precisionBits=16))
-        if self.version <= 1.9:
-            decoder = partial(self.decompileAttributes12, fmt=Glat_format_1_entry)
-        elif self.version <= 2.9:
-            decoder = partial(self.decompileAttributes12, fmt=Glat_format_23_entry)
-        elif self.version >= 3.0:
-            (data, self.scheme) = grUtils.decompress(data)
-            sstruct.unpack2(Glat_format_3, data, self)
-            self.hasOctaboxes = (self.compression & 1) == 1
-            decoder = self.decompileAttributes3
-
-        gloc = ttFont["Gloc"]
-        self.attributes = {}
-        count = 0
-        for s, e in zip(gloc, gloc[1:]):
-            self.attributes[ttFont.getGlyphName(count)] = decoder(data[s:e])
-            count += 1
-
-    def decompileAttributes12(self, data, fmt):
-        attributes = _Dict()
-        while len(data) > 3:
-            e, data = sstruct.unpack2(fmt, data, _Object())
-            keys = range(e.attNum, e.attNum + e.num)
-            if len(data) >= 2 * e.num:
-                vals = struct.unpack_from((">%dh" % e.num), data)
-                attributes.update(zip(keys, vals))
-                data = data[2 * e.num :]
-        return attributes
-
-    def decompileAttributes3(self, data):
-        if self.hasOctaboxes:
-            o, data = sstruct.unpack2(Glat_format_3_octabox_metrics, data, _Object())
-            numsub = bin(o.subboxBitmap).count("1")
-            o.subboxes = []
-            for b in range(numsub):
-                if len(data) >= 8:
-                    subbox, data = sstruct.unpack2(
-                        Glat_format_3_subbox_entry, data, _Object()
-                    )
-                    o.subboxes.append(subbox)
-        attrs = self.decompileAttributes12(data, Glat_format_23_entry)
-        if self.hasOctaboxes:
-            attrs.octabox = o
-        return attrs
-
-    def compile(self, ttFont):
-        data = sstruct.pack(Glat_format_0, self)
-        if self.version <= 1.9:
-            encoder = partial(self.compileAttributes12, fmt=Glat_format_1_entry)
-        elif self.version <= 2.9:
-            encoder = partial(self.compileAttributes12, fmt=Glat_format_1_entry)
-        elif self.version >= 3.0:
-            self.compression = (self.scheme << 27) + (1 if self.hasOctaboxes else 0)
-            data = sstruct.pack(Glat_format_3, self)
-            encoder = self.compileAttributes3
-
-        glocs = []
-        for n in range(len(self.attributes)):
-            glocs.append(len(data))
-            data += encoder(self.attributes[ttFont.getGlyphName(n)])
-        glocs.append(len(data))
-        ttFont["Gloc"].set(glocs)
-
-        if self.version >= 3.0:
-            data = grUtils.compress(self.scheme, data)
-        return data
-
-    def compileAttributes12(self, attrs, fmt):
-        data = b""
-        for e in grUtils.entries(attrs):
-            data += sstruct.pack(fmt, {"attNum": e[0], "num": e[1]}) + struct.pack(
-                (">%dh" % len(e[2])), *e[2]
-            )
-        return data
-
-    def compileAttributes3(self, attrs):
-        if self.hasOctaboxes:
-            o = attrs.octabox
-            data = sstruct.pack(Glat_format_3_octabox_metrics, o)
-            numsub = bin(o.subboxBitmap).count("1")
-            for b in range(numsub):
-                data += sstruct.pack(Glat_format_3_subbox_entry, o.subboxes[b])
-        else:
-            data = ""
-        return data + self.compileAttributes12(attrs, Glat_format_23_entry)
-
-    def toXML(self, writer, ttFont):
-        writer.simpletag("version", version=self.version, compressionScheme=self.scheme)
-        writer.newline()
-        for n, a in sorted(
-            self.attributes.items(), key=lambda x: ttFont.getGlyphID(x[0])
-        ):
-            writer.begintag("glyph", name=n)
-            writer.newline()
-            if hasattr(a, "octabox"):
-                o = a.octabox
-                formatstring, names, fixes = sstruct.getformat(
-                    Glat_format_3_octabox_metrics
-                )
-                vals = {}
-                for k in names:
-                    if k == "subboxBitmap":
-                        continue
-                    vals[k] = "{:.3f}%".format(getattr(o, k) * 100.0 / 255)
-                vals["bitmap"] = "{:0X}".format(o.subboxBitmap)
-                writer.begintag("octaboxes", **vals)
-                writer.newline()
-                formatstring, names, fixes = sstruct.getformat(
-                    Glat_format_3_subbox_entry
-                )
-                for s in o.subboxes:
-                    vals = {}
-                    for k in names:
-                        vals[k] = "{:.3f}%".format(getattr(s, k) * 100.0 / 255)
-                    writer.simpletag("octabox", **vals)
-                    writer.newline()
-                writer.endtag("octaboxes")
-                writer.newline()
-            for k, v in sorted(a.items()):
-                writer.simpletag("attribute", index=k, value=v)
-                writer.newline()
-            writer.endtag("glyph")
-            writer.newline()
-
-    def fromXML(self, name, attrs, content, ttFont):
-        if name == "version":
-            self.version = float(safeEval(attrs["version"]))
-            self.scheme = int(safeEval(attrs["compressionScheme"]))
-        if name != "glyph":
-            return
-        if not hasattr(self, "attributes"):
-            self.attributes = {}
-        gname = attrs["name"]
-        attributes = _Dict()
-        for element in content:
-            if not isinstance(element, tuple):
-                continue
-            tag, attrs, subcontent = element
-            if tag == "attribute":
-                k = int(safeEval(attrs["index"]))
-                v = int(safeEval(attrs["value"]))
-                attributes[k] = v
-            elif tag == "octaboxes":
-                self.hasOctaboxes = True
-                o = _Object()
-                o.subboxBitmap = int(attrs["bitmap"], 16)
-                o.subboxes = []
-                del attrs["bitmap"]
-                for k, v in attrs.items():
-                    setattr(o, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
-                for element in subcontent:
-                    if not isinstance(element, tuple):
-                        continue
-                    (tag, attrs, subcontent) = element
-                    so = _Object()
-                    for k, v in attrs.items():
-                        setattr(so, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
-                    o.subboxes.append(so)
-                attributes.octabox = o
-        self.attributes[gname] = attributes

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fsspec/gui.py

@@ -1,411 +0,0 @@
-import ast
-import contextlib
-import logging
-import os
-import re
-from typing import ClassVar, Sequence
-
-import panel as pn
-
-from .core import OpenFile, get_filesystem_class, split_protocol
-from .registry import known_implementations
-
-pn.extension()
-logger = logging.getLogger("fsspec.gui")
-
-
-class SigSlot(object):
-    """Signal-slot mixin, for Panel event passing
-
-    Include this class in a widget manager's superclasses to be able to
-    register events and callbacks on Panel widgets managed by that class.
-
-    The method ``_register`` should be called as widgets are added, and external
-    code should call ``connect`` to associate callbacks.
-
-    By default, all signals emit a DEBUG logging statement.
-    """
-
-    # names of signals that this class may emit each of which must be
-    # set by _register for any new instance
-    signals: ClassVar[Sequence[str]] = []
-    # names of actions that this class may respond to
-    slots: ClassVar[Sequence[str]] = []
-
-    # each of which must be a method name
-
-    def __init__(self):
-        self._ignoring_events = False
-        self._sigs = {}
-        self._map = {}
-        self._setup()
-
-    def _setup(self):
-        """Create GUI elements and register signals"""
-        self.panel = pn.pane.PaneBase()
-        # no signals to set up in the base class
-
-    def _register(
-        self, widget, name, thing="value", log_level=logging.DEBUG, auto=False
-    ):
-        """Watch the given attribute of a widget and assign it a named event
-
-        This is normally called at the time a widget is instantiated, in the
-        class which owns it.
-
-        Parameters
-        ----------
-        widget : pn.layout.Panel or None
-            Widget to watch. If None, an anonymous signal not associated with
-            any widget.
-        name : str
-            Name of this event
-        thing : str
-            Attribute of the given widget to watch
-        log_level : int
-            When the signal is triggered, a logging event of the given level
-            will be fired in the dfviz logger.
-        auto : bool
-            If True, automatically connects with a method in this class of the
-            same name.
-        """
-        if name not in self.signals:
-            raise ValueError("Attempt to assign an undeclared signal: %s" % name)
-        self._sigs[name] = {
-            "widget": widget,
-            "callbacks": [],
-            "thing": thing,
-            "log": log_level,
-        }
-        wn = "-".join(
-            [
-                getattr(widget, "name", str(widget)) if widget is not None else "none",
-                thing,
-            ]
-        )
-        self._map[wn] = name
-        if widget is not None:
-            widget.param.watch(self._signal, thing, onlychanged=True)
-        if auto and hasattr(self, name):
-            self.connect(name, getattr(self, name))
-
-    def _repr_mimebundle_(self, *args, **kwargs):
-        """Display in a notebook or a server"""
-        try:
-            return self.panel._repr_mimebundle_(*args, **kwargs)
-        except (ValueError, AttributeError):
-            raise NotImplementedError("Panel does not seem to be set " "up properly")
-
-    def connect(self, signal, slot):
-        """Associate call back with given event
-
-        The callback must be a function which takes the "new" value of the
-        watched attribute as the only parameter. If the callback return False,
-        this cancels any further processing of the given event.
-
-        Alternatively, the callback can be a string, in which case it means
-        emitting the correspondingly-named event (i.e., connect to self)
-        """
-        self._sigs[signal]["callbacks"].append(slot)
-
-    def _signal(self, event):
-        """This is called by a an action on a widget
-
-        Within an self.ignore_events context, nothing happens.
-
-        Tests can execute this method by directly changing the values of
-        widget components.
-        """
-        if not self._ignoring_events:
-            wn = "-".join([event.obj.name, event.name])
-            if wn in self._map and self._map[wn] in self._sigs:
-                self._emit(self._map[wn], event.new)
-
-    @contextlib.contextmanager
-    def ignore_events(self):
-        """Temporarily turn off events processing in this instance
-
-        (does not propagate to children)
-        """
-        self._ignoring_events = True
-        try:
-            yield
-        finally:
-            self._ignoring_events = False
-
-    def _emit(self, sig, value=None):
-        """An event happened, call its callbacks
-
-        This method can be used in tests to simulate message passing without
-        directly changing visual elements.
-
-        Calling of callbacks will halt whenever one returns False.
-        """
-        logger.log(self._sigs[sig]["log"], "{}: {}".format(sig, value))
-        for callback in self._sigs[sig]["callbacks"]:
-            if isinstance(callback, str):
-                self._emit(callback)
-            else:
-                try:
-                    # running callbacks should not break the interface
-                    ret = callback(value)
-                    if ret is False:
-                        break
-                except Exception as e:
-                    logger.exception(
-                        "Exception (%s) while executing callback for signal: %s"
-                        "" % (e, sig)
-                    )
-
-    def show(self, threads=False):
-        """Open a new browser tab and display this instance's interface"""
-        self.panel.show(threads=threads, verbose=False)
-        return self
-
-
-class SingleSelect(SigSlot):
-    """A multiselect which only allows you to select one item for an event"""
-
-    signals = ["_selected", "selected"]  # the first is internal
-    slots = ["set_options", "set_selection", "add", "clear", "select"]
-
-    def __init__(self, **kwargs):
-        self.kwargs = kwargs
-        super().__init__()
-
-    def _setup(self):
-        self.panel = pn.widgets.MultiSelect(**self.kwargs)
-        self._register(self.panel, "_selected", "value")
-        self._register(None, "selected")
-        self.connect("_selected", self.select_one)
-
-    def _signal(self, *args, **kwargs):
-        super()._signal(*args, **kwargs)
-
-    def select_one(self, *_):
-        with self.ignore_events():
-            val = [self.panel.value[-1]] if self.panel.value else []
-            self.panel.value = val
-        self._emit("selected", self.panel.value)
-
-    def set_options(self, options):
-        self.panel.options = options
-
-    def clear(self):
-        self.panel.options = []
-
-    @property
-    def value(self):
-        return self.panel.value
-
-    def set_selection(self, selection):
-        self.panel.value = [selection]
-
-
-class FileSelector(SigSlot):
-    """Panel-based graphical file selector widget
-
-    Instances of this widget are interactive and can be displayed in jupyter by having
-    them as the output of a cell,  or in a separate browser tab using ``.show()``.
-    """
-
-    signals = [
-        "protocol_changed",
-        "selection_changed",
-        "directory_entered",
-        "home_clicked",
-        "up_clicked",
-        "go_clicked",
-        "filters_changed",
-    ]
-    slots = ["set_filters", "go_home"]
-
-    def __init__(self, url=None, filters=None, ignore=None, kwargs=None):
-        """
-
-        Parameters
-        ----------
-        url : str (optional)
-            Initial value of the URL to populate the dialog; should include protocol
-        filters : list(str) (optional)
-            File endings to include in the listings. If not included, all files are
-            allowed. Does not affect directories.
-            If given, the endings will appear as checkboxes in the interface
-        ignore : list(str) (optional)
-            Regex(s) of file basename patterns to ignore, e.g., "\\." for typical
-            hidden files on posix
-        kwargs : dict (optional)
-            To pass to file system instance
-        """
-        if url:
-            self.init_protocol, url = split_protocol(url)
-        else:
-            self.init_protocol, url = "file", os.getcwd()
-        self.init_url = url
-        self.init_kwargs = kwargs or "{}"
-        self.filters = filters
-        self.ignore = [re.compile(i) for i in ignore or []]
-        self._fs = None
-        super().__init__()
-
-    def _setup(self):
-        self.url = pn.widgets.TextInput(
-            name="url",
-            value=self.init_url,
-            align="end",
-            sizing_mode="stretch_width",
-            width_policy="max",
-        )
-        self.protocol = pn.widgets.Select(
-            options=list(sorted(known_implementations)),
-            value=self.init_protocol,
-            name="protocol",
-            align="center",
-        )
-        self.kwargs = pn.widgets.TextInput(name="kwargs", value="{}", align="center")
-        self.go = pn.widgets.Button(name="⇨", align="end", width=45)
-        self.main = SingleSelect(size=10)
-        self.home = pn.widgets.Button(name="🏠", width=40, height=30, align="end")
-        self.up = pn.widgets.Button(name="‹", width=30, height=30, align="end")
-
-        self._register(self.protocol, "protocol_changed", auto=True)
-        self._register(self.go, "go_clicked", "clicks", auto=True)
-        self._register(self.up, "up_clicked", "clicks", auto=True)
-        self._register(self.home, "home_clicked", "clicks", auto=True)
-        self._register(None, "selection_changed")
-        self.main.connect("selected", self.selection_changed)
-        self._register(None, "directory_entered")
-        self.prev_protocol = self.protocol.value
-        self.prev_kwargs = self.storage_options
-
-        self.filter_sel = pn.widgets.CheckBoxGroup(
-            value=[], options=[], inline=False, align="end", width_policy="min"
-        )
-        self._register(self.filter_sel, "filters_changed", auto=True)
-
-        self.panel = pn.Column(
-            pn.Row(self.protocol, self.kwargs),
-            pn.Row(self.home, self.up, self.url, self.go, self.filter_sel),
-            self.main.panel,
-        )
-        self.set_filters(self.filters)
-        self.go_clicked()
-
-    def set_filters(self, filters=None):
-        self.filters = filters
-        if filters:
-            self.filter_sel.options = filters
-            self.filter_sel.value = filters
-        else:
-            self.filter_sel.options = []
-            self.filter_sel.value = []
-
-    @property
-    def storage_options(self):
-        """Value of the kwargs box as a dictionary"""
-        return ast.literal_eval(self.kwargs.value) or {}
-
-    @property
-    def fs(self):
-        """Current filesystem instance"""
-        if self._fs is None:
-            cls = get_filesystem_class(self.protocol.value)
-            self._fs = cls(**self.storage_options)
-        return self._fs
-
-    @property
-    def urlpath(self):
-        """URL of currently selected item"""
-        return (
-            (self.protocol.value + "://" + self.main.value[0])
-            if self.main.value
-            else None
-        )
-
-    def open_file(self, mode="rb", compression=None, encoding=None):
-        """Create OpenFile instance for the currently selected item
-
-        For example, in a notebook you might do something like
-
-        .. code-block::
-
-            [ ]: sel = FileSelector(); sel
-
-            # user selects their file
-
-            [ ]: with sel.open_file('rb') as f:
-            ...      out = f.read()
-
-        Parameters
-        ----------
-        mode: str (optional)
-            Open mode for the file.
-        compression: str (optional)
-            The interact with the file as compressed. Set to 'infer' to guess
-            compression from the file ending
-        encoding: str (optional)
-            If using text mode, use this encoding; defaults to UTF8.
-        """
-        if self.urlpath is None:
-            raise ValueError("No file selected")
-        return OpenFile(self.fs, self.urlpath, mode, compression, encoding)
-
-    def filters_changed(self, values):
-        self.filters = values
-        self.go_clicked()
-
-    def selection_changed(self, *_):
-        if self.urlpath is None:
-            return
-        if self.fs.isdir(self.urlpath):
-            self.url.value = self.fs._strip_protocol(self.urlpath)
-        self.go_clicked()
-
-    def go_clicked(self, *_):
-        if (
-            self.prev_protocol != self.protocol.value
-            or self.prev_kwargs != self.storage_options
-        ):
-            self._fs = None  # causes fs to be recreated
-            self.prev_protocol = self.protocol.value
-            self.prev_kwargs = self.storage_options
-        listing = sorted(
-            self.fs.ls(self.url.value, detail=True), key=lambda x: x["name"]
-        )
-        listing = [
-            l
-            for l in listing
-            if not any(i.match(l["name"].rsplit("/", 1)[-1]) for i in self.ignore)
-        ]
-        folders = {
-            "📁 " + o["name"].rsplit("/", 1)[-1]: o["name"]
-            for o in listing
-            if o["type"] == "directory"
-        }
-        files = {
-            "📄 " + o["name"].rsplit("/", 1)[-1]: o["name"]
-            for o in listing
-            if o["type"] == "file"
-        }
-        if self.filters:
-            files = {
-                k: v
-                for k, v in files.items()
-                if any(v.endswith(ext) for ext in self.filters)
-            }
-        self.main.set_options(dict(**folders, **files))
-
-    def protocol_changed(self, *_):
-        self._fs = None
-        self.main.options = []
-        self.url.value = ""
-
-    def home_clicked(self, *_):
-        self.protocol.value = self.init_protocol
-        self.kwargs.value = self.init_kwargs
-        self.url.value = self.init_url
-        self.go_clicked()
-
-    def up_clicked(self, *_):
-        self.url.value = self.fs._parent(self.url.value)
-        self.go_clicked()

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

@@ -1,137 +0,0 @@
-"""gr.Dataset() component."""
-
-from __future__ import annotations
-
-from typing import Any, Literal
-
-from gradio_client.documentation import document, set_documentation_group
-from gradio_client.serializing import StringSerializable
-
-from gradio.components.base import (
-    Component,
-    IOComponent,
-    _Keywords,
-    get_component_instance,
-)
-from gradio.events import Clickable, Selectable
-
-set_documentation_group("component")
-
-
-@document()
-class Dataset(Clickable, Selectable, Component, StringSerializable):
-    """
-    Used to create an output widget for showing datasets. Used to render the examples
-    box.
-    Preprocessing: passes the selected sample either as a {list} of data (if type="value") or as an {int} index (if type="index")
-    Postprocessing: expects a {list} of {lists} corresponding to the dataset data.
-    """
-
-    def __init__(
-        self,
-        *,
-        label: str | None = None,
-        components: list[IOComponent] | list[str],
-        samples: list[list[Any]] | None = None,
-        headers: list[str] | None = None,
-        type: Literal["values", "index"] = "values",
-        samples_per_page: int = 10,
-        visible: bool = True,
-        elem_id: str | None = None,
-        elem_classes: list[str] | str | None = None,
-        container: bool = True,
-        scale: int | None = None,
-        min_width: int = 160,
-        **kwargs,
-    ):
-        """
-        Parameters:
-            components: Which component types to show in this dataset widget, can be passed in as a list of string names or Components instances. The following components are supported in a Dataset: Audio, Checkbox, CheckboxGroup, ColorPicker, Dataframe, Dropdown, File, HTML, Image, Markdown, Model3D, Number, Radio, Slider, Textbox, TimeSeries, Video
-            samples: a nested list of samples. Each sublist within the outer list represents a data sample, and each element within the sublist represents an value for each component
-            headers: Column headers in the Dataset widget, should be the same len as components. If not provided, inferred from component labels
-            type: 'values' if clicking on a sample should pass the value of the sample, or "index" if it should pass the index of the sample
-            samples_per_page: how many examples to show per page.
-            visible: If False, component will be hidden.
-            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
-            elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
-            container: If True, will place the component in a container - providing some extra padding around the border.
-            scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
-            min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
-        """
-        Component.__init__(
-            self, visible=visible, elem_id=elem_id, elem_classes=elem_classes, **kwargs
-        )
-        self.container = container
-        self.scale = scale
-        self.min_width = min_width
-        self.components = [get_component_instance(c, render=False) for c in components]
-
-        # Narrow type to IOComponent
-        assert all(
-            isinstance(c, IOComponent) for c in self.components
-        ), "All components in a `Dataset` must be subclasses of `IOComponent`"
-        self.components = [c for c in self.components if isinstance(c, IOComponent)]
-        for component in self.components:
-            component.root_url = self.root_url
-
-        self.samples = [[]] if samples is None else samples
-        for example in self.samples:
-            for i, (component, ex) in enumerate(zip(self.components, example)):
-                example[i] = component.as_example(ex)
-        self.type = type
-        self.label = label
-        if headers is not None:
-            self.headers = headers
-        elif all(c.label is None for c in self.components):
-            self.headers = []
-        else:
-            self.headers = [c.label or "" for c in self.components]
-        self.samples_per_page = samples_per_page
-
-    def get_config(self):
-        return {
-            "components": [component.get_block_name() for component in self.components],
-            "headers": self.headers,
-            "samples": self.samples,
-            "type": self.type,
-            "label": self.label,
-            "samples_per_page": self.samples_per_page,
-            "container": self.container,
-            "scale": self.scale,
-            "min_width": self.min_width,
-            **Component.get_config(self),
-        }
-
-    @staticmethod
-    def update(
-        samples: Any | Literal[_Keywords.NO_VALUE] | None = _Keywords.NO_VALUE,
-        visible: bool | None = None,
-        label: str | None = None,
-        container: bool | None = None,
-        scale: int | None = None,
-        min_width: int | None = None,
-    ):
-        return {
-            "samples": samples,
-            "visible": visible,
-            "label": label,
-            "container": container,
-            "scale": scale,
-            "min_width": min_width,
-            "__type__": "update",
-        }
-
-    def preprocess(self, x: Any) -> Any:
-        """
-        Any preprocessing needed to be performed on function input.
-        """
-        if self.type == "index":
-            return x
-        elif self.type == "values":
-            return self.samples[x]
-
-    def postprocess(self, samples: list[list[Any]]) -> dict:
-        return {
-            "samples": samples,
-            "__type__": "update",
-        }

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/huggingface_hub/inference/_generated/_async_client.py

@@ -1,1269 +0,0 @@
-# coding=utf-8
-# Copyright 2023-present, the HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# WARNING
-# This entire file has been adapted from the sync-client code in `src/huggingface_hub/inference/_client.py`.
-# Any change in InferenceClient will be automatically reflected in AsyncInferenceClient.
-# To re-generate the code, run `make style` or `python ./utils/generate_async_inference_client.py --update`.
-# WARNING
-import logging
-import time
-import warnings
-from dataclasses import asdict
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncIterable,
-    Dict,
-    List,
-    Optional,
-    Union,
-    overload,
-)
-
-from requests.structures import CaseInsensitiveDict
-
-from huggingface_hub.constants import INFERENCE_ENDPOINT
-from huggingface_hub.inference._common import (
-    ContentT,
-    InferenceTimeoutError,
-    _async_stream_text_generation_response,
-    _b64_encode,
-    _b64_to_image,
-    _bytes_to_dict,
-    _bytes_to_image,
-    _get_recommended_model,
-    _import_numpy,
-    _is_tgi_server,
-    _open_as_binary,
-    _set_as_non_tgi,
-)
-from huggingface_hub.inference._text_generation import (
-    TextGenerationParameters,
-    TextGenerationRequest,
-    TextGenerationResponse,
-    TextGenerationStreamResponse,
-    raise_text_generation_error,
-)
-from huggingface_hub.inference._types import ClassificationOutput, ConversationalOutput, ImageSegmentationOutput
-from huggingface_hub.utils import (
-    build_hf_headers,
-)
-from huggingface_hub.utils._typing import Literal
-
-from .._common import _async_yield_from, _import_aiohttp
-
-
-if TYPE_CHECKING:
-    import numpy as np
-    from PIL import Image
-
-logger = logging.getLogger(__name__)
-
-
-class AsyncInferenceClient:
-    """
-    Initialize a new Inference Client.
-
-    [`InferenceClient`] aims to provide a unified experience to perform inference. The client can be used
-    seamlessly with either the (free) Inference API or self-hosted Inference Endpoints.
-
-    Args:
-        model (`str`, `optional`):
-            The model to run inference with. Can be a model id hosted on the Hugging Face Hub, e.g. `bigcode/starcoder`
-            or a URL to a deployed Inference Endpoint. Defaults to None, in which case a recommended model is
-            automatically selected for the task.
-        token (`str`, *optional*):
-            Hugging Face token. Will default to the locally saved token. Pass `token=False` if you don't want to send
-            your token to the server.
-        timeout (`float`, `optional`):
-            The maximum number of seconds to wait for a response from the server. Loading a new model in Inference
-            API can take up to several minutes. Defaults to None, meaning it will loop until the server is available.
-        headers (`Dict[str, str]`, `optional`):
-            Additional headers to send to the server. By default only the authorization and user-agent headers are sent.
-            Values in this dictionary will override the default values.
-        cookies (`Dict[str, str]`, `optional`):
-            Additional cookies to send to the server.
-    """
-
-    def __init__(
-        self,
-        model: Optional[str] = None,
-        token: Union[str, bool, None] = None,
-        timeout: Optional[float] = None,
-        headers: Optional[Dict[str, str]] = None,
-        cookies: Optional[Dict[str, str]] = None,
-    ) -> None:
-        self.model: Optional[str] = model
-        self.headers = CaseInsensitiveDict(build_hf_headers(token=token))  # contains 'authorization' + 'user-agent'
-        if headers is not None:
-            self.headers.update(headers)
-        self.cookies = cookies
-        self.timeout = timeout
-
-    def __repr__(self):
-        return f"<InferenceClient(model='{self.model if self.model else ''}', timeout={self.timeout})>"
-
-    @overload
-    async def post(  # type: ignore
-        self,
-        *,
-        json: Optional[Union[str, Dict, List]] = None,
-        data: Optional[ContentT] = None,
-        model: Optional[str] = None,
-        task: Optional[str] = None,
-        stream: Literal[False] = ...,
-    ) -> bytes:
-        pass
-
-    @overload
-    async def post(  # type: ignore
-        self,
-        *,
-        json: Optional[Union[str, Dict, List]] = None,
-        data: Optional[ContentT] = None,
-        model: Optional[str] = None,
-        task: Optional[str] = None,
-        stream: Literal[True] = ...,
-    ) -> AsyncIterable[bytes]:
-        pass
-
-    async def post(
-        self,
-        *,
-        json: Optional[Union[str, Dict, List]] = None,
-        data: Optional[ContentT] = None,
-        model: Optional[str] = None,
-        task: Optional[str] = None,
-        stream: bool = False,
-    ) -> Union[bytes, AsyncIterable[bytes]]:
-        """
-        Make a POST request to the inference server.
-
-        Args:
-            json (`Union[str, Dict, List]`, *optional*):
-                The JSON data to send in the request body. Defaults to None.
-            data (`Union[str, Path, bytes, BinaryIO]`, *optional*):
-                The content to send in the request body. It can be raw bytes, a pointer to an opened file, a local file
-                path, or a URL to an online resource (image, audio file,...). If both `json` and `data` are passed,
-                `data` will take precedence. At least `json` or `data` must be provided. Defaults to None.
-            model (`str`, *optional*):
-                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. Will override the model defined at the instance level. Defaults to None.
-            task (`str`, *optional*):
-                The task to perform on the inference. Used only to default to a recommended model if `model` is not
-                provided. At least `model` or `task` must be provided. Defaults to None.
-            stream (`bool`, *optional*):
-                Whether to iterate over streaming APIs.
-
-        Returns:
-            bytes: The raw bytes returned by the server.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-        """
-
-        aiohttp = _import_aiohttp()
-
-        url = self._resolve_url(model, task)
-
-        if data is not None and json is not None:
-            warnings.warn("Ignoring `json` as `data` is passed as binary.")
-
-        t0 = time.time()
-        timeout = self.timeout
-        while True:
-            with _open_as_binary(data) as data_as_binary:
-                # Do not use context manager as we don't want to close the connection immediately when returning
-                # a stream
-                client = aiohttp.ClientSession(
-                    headers=self.headers, cookies=self.cookies, timeout=aiohttp.ClientTimeout(self.timeout)
-                )
-
-                try:
-                    response = await client.post(url, headers=build_hf_headers(), json=json, data=data_as_binary)
-                    response_error_payload = None
-                    if response.status != 200:
-                        try:
-                            response_error_payload = await response.json()  # get payload before connection closed
-                        except Exception:
-                            pass
-                    response.raise_for_status()
-                    if stream:
-                        return _async_yield_from(client, response)
-                    else:
-                        content = await response.read()
-                        await client.close()
-                        return content
-                except TimeoutError as error:
-                    await client.close()
-                    # Convert any `TimeoutError` to a `InferenceTimeoutError`
-                    raise InferenceTimeoutError(f"Inference call timed out: {url}") from error
-                except aiohttp.ClientResponseError as error:
-                    error.response_error_payload = response_error_payload
-                    await client.close()
-                    if response.status == 503:
-                        # If Model is unavailable, either raise a TimeoutError...
-                        if timeout is not None and time.time() - t0 > timeout:
-                            raise InferenceTimeoutError(
-                                f"Model not loaded on the server: {url}. Please retry with a higher timeout"
-                                f" (current: {self.timeout})."
-                            ) from error
-                        # ...or wait 1s and retry
-                        logger.info(f"Waiting for model to be loaded on the server: {error}")
-                        time.sleep(1)
-                        if timeout is not None:
-                            timeout = max(self.timeout - (time.time() - t0), 1)  # type: ignore
-                        continue
-                    raise error
-
-    async def audio_classification(
-        self,
-        audio: ContentT,
-        *,
-        model: Optional[str] = None,
-    ) -> List[ClassificationOutput]:
-        """
-        Perform audio classification on the provided audio content.
-
-        Args:
-            audio (Union[str, Path, bytes, BinaryIO]):
-                The audio content to classify. It can be raw audio bytes, a local audio file, or a URL pointing to an
-                audio file.
-            model (`str`, *optional*):
-                The model to use for audio classification. Can be a model ID hosted on the Hugging Face Hub
-                or a URL to a deployed Inference Endpoint. If not provided, the default recommended model for
-                audio classification will be used.
-
-        Returns:
-            `List[Dict]`: The classification output containing the predicted label and its confidence.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> await client.audio_classification("audio.flac")
-        [{'score': 0.4976358711719513, 'label': 'hap'}, {'score': 0.3677836060523987, 'label': 'neu'},...]
-        ```
-        """
-        response = await self.post(data=audio, model=model, task="audio-classification")
-        return _bytes_to_dict(response)
-
-    async def automatic_speech_recognition(
-        self,
-        audio: ContentT,
-        *,
-        model: Optional[str] = None,
-    ) -> str:
-        """
-        Perform automatic speech recognition (ASR or audio-to-text) on the given audio content.
-
-        Args:
-            audio (Union[str, Path, bytes, BinaryIO]):
-                The content to transcribe. It can be raw audio bytes, local audio file, or a URL to an audio file.
-            model (`str`, *optional*):
-                The model to use for ASR. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. If not provided, the default recommended model for ASR will be used.
-
-        Returns:
-            str: The transcribed text.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> await client.automatic_speech_recognition("hello_world.flac")
-        "hello world"
-        ```
-        """
-        response = await self.post(data=audio, model=model, task="automatic-speech-recognition")
-        return _bytes_to_dict(response)["text"]
-
-    async def conversational(
-        self,
-        text: str,
-        generated_responses: Optional[List[str]] = None,
-        past_user_inputs: Optional[List[str]] = None,
-        *,
-        parameters: Optional[Dict[str, Any]] = None,
-        model: Optional[str] = None,
-    ) -> ConversationalOutput:
-        """
-        Generate conversational responses based on the given input text (i.e. chat with the API).
-
-        Args:
-            text (`str`):
-                The last input from the user in the conversation.
-            generated_responses (`List[str]`, *optional*):
-                A list of strings corresponding to the earlier replies from the model. Defaults to None.
-            past_user_inputs (`List[str]`, *optional*):
-                A list of strings corresponding to the earlier replies from the user. Should be the same length as
-                `generated_responses`. Defaults to None.
-            parameters (`Dict[str, Any]`, *optional*):
-                Additional parameters for the conversational task. Defaults to None. For more details about the available
-                parameters, please refer to [this page](https://huggingface.co/docs/api-inference/detailed_parameters#conversational-task)
-            model (`str`, *optional*):
-                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
-                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
-                Defaults to None.
-
-        Returns:
-            `Dict`: The generated conversational output.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> output = await client.conversational("Hi, who are you?")
-        >>> output
-        {'generated_text': 'I am the one who knocks.', 'conversation': {'generated_responses': ['I am the one who knocks.'], 'past_user_inputs': ['Hi, who are you?']}, 'warnings': ['Setting `pad_token_id` to `eos_token_id`:50256 async for open-end generation.']}
-        >>> await client.conversational(
-        ...     "Wow, that's scary!",
-        ...     generated_responses=output["conversation"]["generated_responses"],
-        ...     past_user_inputs=output["conversation"]["past_user_inputs"],
-        ... )
-        ```
-        """
-        payload: Dict[str, Any] = {"inputs": {"text": text}}
-        if generated_responses is not None:
-            payload["inputs"]["generated_responses"] = generated_responses
-        if past_user_inputs is not None:
-            payload["inputs"]["past_user_inputs"] = past_user_inputs
-        if parameters is not None:
-            payload["parameters"] = parameters
-        response = await self.post(json=payload, model=model, task="conversational")
-        return _bytes_to_dict(response)
-
-    async def feature_extraction(self, text: str, *, model: Optional[str] = None) -> "np.ndarray":
-        """
-        Generate embeddings for a given text.
-
-        Args:
-            text (`str`):
-                The text to embed.
-            model (`str`, *optional*):
-                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
-                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
-                Defaults to None.
-
-        Returns:
-            `np.ndarray`: The embedding representing the input text as a float32 numpy array.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> await client.feature_extraction("Hi, who are you?")
-        array([[ 2.424802  ,  2.93384   ,  1.1750331 , ...,  1.240499, -0.13776633, -0.7889173 ],
-        [-0.42943227, -0.6364878 , -1.693462  , ...,  0.41978157, -2.4336355 ,  0.6162071 ],
-        ...,
-        [ 0.28552425, -0.928395  , -1.2077185 , ...,  0.76810825, -2.1069427 ,  0.6236161 ]], dtype=float32)
-        ```
-        """
-        response = await self.post(json={"inputs": text}, model=model, task="feature-extraction")
-        np = _import_numpy()
-        return np.array(_bytes_to_dict(response)[0], dtype="float32")
-
-    async def image_classification(
-        self,
-        image: ContentT,
-        *,
-        model: Optional[str] = None,
-    ) -> List[ClassificationOutput]:
-        """
-        Perform image classification on the given image using the specified model.
-
-        Args:
-            image (`Union[str, Path, bytes, BinaryIO]`):
-                The image to classify. It can be raw bytes, an image file, or a URL to an online image.
-            model (`str`, *optional*):
-                The model to use for image classification. Can be a model ID hosted on the Hugging Face Hub or a URL to a
-                deployed Inference Endpoint. If not provided, the default recommended model for image classification will be used.
-
-        Returns:
-            `List[Dict]`: a list of dictionaries containing the predicted label and associated probability.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> await client.image_classification("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
-        [{'score': 0.9779096841812134, 'label': 'Blenheim spaniel'}, ...]
-        ```
-        """
-        response = await self.post(data=image, model=model, task="image-classification")
-        return _bytes_to_dict(response)
-
-    async def image_segmentation(
-        self,
-        image: ContentT,
-        *,
-        model: Optional[str] = None,
-    ) -> List[ImageSegmentationOutput]:
-        """
-        Perform image segmentation on the given image using the specified model.
-
-        <Tip warning={true}>
-
-        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
-
-        </Tip>
-
-        Args:
-            image (`Union[str, Path, bytes, BinaryIO]`):
-                The image to segment. It can be raw bytes, an image file, or a URL to an online image.
-            model (`str`, *optional*):
-                The model to use for image segmentation. Can be a model ID hosted on the Hugging Face Hub or a URL to a
-                deployed Inference Endpoint. If not provided, the default recommended model for image segmentation will be used.
-
-        Returns:
-            `List[Dict]`: A list of dictionaries containing the segmented masks and associated attributes.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> await client.image_segmentation("cat.jpg"):
-        [{'score': 0.989008, 'label': 'LABEL_184', 'mask': <PIL.PngImagePlugin.PngImageFile image mode=L size=400x300 at 0x7FDD2B129CC0>}, ...]
-        ```
-        """
-
-        # Segment
-        response = await self.post(data=image, model=model, task="image-segmentation")
-        output = _bytes_to_dict(response)
-
-        # Parse masks as PIL Image
-        if not isinstance(output, list):
-            raise ValueError(f"Server output must be a list. Got {type(output)}: {str(output)[:200]}...")
-        for item in output:
-            item["mask"] = _b64_to_image(item["mask"])
-        return output
-
-    async def image_to_image(
-        self,
-        image: ContentT,
-        prompt: Optional[str] = None,
-        *,
-        negative_prompt: Optional[str] = None,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        num_inference_steps: Optional[int] = None,
-        guidance_scale: Optional[float] = None,
-        model: Optional[str] = None,
-        **kwargs,
-    ) -> "Image":
-        """
-        Perform image-to-image translation using a specified model.
-
-        <Tip warning={true}>
-
-        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
-
-        </Tip>
-
-        Args:
-            image (`Union[str, Path, bytes, BinaryIO]`):
-                The input image for translation. It can be raw bytes, an image file, or a URL to an online image.
-            prompt (`str`, *optional*):
-                The text prompt to guide the image generation.
-            negative_prompt (`str`, *optional*):
-                A negative prompt to guide the translation process.
-            height (`int`, *optional*):
-                The height in pixels of the generated image.
-            width (`int`, *optional*):
-                The width in pixels of the generated image.
-            num_inference_steps (`int`, *optional*):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            guidance_scale (`float`, *optional*):
-                Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            model (`str`, *optional*):
-                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
-
-        Returns:
-            `Image`: The translated image.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> image = await client.image_to_image("cat.jpg", prompt="turn the cat into a tiger")
-        >>> image.save("tiger.jpg")
-        ```
-        """
-        parameters = {
-            "prompt": prompt,
-            "negative_prompt": negative_prompt,
-            "height": height,
-            "width": width,
-            "num_inference_steps": num_inference_steps,
-            "guidance_scale": guidance_scale,
-            **kwargs,
-        }
-        if all(parameter is None for parameter in parameters.values()):
-            # Either only an image to send => send as raw bytes
-            data = image
-            payload: Optional[Dict[str, Any]] = None
-        else:
-            # Or an image + some parameters => use base64 encoding
-            data = None
-            payload = {"inputs": _b64_encode(image)}
-            for key, value in parameters.items():
-                if value is not None:
-                    payload[key] = value
-
-        response = await self.post(json=payload, data=data, model=model, task="image-to-image")
-        return _bytes_to_image(response)
-
-    async def image_to_text(self, image: ContentT, *, model: Optional[str] = None) -> str:
-        """
-        Takes an input image and return text.
-
-        Models can have very different outputs depending on your use case (image captioning, optical character recognition
-        (OCR), Pix2Struct, etc). Please have a look to the model card to learn more about a model's specificities.
-
-        Args:
-            image (`Union[str, Path, bytes, BinaryIO]`):
-                The input image to caption. It can be raw bytes, an image file, or a URL to an online image..
-            model (`str`, *optional*):
-                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
-
-        Returns:
-            `str`: The generated text.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> await client.image_to_text("cat.jpg")
-        'a cat standing in a grassy field '
-        >>> await client.image_to_text("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
-        'a dog laying on the grass next to a flower pot '
-        ```
-        """
-        response = await self.post(data=image, model=model, task="image-to-text")
-        return _bytes_to_dict(response)[0]["generated_text"]
-
-    async def sentence_similarity(
-        self, sentence: str, other_sentences: List[str], *, model: Optional[str] = None
-    ) -> List[float]:
-        """
-        Compute the semantic similarity between a sentence and a list of other sentences by comparing their embeddings.
-
-        Args:
-            sentence (`str`):
-                The main sentence to compare to others.
-            other_sentences (`List[str]`):
-                The list of sentences to compare to.
-            model (`str`, *optional*):
-                The model to use for the conversational task. Can be a model ID hosted on the Hugging Face Hub or a URL to
-                a deployed Inference Endpoint. If not provided, the default recommended conversational model will be used.
-                Defaults to None.
-
-        Returns:
-            `List[float]`: The embedding representing the input text.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> await client.sentence_similarity(
-        ...     "Machine learning is so easy.",
-        ...     other_sentences=[
-        ...         "Deep learning is so straightforward.",
-        ...         "This is so difficult, like rocket science.",
-        ...         "I can't believe how much I struggled with this.",
-        ...     ],
-        ... )
-        [0.7785726189613342, 0.45876261591911316, 0.2906220555305481]
-        ```
-        """
-        response = await self.post(
-            json={"inputs": {"source_sentence": sentence, "sentences": other_sentences}},
-            model=model,
-            task="sentence-similarity",
-        )
-        return _bytes_to_dict(response)
-
-    async def summarization(
-        self,
-        text: str,
-        *,
-        parameters: Optional[Dict[str, Any]] = None,
-        model: Optional[str] = None,
-    ) -> str:
-        """
-        Generate a summary of a given text using a specified model.
-
-        Args:
-            text (`str`):
-                The input text to summarize.
-            parameters (`Dict[str, Any]`, *optional*):
-                Additional parameters for summarization. Check out this [page](https://huggingface.co/docs/api-inference/detailed_parameters#summarization-task)
-                for more details.
-            model (`str`, *optional*):
-                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
-
-        Returns:
-            `str`: The generated summary text.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-        >>> await client.summarization("The Eiffel tower...")
-        'The Eiffel tower is one of the most famous landmarks in the world....'
-        ```
-        """
-        payload: Dict[str, Any] = {"inputs": text}
-        if parameters is not None:
-            payload["parameters"] = parameters
-        response = await self.post(json=payload, model=model, task="summarization")
-        return _bytes_to_dict(response)[0]["summary_text"]
-
-    @overload
-    async def text_generation(  # type: ignore
-        self,
-        prompt: str,
-        *,
-        details: Literal[False] = ...,
-        stream: Literal[False] = ...,
-        model: Optional[str] = None,
-        do_sample: bool = False,
-        max_new_tokens: int = 20,
-        best_of: Optional[int] = None,
-        repetition_penalty: Optional[float] = None,
-        return_full_text: bool = False,
-        seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,
-        temperature: Optional[float] = None,
-        top_k: Optional[int] = None,
-        top_p: Optional[float] = None,
-        truncate: Optional[int] = None,
-        typical_p: Optional[float] = None,
-        watermark: bool = False,
-    ) -> str:
-        ...
-
-    @overload
-    async def text_generation(  # type: ignore
-        self,
-        prompt: str,
-        *,
-        details: Literal[True] = ...,
-        stream: Literal[False] = ...,
-        model: Optional[str] = None,
-        do_sample: bool = False,
-        max_new_tokens: int = 20,
-        best_of: Optional[int] = None,
-        repetition_penalty: Optional[float] = None,
-        return_full_text: bool = False,
-        seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,
-        temperature: Optional[float] = None,
-        top_k: Optional[int] = None,
-        top_p: Optional[float] = None,
-        truncate: Optional[int] = None,
-        typical_p: Optional[float] = None,
-        watermark: bool = False,
-    ) -> TextGenerationResponse:
-        ...
-
-    @overload
-    async def text_generation(  # type: ignore
-        self,
-        prompt: str,
-        *,
-        details: Literal[False] = ...,
-        stream: Literal[True] = ...,
-        model: Optional[str] = None,
-        do_sample: bool = False,
-        max_new_tokens: int = 20,
-        best_of: Optional[int] = None,
-        repetition_penalty: Optional[float] = None,
-        return_full_text: bool = False,
-        seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,
-        temperature: Optional[float] = None,
-        top_k: Optional[int] = None,
-        top_p: Optional[float] = None,
-        truncate: Optional[int] = None,
-        typical_p: Optional[float] = None,
-        watermark: bool = False,
-    ) -> AsyncIterable[str]:
-        ...
-
-    @overload
-    async def text_generation(
-        self,
-        prompt: str,
-        *,
-        details: Literal[True] = ...,
-        stream: Literal[True] = ...,
-        model: Optional[str] = None,
-        do_sample: bool = False,
-        max_new_tokens: int = 20,
-        best_of: Optional[int] = None,
-        repetition_penalty: Optional[float] = None,
-        return_full_text: bool = False,
-        seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,
-        temperature: Optional[float] = None,
-        top_k: Optional[int] = None,
-        top_p: Optional[float] = None,
-        truncate: Optional[int] = None,
-        typical_p: Optional[float] = None,
-        watermark: bool = False,
-    ) -> AsyncIterable[TextGenerationStreamResponse]:
-        ...
-
-    async def text_generation(
-        self,
-        prompt: str,
-        *,
-        details: bool = False,
-        stream: bool = False,
-        model: Optional[str] = None,
-        do_sample: bool = False,
-        max_new_tokens: int = 20,
-        best_of: Optional[int] = None,
-        repetition_penalty: Optional[float] = None,
-        return_full_text: bool = False,
-        seed: Optional[int] = None,
-        stop_sequences: Optional[List[str]] = None,
-        temperature: Optional[float] = None,
-        top_k: Optional[int] = None,
-        top_p: Optional[float] = None,
-        truncate: Optional[int] = None,
-        typical_p: Optional[float] = None,
-        watermark: bool = False,
-        decoder_input_details: bool = False,
-    ) -> Union[str, TextGenerationResponse, AsyncIterable[str], AsyncIterable[TextGenerationStreamResponse]]:
-        """
-        Given a prompt, generate the following text.
-
-        It is recommended to have Pydantic installed in order to get inputs validated. This is preferable as it allow
-        early failures.
-
-        API endpoint is supposed to run with the `text-generation-inference` backend (TGI). This backend is the
-        go-to solution to run large language models at scale. However, for some smaller models (e.g. "gpt2") the
-        default `transformers` + `api-inference` solution is still in use. Both approaches have very similar APIs, but
-        not exactly the same. This method is compatible with both approaches but some parameters are only available for
-        `text-generation-inference`. If some parameters are ignored, a warning message is triggered but the process
-        continues correctly.
-
-        To learn more about the TGI project, please refer to https://github.com/huggingface/text-generation-inference.
-
-        Args:
-            prompt (`str`):
-                Input text.
-            details (`bool`, *optional*):
-                By default, text_generation returns a string. Pass `details=True` if you want a detailed output (tokens,
-                probabilities, seed, finish reason, etc.). Only available for models running on with the
-                `text-generation-inference` backend.
-            stream (`bool`, *optional*):
-                By default, text_generation returns the full generated text. Pass `stream=True` if you want a stream of
-                tokens to be returned. Only available for models running on with the `text-generation-inference`
-                backend.
-            model (`str`, *optional*):
-                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
-            do_sample (`bool`):
-                Activate logits sampling
-            max_new_tokens (`int`):
-                Maximum number of generated tokens
-            best_of (`int`):
-                Generate best_of sequences and return the one if the highest token logprobs
-            repetition_penalty (`float`):
-                The parameter for repetition penalty. 1.0 means no penalty. See [this
-                paper](https://arxiv.org/pdf/1909.05858.pdf) for more details.
-            return_full_text (`bool`):
-                Whether to prepend the prompt to the generated text
-            seed (`int`):
-                Random sampling seed
-            stop_sequences (`List[str]`):
-                Stop generating tokens if a member of `stop_sequences` is generated
-            temperature (`float`):
-                The value used to module the logits distribution.
-            top_k (`int`):
-                The number of highest probability vocabulary tokens to keep for top-k-filtering.
-            top_p (`float`):
-                If set to < 1, only the smallest set of most probable tokens with probabilities that add up to `top_p` or
-                higher are kept for generation.
-            truncate (`int`):
-                Truncate inputs tokens to the given size
-            typical_p (`float`):
-                Typical Decoding mass
-                See [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) for more information
-            watermark (`bool`):
-                Watermarking with [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226)
-            decoder_input_details (`bool`):
-                Return the decoder input token logprobs and ids. You must set `details=True` as well for it to be taken
-                into account. Defaults to `False`.
-
-        Returns:
-            `Union[str, TextGenerationResponse, Iterable[str], Iterable[TextGenerationStreamResponse]]`:
-            Generated text returned from the server:
-            - if `stream=False` and `details=False`, the generated text is returned as a `str` (default)
-            - if `stream=True` and `details=False`, the generated text is returned token by token as a `Iterable[str]`
-            - if `stream=False` and `details=True`, the generated text is returned with more details as a [`~huggingface_hub.inference._text_generation.TextGenerationResponse`]
-            - if `details=True` and `stream=True`, the generated text is returned token by token as a iterable of [`~huggingface_hub.inference._text_generation.TextGenerationStreamResponse`]
-
-        Raises:
-            `ValidationError`:
-                If input values are not valid. No HTTP call is made to the server.
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-
-        # Case 1: generate text
-        >>> await client.text_generation("The huggingface_hub library is ", max_new_tokens=12)
-        '100% open source and built to be easy to use.'
-
-        # Case 2: iterate over the generated tokens. Useful async for large generation.
-        >>> async for token in await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, stream=True):
-        ...     print(token)
-        100
-        %
-        open
-        source
-        and
-        built
-        to
-        be
-        easy
-        to
-        use
-        .
-
-        # Case 3: get more details about the generation process.
-        >>> await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True)
-        TextGenerationResponse(
-            generated_text='100% open source and built to be easy to use.',
-            details=Details(
-                finish_reason=<FinishReason.Length: 'length'>,
-                generated_tokens=12,
-                seed=None,
-                prefill=[
-                    InputToken(id=487, text='The', logprob=None),
-                    InputToken(id=53789, text=' hugging', logprob=-13.171875),
-                    (...)
-                    InputToken(id=204, text=' ', logprob=-7.0390625)
-                ],
-                tokens=[
-                    Token(id=1425, text='100', logprob=-1.0175781, special=False),
-                    Token(id=16, text='%', logprob=-0.0463562, special=False),
-                    (...)
-                    Token(id=25, text='.', logprob=-0.5703125, special=False)
-                ],
-                best_of_sequences=None
-            )
-        )
-
-        # Case 4: iterate over the generated tokens with more details.
-        # Last object is more complete, containing the full generated text and the finish reason.
-        >>> async for details in await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True, stream=True):
-        ...     print(details)
-        ...
-        TextGenerationStreamResponse(token=Token(id=1425, text='100', logprob=-1.0175781, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=16, text='%', logprob=-0.0463562, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=1314, text=' open', logprob=-1.3359375, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=3178, text=' source', logprob=-0.28100586, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=273, text=' and', logprob=-0.5961914, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=3426, text=' built', logprob=-1.9423828, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=271, text=' to', logprob=-1.4121094, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=314, text=' be', logprob=-1.5224609, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=1833, text=' easy', logprob=-2.1132812, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=271, text=' to', logprob=-0.08520508, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(id=745, text=' use', logprob=-0.39453125, special=False), generated_text=None, details=None)
-        TextGenerationStreamResponse(token=Token(
-            id=25,
-            text='.',
-            logprob=-0.5703125,
-            special=False),
-            generated_text='100% open source and built to be easy to use.',
-            details=StreamDetails(finish_reason=<FinishReason.Length: 'length'>, generated_tokens=12, seed=None)
-        )
-        ```
-        """
-        # NOTE: Text-generation integration is taken from the text-generation-inference project. It has more features
-        # like input/output validation (if Pydantic is installed). See `_text_generation.py` header for more details.
-
-        if decoder_input_details and not details:
-            warnings.warn(
-                "`decoder_input_details=True` has been passed to the server but `details=False` is set meaning that"
-                " the output from the server will be truncated."
-            )
-            decoder_input_details = False
-
-        # Validate parameters
-        parameters = TextGenerationParameters(
-            best_of=best_of,
-            details=details,
-            do_sample=do_sample,
-            max_new_tokens=max_new_tokens,
-            repetition_penalty=repetition_penalty,
-            return_full_text=return_full_text,
-            seed=seed,
-            stop=stop_sequences if stop_sequences is not None else [],
-            temperature=temperature,
-            top_k=top_k,
-            top_p=top_p,
-            truncate=truncate,
-            typical_p=typical_p,
-            watermark=watermark,
-            decoder_input_details=decoder_input_details,
-        )
-        request = TextGenerationRequest(inputs=prompt, stream=stream, parameters=parameters)
-        payload = asdict(request)
-
-        # Remove some parameters if not a TGI server
-        if not _is_tgi_server(model):
-            ignored_parameters = []
-            for key in "watermark", "stop", "details", "decoder_input_details":
-                if payload["parameters"][key] is not None:
-                    ignored_parameters.append(key)
-                del payload["parameters"][key]
-            if len(ignored_parameters) > 0:
-                warnings.warn(
-                    (
-                        "API endpoint/model for text-generation is not served via TGI. Ignoring parameters"
-                        f" {ignored_parameters}."
-                    ),
-                    UserWarning,
-                )
-            if details:
-                warnings.warn(
-                    (
-                        "API endpoint/model for text-generation is not served via TGI. Parameter `details=True` will"
-                        " be ignored meaning only the generated text will be returned."
-                    ),
-                    UserWarning,
-                )
-                details = False
-            if stream:
-                raise ValueError(
-                    "API endpoint/model for text-generation is not served via TGI. Cannot return output as a stream."
-                    " Please pass `stream=False` as input."
-                )
-
-        # Handle errors separately for more precise error messages
-        try:
-            bytes_output = await self.post(json=payload, model=model, task="text-generation", stream=stream)  # type: ignore
-        except _import_aiohttp().ClientResponseError as e:
-            error_message = getattr(e, "response_error_payload", {}).get("error", "")
-            if e.code == 400 and "The following `model_kwargs` are not used by the model" in error_message:
-                _set_as_non_tgi(model)
-                return await self.text_generation(  # type: ignore
-                    prompt=prompt,
-                    details=details,
-                    stream=stream,
-                    model=model,
-                    do_sample=do_sample,
-                    max_new_tokens=max_new_tokens,
-                    best_of=best_of,
-                    repetition_penalty=repetition_penalty,
-                    return_full_text=return_full_text,
-                    seed=seed,
-                    stop_sequences=stop_sequences,
-                    temperature=temperature,
-                    top_k=top_k,
-                    top_p=top_p,
-                    truncate=truncate,
-                    typical_p=typical_p,
-                    watermark=watermark,
-                    decoder_input_details=decoder_input_details,
-                )
-            raise_text_generation_error(e)
-
-        # Parse output
-        if stream:
-            return _async_stream_text_generation_response(bytes_output, details)  # type: ignore
-
-        data = _bytes_to_dict(bytes_output)[0]
-        return TextGenerationResponse(**data) if details else data["generated_text"]
-
-    async def text_to_image(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        height: Optional[float] = None,
-        width: Optional[float] = None,
-        num_inference_steps: Optional[float] = None,
-        guidance_scale: Optional[float] = None,
-        model: Optional[str] = None,
-        **kwargs,
-    ) -> "Image":
-        """
-        Generate an image based on a given text using a specified model.
-
-        <Tip warning={true}>
-
-        You must have `PIL` installed if you want to work with images (`pip install Pillow`).
-
-        </Tip>
-
-        Args:
-            prompt (`str`):
-                The prompt to generate an image from.
-            negative_prompt (`str`, *optional*):
-                An optional negative prompt for the image generation.
-            height (`float`, *optional*):
-                The height in pixels of the image to generate.
-            width (`float`, *optional*):
-                The width in pixels of the image to generate.
-            num_inference_steps (`int`, *optional*):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            guidance_scale (`float`, *optional*):
-                Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            model (`str`, *optional*):
-                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
-
-        Returns:
-            `Image`: The generated image.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-
-        >>> image = await client.text_to_image("An astronaut riding a horse on the moon.")
-        >>> image.save("astronaut.png")
-
-        >>> image = await client.text_to_image(
-        ...     "An astronaut riding a horse on the moon.",
-        ...     negative_prompt="low resolution, blurry",
-        ...     model="stabilityai/stable-diffusion-2-1",
-        ... )
-        >>> image.save("better_astronaut.png")
-        ```
-        """
-        parameters = {
-            "inputs": prompt,
-            "negative_prompt": negative_prompt,
-            "height": height,
-            "width": width,
-            "num_inference_steps": num_inference_steps,
-            "guidance_scale": guidance_scale,
-            **kwargs,
-        }
-        payload = {}
-        for key, value in parameters.items():
-            if value is not None:
-                payload[key] = value
-        response = await self.post(json=payload, model=model, task="text-to-image")
-        return _bytes_to_image(response)
-
-    async def text_to_speech(self, text: str, *, model: Optional[str] = None) -> bytes:
-        """
-        Synthesize an audio of a voice pronouncing a given text.
-
-        Args:
-            text (`str`):
-                The text to synthesize.
-            model (`str`, *optional*):
-                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
-
-        Returns:
-            `bytes`: The generated audio.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from pathlib import Path
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-
-        >>> audio = await client.text_to_speech("Hello world")
-        >>> Path("hello_world.flac").write_bytes(audio)
-        ```
-        """
-        return await self.post(json={"inputs": text}, model=model, task="text-to-speech")
-
-    async def zero_shot_image_classification(
-        self, image: ContentT, labels: List[str], *, model: Optional[str] = None
-    ) -> List[ClassificationOutput]:
-        """
-        Provide input image and text labels to predict text labels for the image.
-
-        Args:
-            image (`Union[str, Path, bytes, BinaryIO]`):
-                The input image to caption. It can be raw bytes, an image file, or a URL to an online image.
-            labels (`List[str]`):
-                List of string possible labels. The `len(labels)` must be greater than 1.
-            model (`str`, *optional*):
-                The model to use for inference. Can be a model ID hosted on the Hugging Face Hub or a URL to a deployed
-                Inference Endpoint. This parameter overrides the model defined at the instance level. Defaults to None.
-
-        Returns:
-            `List[Dict]`: List of classification outputs containing the predicted labels and their confidence.
-
-        Raises:
-            [`InferenceTimeoutError`]:
-                If the model is unavailable or the request times out.
-            `aiohttp.ClientResponseError`:
-                If the request fails with an HTTP error status code other than HTTP 503.
-
-        Example:
-        ```py
-        # Must be run in an async context
-        >>> from huggingface_hub import AsyncInferenceClient
-        >>> client = AsyncInferenceClient()
-
-        >>> await client.zero_shot_image_classification(
-        ...     "https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg",
-        ...     labels=["dog", "cat", "horse"],
-        ... )
-        [{"label": "dog", "score": 0.956}, ...]
-        ```
-        """
-
-        # Raise valueerror if input is less than 2 labels
-        if len(labels) < 2:
-            raise ValueError("You must specify at least 2 classes to compare. Please specify more than 1 class.")
-
-        response = await self.post(
-            json={"image": _b64_encode(image), "parameters": {"candidate_labels": ",".join(labels)}},
-            model=model,
-            task="zero-shot-image-classification",
-        )
-        return _bytes_to_dict(response)
-
-    def _resolve_url(self, model: Optional[str] = None, task: Optional[str] = None) -> str:
-        model = model or self.model
-
-        # If model is already a URL, ignore `task` and return directly
-        if model is not None and (model.startswith("http://") or model.startswith("https://")):
-            return model
-
-        # # If no model but task is set => fetch the recommended one for this task
-        if model is None:
-            if task is None:
-                raise ValueError(
-                    "You must specify at least a model (repo_id or URL) or a task, either when instantiating"
-                    " `InferenceClient` or when making a request."
-                )
-            model = _get_recommended_model(task)
-
-        # Compute InferenceAPI url
-        return (
-            # Feature-extraction and sentence-similarity are the only cases where we handle models with several tasks.
-            f"{INFERENCE_ENDPOINT}/pipeline/{task}/{model}"
-            if task in ("feature-extraction", "sentence-similarity")
-            # Otherwise, we use the default endpoint
-            else f"{INFERENCE_ENDPOINT}/models/{model}"
-        )

spaces/DaleChen/AutoGPT/autogpt/agent/__init__.py

@@ -1,4 +0,0 @@
-from autogpt.agent.agent import Agent
-from autogpt.agent.agent_manager import AgentManager
-
-__all__ = ["Agent", "AgentManager"]

spaces/Datasculptor/MusicGen/tests/modules/test_conv.py

@@ -1,203 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from itertools import product
-import math
-import random
-
-import pytest
-import torch
-from torch import nn
-
-from audiocraft.modules import (
-    NormConv1d,
-    NormConvTranspose1d,
-    StreamableConv1d,
-    StreamableConvTranspose1d,
-    pad1d,
-    unpad1d,
-)
-
-
-def test_get_extra_padding_for_conv1d():
-    # TODO: Implement me!
-    pass
-
-
-def test_pad1d_zeros():
-    x = torch.randn(1, 1, 20)
-
-    xp1 = pad1d(x, (0, 5), mode='constant', value=0.)
-    assert xp1.shape[-1] == 25
-    xp2 = pad1d(x, (5, 5), mode='constant', value=0.)
-    assert xp2.shape[-1] == 30
-    xp3 = pad1d(x, (0, 0), mode='constant', value=0.)
-    assert xp3.shape[-1] == 20
-    xp4 = pad1d(x, (10, 30), mode='constant', value=0.)
-    assert xp4.shape[-1] == 60
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (-1, 0), mode='constant', value=0.)
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (0, -1), mode='constant', value=0.)
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (-1, -1), mode='constant', value=0.)
-
-
-def test_pad1d_reflect():
-    x = torch.randn(1, 1, 20)
-
-    xp1 = pad1d(x, (0, 5), mode='reflect', value=0.)
-    assert xp1.shape[-1] == 25
-    xp2 = pad1d(x, (5, 5), mode='reflect', value=0.)
-    assert xp2.shape[-1] == 30
-    xp3 = pad1d(x, (0, 0), mode='reflect', value=0.)
-    assert xp3.shape[-1] == 20
-    xp4 = pad1d(x, (10, 30), mode='reflect', value=0.)
-    assert xp4.shape[-1] == 60
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (-1, 0), mode='reflect', value=0.)
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (0, -1), mode='reflect', value=0.)
-
-    with pytest.raises(AssertionError):
-        pad1d(x, (-1, -1), mode='reflect', value=0.)
-
-
-def test_unpad1d():
-    x = torch.randn(1, 1, 20)
-
-    u1 = unpad1d(x, (5, 5))
-    assert u1.shape[-1] == 10
-    u2 = unpad1d(x, (0, 5))
-    assert u2.shape[-1] == 15
-    u3 = unpad1d(x, (5, 0))
-    assert u3.shape[-1] == 15
-    u4 = unpad1d(x, (0, 0))
-    assert u4.shape[-1] == x.shape[-1]
-
-    with pytest.raises(AssertionError):
-        unpad1d(x, (-1, 0))
-
-    with pytest.raises(AssertionError):
-        unpad1d(x, (0, -1))
-
-    with pytest.raises(AssertionError):
-        unpad1d(x, (-1, -1))
-
-
-class TestNormConv1d:
-
-    def test_norm_conv1d_modules(self):
-        N, C, T = 2, 2, random.randrange(1, 100_000)
-        t0 = torch.randn(N, C, T)
-
-        C_out, kernel_size, stride = 1, 4, 1
-        expected_out_length = int((T - kernel_size) / stride + 1)
-        wn_conv = NormConv1d(C, 1, kernel_size=4, norm='weight_norm')
-        gn_conv = NormConv1d(C, 1, kernel_size=4, norm='time_group_norm')
-        nn_conv = NormConv1d(C, 1, kernel_size=4, norm='none')
-
-        assert isinstance(wn_conv.norm, nn.Identity)
-        assert isinstance(wn_conv.conv, nn.Conv1d)
-
-        assert isinstance(gn_conv.norm, nn.GroupNorm)
-        assert isinstance(gn_conv.conv, nn.Conv1d)
-
-        assert isinstance(nn_conv.norm, nn.Identity)
-        assert isinstance(nn_conv.conv, nn.Conv1d)
-
-        for conv_layer in [wn_conv, gn_conv, nn_conv]:
-            out = conv_layer(t0)
-            assert isinstance(out, torch.Tensor)
-            assert list(out.shape) == [N, C_out, expected_out_length]
-
-
-class TestNormConvTranspose1d:
-
-    def test_normalizations(self):
-        N, C, T = 2, 2, random.randrange(1, 100_000)
-        t0 = torch.randn(N, C, T)
-
-        C_out, kernel_size, stride = 1, 4, 1
-        expected_out_length = (T - 1) * stride + (kernel_size - 1) + 1
-
-        wn_convtr = NormConvTranspose1d(C, C_out, kernel_size=kernel_size, stride=stride, norm='weight_norm')
-        gn_convtr = NormConvTranspose1d(C, C_out, kernel_size=kernel_size, stride=stride, norm='time_group_norm')
-        nn_convtr = NormConvTranspose1d(C, C_out, kernel_size=kernel_size, stride=stride, norm='none')
-
-        assert isinstance(wn_convtr.norm, nn.Identity)
-        assert isinstance(wn_convtr.convtr, nn.ConvTranspose1d)
-
-        assert isinstance(gn_convtr.norm, nn.GroupNorm)
-        assert isinstance(gn_convtr.convtr, nn.ConvTranspose1d)
-
-        assert isinstance(nn_convtr.norm, nn.Identity)
-        assert isinstance(nn_convtr.convtr, nn.ConvTranspose1d)
-
-        for convtr_layer in [wn_convtr, gn_convtr, nn_convtr]:
-            out = convtr_layer(t0)
-            assert isinstance(out, torch.Tensor)
-            assert list(out.shape) == [N, C_out, expected_out_length]
-
-
-class TestStreamableConv1d:
-
-    def get_streamable_conv1d_output_length(self, length, kernel_size, stride, dilation):
-        # StreamableConv1d internally pads to make sure that the last window is full
-        padding_total = (kernel_size - 1) * dilation - (stride - 1)
-        n_frames = (length - kernel_size + padding_total) / stride + 1
-        ideal_length = (math.ceil(n_frames) - 1) * stride + (kernel_size - padding_total)
-        return ideal_length // stride
-
-    def test_streamable_conv1d(self):
-        N, C, T = 2, 2, random.randrange(1, 100_000)
-        t0 = torch.randn(N, C, T)
-        C_out = 1
-
-        # conv params are [(kernel_size, stride, dilation)]
-        conv_params = [(4, 1, 1), (4, 2, 1), (3, 1, 3), (10, 5, 1), (3, 2, 3)]
-        for causal, (kernel_size, stride, dilation) in product([False, True], conv_params):
-            expected_out_length = self.get_streamable_conv1d_output_length(T, kernel_size, stride, dilation)
-            sconv = StreamableConv1d(C, C_out, kernel_size=kernel_size, stride=stride, dilation=dilation, causal=causal)
-            out = sconv(t0)
-            assert isinstance(out, torch.Tensor)
-            print(list(out.shape), [N, C_out, expected_out_length])
-            assert list(out.shape) == [N, C_out, expected_out_length]
-
-
-class TestStreamableConvTranspose1d:
-
-    def get_streamable_convtr1d_output_length(self, length, kernel_size, stride):
-        padding_total = (kernel_size - stride)
-        return (length - 1) * stride - padding_total + (kernel_size - 1) + 1
-
-    def test_streamable_convtr1d(self):
-        N, C, T = 2, 2, random.randrange(1, 100_000)
-        t0 = torch.randn(N, C, T)
-
-        C_out = 1
-
-        with pytest.raises(AssertionError):
-            StreamableConvTranspose1d(C, C_out, kernel_size=4, causal=False, trim_right_ratio=0.5)
-            StreamableConvTranspose1d(C, C_out, kernel_size=4, causal=True, trim_right_ratio=-1.)
-            StreamableConvTranspose1d(C, C_out, kernel_size=4, causal=True, trim_right_ratio=2)
-
-        # causal params are [(causal, trim_right)]
-        causal_params = [(False, 1.0), (True, 1.0), (True, 0.5), (True, 0.0)]
-        # conv params are [(kernel_size, stride)]
-        conv_params = [(4, 1), (4, 2), (3, 1), (10, 5)]
-        for ((causal, trim_right_ratio), (kernel_size, stride)) in product(causal_params, conv_params):
-            expected_out_length = self.get_streamable_convtr1d_output_length(T, kernel_size, stride)
-            sconvtr = StreamableConvTranspose1d(C, C_out, kernel_size=kernel_size, stride=stride,
-                                                causal=causal, trim_right_ratio=trim_right_ratio)
-            out = sconvtr(t0)
-            assert isinstance(out, torch.Tensor)
-            assert list(out.shape) == [N, C_out, expected_out_length]

spaces/Datatrooper/zero-shot-image-classification/app.py

@@ -1,28 +0,0 @@
-from turtle import title
-import gradio as gr
-from transformers import pipeline
-import numpy as np
-from PIL import Image
-
-
-pipe = pipeline("zero-shot-image-classification", model="openai/clip-vit-base-patch32")
-images="dog.jpg"
-
-def shot(image, labels_text):
-    PIL_image = Image.fromarray(np.uint8(image)).convert('RGB')
-    labels = labels_text.split(",")
-    res = pipe(images=PIL_image, 
-           candidate_labels=labels,
-           hypothesis_template= "This is a photo of a {}")
-    return {dic["label"]: dic["score"] for dic in res}
-    
-iface = gr.Interface(shot, 
-                    ["image", "text"], 
-                    "label", 
-                    examples=[["dog.jpg", "dog,cat,bird"], 
-                              ["germany.jpg", "germany,belgium,colombia"],
-                              ["colombia.jpg", "germany,belgium,colombia"]],
-                    description="Add a picture and a list of labels separated by commas",
-                    title="Zero-shot Image Classification")
-
-iface.launch()

spaces/Dinoking/Guccio-AI-Designer/models/stylegan/stylegan_tf/dnnlib/tflib/autosummary.py

@@ -1,184 +0,0 @@
-# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
-#
-# This work is licensed under the Creative Commons Attribution-NonCommercial
-# 4.0 International License. To view a copy of this license, visit
-# http://creativecommons.org/licenses/by-nc/4.0/ or send a letter to
-# Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
-
-"""Helper for adding automatically tracked values to Tensorboard.
-
-Autosummary creates an identity op that internally keeps track of the input
-values and automatically shows up in TensorBoard. The reported value
-represents an average over input components. The average is accumulated
-constantly over time and flushed when save_summaries() is called.
-
-Notes:
-- The output tensor must be used as an input for something else in the
-  graph. Otherwise, the autosummary op will not get executed, and the average
-  value will not get accumulated.
-- It is perfectly fine to include autosummaries with the same name in
-  several places throughout the graph, even if they are executed concurrently.
-- It is ok to also pass in a python scalar or numpy array. In this case, it
-  is added to the average immediately.
-"""
-
-from collections import OrderedDict
-import numpy as np
-import tensorflow as tf
-from tensorboard import summary as summary_lib
-from tensorboard.plugins.custom_scalar import layout_pb2
-
-from . import tfutil
-from .tfutil import TfExpression
-from .tfutil import TfExpressionEx
-
-_dtype = tf.float64
-_vars = OrderedDict()  # name => [var, ...]
-_immediate = OrderedDict()  # name => update_op, update_value
-_finalized = False
-_merge_op = None
-
-
-def _create_var(name: str, value_expr: TfExpression) -> TfExpression:
-    """Internal helper for creating autosummary accumulators."""
-    assert not _finalized
-    name_id = name.replace("/", "_")
-    v = tf.cast(value_expr, _dtype)
-
-    if v.shape.is_fully_defined():
-        size = np.prod(tfutil.shape_to_list(v.shape))
-        size_expr = tf.constant(size, dtype=_dtype)
-    else:
-        size = None
-        size_expr = tf.reduce_prod(tf.cast(tf.shape(v), _dtype))
-
-    if size == 1:
-        if v.shape.ndims != 0:
-            v = tf.reshape(v, [])
-        v = [size_expr, v, tf.square(v)]
-    else:
-        v = [size_expr, tf.reduce_sum(v), tf.reduce_sum(tf.square(v))]
-    v = tf.cond(tf.is_finite(v[1]), lambda: tf.stack(v), lambda: tf.zeros(3, dtype=_dtype))
-
-    with tfutil.absolute_name_scope("Autosummary/" + name_id), tf.control_dependencies(None):
-        var = tf.Variable(tf.zeros(3, dtype=_dtype), trainable=False)  # [sum(1), sum(x), sum(x**2)]
-    update_op = tf.cond(tf.is_variable_initialized(var), lambda: tf.assign_add(var, v), lambda: tf.assign(var, v))
-
-    if name in _vars:
-        _vars[name].append(var)
-    else:
-        _vars[name] = [var]
-    return update_op
-
-
-def autosummary(name: str, value: TfExpressionEx, passthru: TfExpressionEx = None) -> TfExpressionEx:
-    """Create a new autosummary.
-
-    Args:
-        name:     Name to use in TensorBoard
-        value:    TensorFlow expression or python value to track
-        passthru: Optionally return this TF node without modifications but tack an autosummary update side-effect to this node.
-
-    Example use of the passthru mechanism:
-
-    n = autosummary('l2loss', loss, passthru=n)
-
-    This is a shorthand for the following code:
-
-    with tf.control_dependencies([autosummary('l2loss', loss)]):
-        n = tf.identity(n)
-    """
-    tfutil.assert_tf_initialized()
-    name_id = name.replace("/", "_")
-
-    if tfutil.is_tf_expression(value):
-        with tf.name_scope("summary_" + name_id), tf.device(value.device):
-            update_op = _create_var(name, value)
-            with tf.control_dependencies([update_op]):
-                return tf.identity(value if passthru is None else passthru)
-
-    else:  # python scalar or numpy array
-        if name not in _immediate:
-            with tfutil.absolute_name_scope("Autosummary/" + name_id), tf.device(None), tf.control_dependencies(None):
-                update_value = tf.placeholder(_dtype)
-                update_op = _create_var(name, update_value)
-                _immediate[name] = update_op, update_value
-
-        update_op, update_value = _immediate[name]
-        tfutil.run(update_op, {update_value: value})
-        return value if passthru is None else passthru
-
-
-def finalize_autosummaries() -> None:
-    """Create the necessary ops to include autosummaries in TensorBoard report.
-    Note: This should be done only once per graph.
-    """
-    global _finalized
-    tfutil.assert_tf_initialized()
-
-    if _finalized:
-        return None
-
-    _finalized = True
-    tfutil.init_uninitialized_vars([var for vars_list in _vars.values() for var in vars_list])
-
-    # Create summary ops.
-    with tf.device(None), tf.control_dependencies(None):
-        for name, vars_list in _vars.items():
-            name_id = name.replace("/", "_")
-            with tfutil.absolute_name_scope("Autosummary/" + name_id):
-                moments = tf.add_n(vars_list)
-                moments /= moments[0]
-                with tf.control_dependencies([moments]):  # read before resetting
-                    reset_ops = [tf.assign(var, tf.zeros(3, dtype=_dtype)) for var in vars_list]
-                    with tf.name_scope(None), tf.control_dependencies(reset_ops):  # reset before reporting
-                        mean = moments[1]
-                        std = tf.sqrt(moments[2] - tf.square(moments[1]))
-                        tf.summary.scalar(name, mean)
-                        tf.summary.scalar("xCustomScalars/" + name + "/margin_lo", mean - std)
-                        tf.summary.scalar("xCustomScalars/" + name + "/margin_hi", mean + std)
-
-    # Group by category and chart name.
-    cat_dict = OrderedDict()
-    for series_name in sorted(_vars.keys()):
-        p = series_name.split("/")
-        cat = p[0] if len(p) >= 2 else ""
-        chart = "/".join(p[1:-1]) if len(p) >= 3 else p[-1]
-        if cat not in cat_dict:
-            cat_dict[cat] = OrderedDict()
-        if chart not in cat_dict[cat]:
-            cat_dict[cat][chart] = []
-        cat_dict[cat][chart].append(series_name)
-
-    # Setup custom_scalar layout.
-    categories = []
-    for cat_name, chart_dict in cat_dict.items():
-        charts = []
-        for chart_name, series_names in chart_dict.items():
-            series = []
-            for series_name in series_names:
-                series.append(layout_pb2.MarginChartContent.Series(
-                    value=series_name,
-                    lower="xCustomScalars/" + series_name + "/margin_lo",
-                    upper="xCustomScalars/" + series_name + "/margin_hi"))
-            margin = layout_pb2.MarginChartContent(series=series)
-            charts.append(layout_pb2.Chart(title=chart_name, margin=margin))
-        categories.append(layout_pb2.Category(title=cat_name, chart=charts))
-    layout = summary_lib.custom_scalar_pb(layout_pb2.Layout(category=categories))
-    return layout
-
-def save_summaries(file_writer, global_step=None):
-    """Call FileWriter.add_summary() with all summaries in the default graph,
-    automatically finalizing and merging them on the first call.
-    """
-    global _merge_op
-    tfutil.assert_tf_initialized()
-
-    if _merge_op is None:
-        layout = finalize_autosummaries()
-        if layout is not None:
-            file_writer.add_summary(layout)
-        with tf.device(None), tf.control_dependencies(None):
-            _merge_op = tf.summary.merge_all()
-
-    file_writer.add_summary(_merge_op.eval(), global_step)

spaces/DonDoesStuff/sd_xl_base_0.9/style.css

@@ -1,84 +0,0 @@
-#col-container {
-    max-width: 800px;
-    margin-left: auto;
-    margin-right: auto;
-}
-a {
-    color: inherit;
-    text-decoration: underline;
-}
-.gradio-container {
-    font-family: 'IBM Plex Sans', sans-serif;
-}
-.gr-button {
-    color: white;
-    border-color: #9d66e5;
-    background: #9d66e5;
-}
-input[type='range'] {
-    accent-color: #9d66e5;
-}
-.dark input[type='range'] {
-    accent-color: #dfdfdf;
-}
-.container {
-    max-width: 800px;
-    margin: auto;
-    padding-top: 1.5rem;
-}
-#gallery {
-    min-height: 22rem;
-    margin-bottom: 15px;
-    margin-left: auto;
-    margin-right: auto;
-    border-bottom-right-radius: .5rem !important;
-    border-bottom-left-radius: .5rem !important;
-}
-#gallery>div>.h-full {
-    min-height: 20rem;
-}
-.details:hover {
-    text-decoration: underline;
-}
-.gr-button {
-    white-space: nowrap;
-}
-.gr-button:focus {
-    border-color: rgb(147 197 253 / var(--tw-border-opacity));
-    outline: none;
-    box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000);
-    --tw-border-opacity: 1;
-    --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
-    --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color);
-    --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity));
-    --tw-ring-opacity: .5;
-}
-#advanced-options {
-    margin-bottom: 20px;
-}
-.footer {
-    margin-bottom: 45px;
-    margin-top: 35px;
-    text-align: center;
-    border-bottom: 1px solid #e5e5e5;
-}
-.footer>p {
-    font-size: .8rem;
-    display: inline-block;
-    padding: 0 10px;
-    transform: translateY(10px);
-    background: white;
-}
-.dark .logo{ filter: invert(1); }
-.dark .footer {
-    border-color: #303030;
-}
-.dark .footer>p {
-    background: #0b0f19;
-}
-.acknowledgments h4{
-    margin: 1.25em 0 .25em 0;
-    font-weight: bold;
-    font-size: 115%;
-}
-

spaces/Duskfallcrew/shindi-realistic-skin-style/README.md

@@ -1,13 +0,0 @@
----
-title: Shindi Realistic Skin Style
-emoji: 🐠
-colorFrom: purple
-colorTo: gray
-sdk: gradio
-sdk_version: 3.16.2
-app_file: app.py
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/ECCV2022/bytetrack/tutorials/ctracker/mot_online/matching.py

@@ -1,198 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import lap
-import numpy as np
-import scipy
-from cython_bbox import bbox_overlaps as bbox_ious
-from scipy.spatial.distance import cdist
-
-chi2inv95 = {
-    1: 3.8415,
-    2: 5.9915,
-    3: 7.8147,
-    4: 9.4877,
-    5: 11.070,
-    6: 12.592,
-    7: 14.067,
-    8: 15.507,
-    9: 16.919}
-
-def merge_matches(m1, m2, shape):
-    O,P,Q = shape
-    m1 = np.asarray(m1)
-    m2 = np.asarray(m2)
-
-    M1 = scipy.sparse.coo_matrix((np.ones(len(m1)), (m1[:, 0], m1[:, 1])), shape=(O, P))
-    M2 = scipy.sparse.coo_matrix((np.ones(len(m2)), (m2[:, 0], m2[:, 1])), shape=(P, Q))
-
-    mask = M1*M2
-    match = mask.nonzero()
-    match = list(zip(match[0], match[1]))
-    unmatched_O = tuple(set(range(O)) - set([i for i, j in match]))
-    unmatched_Q = tuple(set(range(Q)) - set([j for i, j in match]))
-
-    return match, unmatched_O, unmatched_Q
-
-
-def _indices_to_matches(cost_matrix, indices, thresh):
-    matched_cost = cost_matrix[tuple(zip(*indices))]
-    matched_mask = (matched_cost <= thresh)
-
-    matches = indices[matched_mask]
-    unmatched_a = tuple(set(range(cost_matrix.shape[0])) - set(matches[:, 0]))
-    unmatched_b = tuple(set(range(cost_matrix.shape[1])) - set(matches[:, 1]))
-
-    return matches, unmatched_a, unmatched_b
-
-
-def linear_assignment(cost_matrix, thresh):
-    if cost_matrix.size == 0:
-        return np.empty((0, 2), dtype=int), tuple(range(cost_matrix.shape[0])), tuple(range(cost_matrix.shape[1]))
-    matches, unmatched_a, unmatched_b = [], [], []
-    cost, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh)
-    for ix, mx in enumerate(x):
-        if mx >= 0:
-            matches.append([ix, mx])
-    unmatched_a = np.where(x < 0)[0]
-    unmatched_b = np.where(y < 0)[0]
-    matches = np.asarray(matches)
-    return matches, unmatched_a, unmatched_b
-
-
-def ious(atlbrs, btlbrs):
-    """
-    Compute cost based on IoU
-    :type atlbrs: list[tlbr] | np.ndarray
-    :type atlbrs: list[tlbr] | np.ndarray
-
-    :rtype ious np.ndarray
-    """
-    ious = np.zeros((len(atlbrs), len(btlbrs)), dtype=np.float)
-    if ious.size == 0:
-        return ious
-
-    ious = bbox_ious(
-        np.ascontiguousarray(atlbrs, dtype=np.float),
-        np.ascontiguousarray(btlbrs, dtype=np.float)
-    )
-
-    return ious
-
-
-def iou_distance(atracks, btracks):
-    """
-    Compute cost based on IoU
-    :type atracks: list[STrack]
-    :type btracks: list[STrack]
-
-    :rtype cost_matrix np.ndarray
-    """
-
-    if (len(atracks)>0 and isinstance(atracks[0], np.ndarray)) or (len(btracks) > 0 and isinstance(btracks[0], np.ndarray)):
-        atlbrs = atracks
-        btlbrs = btracks
-    else:
-        atlbrs = [track.tlbr for track in atracks]
-        btlbrs = [track.tlbr for track in btracks]
-    _ious = ious(atlbrs, btlbrs)
-    cost_matrix = 1 - _ious
-
-    return cost_matrix
-
-def embedding_distance(tracks, detections, metric='cosine'):
-    """
-    :param tracks: list[STrack]
-    :param detections: list[BaseTrack]
-    :param metric:
-    :return: cost_matrix np.ndarray
-    """
-
-    cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float)
-    if cost_matrix.size == 0:
-        return cost_matrix
-    det_features = np.asarray([track.curr_feat for track in detections], dtype=np.float)
-    #for i, track in enumerate(tracks):
-        #cost_matrix[i, :] = np.maximum(0.0, cdist(track.smooth_feat.reshape(1,-1), det_features, metric))
-    track_features = np.asarray([track.smooth_feat for track in tracks], dtype=np.float)
-    cost_matrix = np.maximum(0.0, cdist(track_features, det_features, metric))  # Nomalized features
-    return cost_matrix
-
-def embedding_distance2(tracks, detections, metric='cosine'):
-    """
-    :param tracks: list[STrack]
-    :param detections: list[BaseTrack]
-    :param metric:
-    :return: cost_matrix np.ndarray
-    """
-
-    cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float)
-    if cost_matrix.size == 0:
-        return cost_matrix
-    det_features = np.asarray([track.curr_feat for track in detections], dtype=np.float)
-    #for i, track in enumerate(tracks):
-        #cost_matrix[i, :] = np.maximum(0.0, cdist(track.smooth_feat.reshape(1,-1), det_features, metric))
-    track_features = np.asarray([track.smooth_feat for track in tracks], dtype=np.float)
-    cost_matrix = np.maximum(0.0, cdist(track_features, det_features, metric))  # Nomalized features
-    track_features = np.asarray([track.features[0] for track in tracks], dtype=np.float)
-    cost_matrix2 = np.maximum(0.0, cdist(track_features, det_features, metric))  # Nomalized features
-    track_features = np.asarray([track.features[len(track.features)-1] for track in tracks], dtype=np.float)
-    cost_matrix3 = np.maximum(0.0, cdist(track_features, det_features, metric))  # Nomalized features
-    for row in range(len(cost_matrix)):
-        cost_matrix[row] = (cost_matrix[row]+cost_matrix2[row]+cost_matrix3[row])/3
-    return cost_matrix
-
-
-def vis_id_feature_A_distance(tracks, detections, metric='cosine'):
-    track_features = []
-    det_features = []
-    leg1 = len(tracks)
-    leg2 = len(detections)
-    cost_matrix = np.zeros((leg1, leg2), dtype=np.float)
-    cost_matrix_det = np.zeros((leg1, leg2), dtype=np.float)
-    cost_matrix_track = np.zeros((leg1, leg2), dtype=np.float)
-    det_features = np.asarray([track.curr_feat for track in detections], dtype=np.float)
-    track_features = np.asarray([track.smooth_feat for track in tracks], dtype=np.float)
-    if leg2 != 0:
-        cost_matrix_det = np.maximum(0.0, cdist(det_features, det_features, metric))
-    if leg1 != 0:
-        cost_matrix_track = np.maximum(0.0, cdist(track_features, track_features, metric))
-    if cost_matrix.size == 0:
-        return track_features, det_features, cost_matrix, cost_matrix_det, cost_matrix_track
-    cost_matrix = np.maximum(0.0, cdist(track_features, det_features, metric))
-    if leg1 > 10:
-        leg1 = 10
-        tracks = tracks[:10]
-    if leg2 > 10:
-        leg2 = 10
-        detections = detections[:10]
-    det_features = np.asarray([track.curr_feat for track in detections], dtype=np.float)
-    track_features = np.asarray([track.smooth_feat for track in tracks], dtype=np.float)
-    return track_features, det_features, cost_matrix, cost_matrix_det, cost_matrix_track
-
-def gate_cost_matrix(kf, cost_matrix, tracks, detections, only_position=False):
-    if cost_matrix.size == 0:
-        return cost_matrix
-    gating_dim = 2 if only_position else 4
-    gating_threshold = chi2inv95[gating_dim]
-    measurements = np.asarray([det.to_xyah() for det in detections])
-    for row, track in enumerate(tracks):
-        gating_distance = kf.gating_distance(
-            track.mean, track.covariance, measurements, only_position)
-        cost_matrix[row, gating_distance > gating_threshold] = np.inf
-    return cost_matrix
-
-
-def fuse_motion(kf, cost_matrix, tracks, detections, only_position=False, lambda_=0.98):
-    if cost_matrix.size == 0:
-        return cost_matrix
-    gating_dim = 2 if only_position else 4
-    gating_threshold = chi2inv95[gating_dim]
-    measurements = np.asarray([det.to_xyah() for det in detections])
-    for row, track in enumerate(tracks):
-        gating_distance = kf.gating_distance(
-            track.mean, track.covariance, measurements, only_position, metric='maha')
-        cost_matrix[row, gating_distance > gating_threshold] = np.inf
-        cost_matrix[row] = lambda_ * cost_matrix[row] + (1 - lambda_) * gating_distance
-    return cost_matrix

spaces/EXPOSUREEE/Ai-Image-Enhancer/inference_realesrgan.py

@@ -1,128 +0,0 @@
-import argparse
-import cv2
-import glob
-import os
-from basicsr.archs.rrdbnet_arch import RRDBNet
-
-from realesrgan import RealESRGANer
-from realesrgan.archs.srvgg_arch import SRVGGNetCompact
-
-
-def main():
-    """Inference demo for Real-ESRGAN.
-    """
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-i', '--input', type=str, default='inputs', help='Input image or folder')
-    parser.add_argument(
-        '-n',
-        '--model_name',
-        type=str,
-        default='RealESRGAN_x4plus',
-        help=('Model names: RealESRGAN_x4plus | RealESRNet_x4plus | RealESRGAN_x4plus_anime_6B | RealESRGAN_x2plus'
-              'RealESRGANv2-anime-xsx2 | RealESRGANv2-animevideo-xsx2-nousm | RealESRGANv2-animevideo-xsx2'
-              'RealESRGANv2-anime-xsx4 | RealESRGANv2-animevideo-xsx4-nousm | RealESRGANv2-animevideo-xsx4'))
-    parser.add_argument('-o', '--output', type=str, default='results', help='Output folder')
-    parser.add_argument('-s', '--outscale', type=float, default=4, help='The final upsampling scale of the image')
-    parser.add_argument('--suffix', type=str, default='out', help='Suffix of the restored image')
-    parser.add_argument('-t', '--tile', type=int, default=0, help='Tile size, 0 for no tile during testing')
-    parser.add_argument('--tile_pad', type=int, default=10, help='Tile padding')
-    parser.add_argument('--pre_pad', type=int, default=0, help='Pre padding size at each border')
-    parser.add_argument('--face_enhance', action='store_true', help='Use GFPGAN to enhance face')
-    parser.add_argument('--half', action='store_true', help='Use half precision during inference')
-    parser.add_argument(
-        '--alpha_upsampler',
-        type=str,
-        default='realesrgan',
-        help='The upsampler for the alpha channels. Options: realesrgan | bicubic')
-    parser.add_argument(
-        '--ext',
-        type=str,
-        default='auto',
-        help='Image extension. Options: auto | jpg | png, auto means using the same extension as inputs')
-    args = parser.parse_args()
-
-    # determine models according to model names
-    args.model_name = args.model_name.split('.')[0]
-    if args.model_name in ['RealESRGAN_x4plus', 'RealESRNet_x4plus']:  # x4 RRDBNet model
-        model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
-        netscale = 4
-    elif args.model_name in ['RealESRGAN_x4plus_anime_6B']:  # x4 RRDBNet model with 6 blocks
-        model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=6, num_grow_ch=32, scale=4)
-        netscale = 4
-    elif args.model_name in ['RealESRGAN_x2plus']:  # x2 RRDBNet model
-        model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=2)
-        netscale = 2
-    elif args.model_name in [
-            'RealESRGANv2-anime-xsx2', 'RealESRGANv2-animevideo-xsx2-nousm', 'RealESRGANv2-animevideo-xsx2'
-    ]:  # x2 VGG-style model (XS size)
-        model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=16, upscale=2, act_type='prelu')
-        netscale = 2
-    elif args.model_name in [
-            'RealESRGANv2-anime-xsx4', 'RealESRGANv2-animevideo-xsx4-nousm', 'RealESRGANv2-animevideo-xsx4'
-    ]:  # x4 VGG-style model (XS size)
-        model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=16, upscale=4, act_type='prelu')
-        netscale = 4
-
-    # determine model paths
-    model_path = os.path.join('.', args.model_name + '.pth')
-    if not os.path.isfile(model_path):
-        model_path = os.path.join('.', args.model_name + '.pth')
-    if not os.path.isfile(model_path):
-        raise ValueError(f'Model {args.model_name} does not exist.')
-
-    # restorer
-    upsampler = RealESRGANer(
-        scale=netscale,
-        model_path=model_path,
-        model=model,
-        tile=args.tile,
-        tile_pad=args.tile_pad,
-        pre_pad=args.pre_pad,
-        half=args.half)
-
-    if args.face_enhance:  # Use GFPGAN for face enhancement
-        from gfpgan import GFPGANer
-        face_enhancer = GFPGANer(
-            model_path='https://github.com/TencentARC/GFPGAN/releases/download/v0.2.0/GFPGANCleanv1-NoCE-C2.pth',
-            upscale=args.outscale,
-            arch='clean',
-            channel_multiplier=2,
-            bg_upsampler=upsampler)
-    os.makedirs(args.output, exist_ok=True)
-
-    if os.path.isfile(args.input):
-        paths = [args.input]
-    else:
-        paths = sorted(glob.glob(os.path.join(args.input, '*')))
-
-    for idx, path in enumerate(paths):
-        imgname, extension = os.path.splitext(os.path.basename(path))
-        print('Testing', idx, imgname)
-
-        img = cv2.imread(path, cv2.IMREAD_UNCHANGED)
-        if len(img.shape) == 3 and img.shape[2] == 4:
-            img_mode = 'RGBA'
-        else:
-            img_mode = None
-
-        try:
-            if args.face_enhance:
-                _, _, output = face_enhancer.enhance(img, has_aligned=False, only_center_face=False, paste_back=True)
-            else:
-                output, _ = upsampler.enhance(img, outscale=args.outscale)
-        except RuntimeError as error:
-            print('Error', error)
-            print('If you encounter CUDA out of memory, try to set --tile with a smaller number.')
-        else:
-            if args.ext == 'auto':
-                extension = extension[1:]
-            else:
-                extension = args.ext
-            if img_mode == 'RGBA':  # RGBA images should be saved in png format
-                extension = 'png'
-            save_path = os.path.join(args.output, f'{imgname}_{args.suffix}.{extension}')
-            cv2.imwrite(save_path, output)
-
-
-if __name__ == '__main__':
-    main()

spaces/Epitech/hand-sign-detection/app.py

@@ -1,45 +0,0 @@
-import cv2
-import gradio as gr
-import math
-import numpy as np
-from cvzone.ClassificationModule import Classifier
-from cvzone.HandTrackingModule import HandDetector
-
-bgSize = 96
-classifier = Classifier("keras_model.h5", "labels.txt")
-detector = HandDetector(maxHands=1)
-labels = ["Look", "Drink", "Eat", "Ok"]
-offset = 20
-
-def segment(image):
-    hands, frame = detector.findHands(image)
-    try:
-        if hands:
-            hand = hands[0]
-            x, y, w, h = hand['bbox']
-            croppedHand = np.ones((bgSize, bgSize, 3), np.uint8) * 12
-            imgCrop = frame[y - offset:y + h +
-                            offset, x - offset:x + w + offset]
-            aspectRatio = h / w
-            if aspectRatio > 1:
-                constant = bgSize / h
-                wComputed = math.floor(constant * w)
-                bgResize = cv2.resize(imgCrop, (wComputed, bgSize))
-                bgResizeShape = bgResize.shape
-                wGap = math.floor((bgSize-wComputed)/2)
-                croppedHand[:bgResizeShape[0],
-                            wGap:wGap + wComputed] = bgResize
-            else:
-                constant = bgSize / w
-                hComputed = math.floor(constant * h)
-                bgResize = cv2.resize(imgCrop, (bgSize, hComputed))
-                bgResizeShape = bgResize.shape
-                hGap = math.floor((bgSize - hComputed) / 2)
-                croppedHand[hGap: hComputed + hGap, :] = bgResize
-            _, index = classifier.getPrediction(croppedHand, draw=False)
-            return labels[index]
-    except Exception as e:
-        print(e)
-    return 'No sign detected'
-
-gr.interface.Interface(fn=segment, live=True, inputs=gr.Image(source='webcam', streaming=True), outputs="text").launch()

spaces/EuroPython2022/Leaderboard/app.py

@@ -1,39 +0,0 @@
-import os
-import requests
-import pandas as pd
-import gradio as gr
-from huggingface_hub.hf_api import SpaceInfo
-from pathlib import Path
-
-
-path = f"https://huggingface.co/api/spaces" 	
-
-    
-def get_europython_spaces():
-    r = requests.get(path)
-    d = r.json()
-    spaces = [SpaceInfo(**x) for x in d]
-    blocks_spaces = {}
-    for i in range(0,len(spaces)):
-        if spaces[i].id.split('/')[0] == 'EuroPython2022' and hasattr(spaces[i], 'likes') and spaces[i].id != 'EuroPython2022/Leaderboard' and spaces[i].id != 'EuroPython2022/README':
-            blocks_spaces[spaces[i].id]=spaces[i].likes
-    df = pd.DataFrame(
-    [{"Spaces_Name": Spaces, "likes": likes} for Spaces,likes in blocks_spaces.items()])
-    df = df.sort_values(by=['likes'],ascending=False)
-    return df
-
-
-block = gr.Blocks()
-
-with block:    
-    gr.Markdown("""Leaderboard for the most popular EuroPython 2022 Spaces. To learn more and join, see <a href="https://huggingface.co/EuroPython2022" target="_blank" style="text-decoration: underline">EuroPython 2022 Event</a>""")
-    with gr.Tabs():
-        with gr.TabItem("EuroPython 2022 Leaderboard"):
-            with gr.Row():
-                data = gr.outputs.Dataframe(type="pandas")
-            with gr.Row():
-                data_run = gr.Button("Refresh")
-                data_run.click(get_europython_spaces, inputs=None, outputs=data)
-
-    block.load(get_europython_spaces, inputs=None, outputs=data)                
-block.launch()

spaces/EuroPython2022/clickbaitonator/fudge/README.md

@@ -1,155 +0,0 @@
-# FUDGE: Controlled Text Generation With Future Discriminators
-
-This repo contains code corresponding to the paper FUDGE: Controlled Text Generation With Future Discriminators (https://arxiv.org/abs/2104.05218) by Kevin Yang and Dan Klein, published at NAACL 2021. 
-
-You can also find a video presentation at http://somup.com/crhlVPFKN7 and the corresponding slides in `slides.pptx`. 
-
-## Setup/Installation
-
-We tested on Python 3.8.5 but earlier versions of Python 3 are almost certainly fine. To get the required packages (other versions likely to work too):
-
-```
-pip install -r requirements.txt
-```
-
-Additionally, to get our pre-trained predictor checkpoints and training data, run:
-
-```
-wget https://naacl2021-fudge-files.s3.amazonaws.com/large_files.zip
-```
-
-and extract the zip to the top-level `lm-prediction/` folder. (There should be three folders, `ckpt/`, `train_data/`, and `topic_human_evals/`. The zip is 7GB.) Note: the zip seems to not work for some people actually, if this is the case you can get the files directly from https://drive.google.com/drive/folders/1GZfOGqpQxDmIfD2RvuhUQla9eX2OHUXU?usp=sharing (13GB). 
-
-`ckpt/` contains predictor checkpoints for each task if you are just interested in running inference. (Note that for the paper results, we used predictors trained with an older version of the code, but the new checkpoints get similar results, so you are OK to use the new predictors provided here if e.g. you just want to use FUDGE as a baseline. You can just run the evaluation commands provided below; it should take maybe 5-60 minutes depending on the task and your compute, assuming you have a GPU.)
-
-`train_data/` contains our GPT2-generated training data for the poetry and topic tasks' predictors. See https://github.com/raosudha89/GYAFC-corpus for instructions on gaining access to the GYAFC data used for the machine translation formality task; replace our dummy folders with the corresponding folders/files if you want to train our formality predictor. 
-
-## Clickbait
-To generate outputs, run:
-
-```
-python -u evaluate_clickbait.py --ckpt ckpt/topic/future_word_predictor/model.pth.tar --dataset_info ckpt/topic/future_word_predictor/dataset_info --in_file topic_data/topic_prefixes.txt --condition_lambda 4.0 --verbose --precondition_topk 200 --length_cutoff 80 --device cpu
-
-python -u evaluate_clickbait.py --ckpt ckpt/formality/predictor_gyafc_entertainment_music/model.pth.tar --dataset_info ckpt/formality/predictor_gyafc_entertainment_music/dataset_info --in_file formality_data/fisher_test_oracle.es 
-
-python -u evaluate_clickbait.py --ckpt ckpt/topic/future_word_predictor/model.pth.tar --dataset_info ckpt/topic/future_word_predictor/dataset_info --in_file topic_data/topic_prefixes.txt --condition_lambda 4.0 --verbose --precondition_topk 200 --sample_size 3 --max_sample_batch 1 --length_cutoff 80 --log_file clickbait_preds.log
-```
-
-Then evaluate metrics using:
-
-```
-python eval_topic_metrics.py --log_file topic_preds.log --tw_dir topic_data/test_wordlists
-```
-
-
-## Poetry Couplet Completion
-
-### Evaluation
-
-To generate outputs, run:
-
-```
-python -u evaluate_poetry.py --iambic_ckpt ckpt/poetry/iambic_predictor/model.pth.tar --rhyme_ckpt ckpt/poetry/rhyme_predictor/model.pth.tar --newline_ckpt ckpt/poetry/newline_predictor/model.pth.tar --dataset_info ckpt/poetry/rhyme_predictor/dataset_info --rhyme_info ckpt/poetry/rhyme_predictor/rhyme_info --prefix_file poetry_data/couplet_prefixes.txt --precondition_topk 200 > poetry_preds.log
-```
-
-Then evaluate metrics using:
-
-```
-python eval_poetry_metrics.py --pred_file poetry_preds.log --prefix_file poetry_data/couplet_prefixes.txt
-```
-
-### Training your own predictors
-
-Example commands for all three predictors used in the poetry task below. (You actually probably don't need so many epochs for iambic and rhyme; in any case the commands will save intermediate ckpts so you can just stop them early if needed by inspecting the log.)
-
-Iambic predictor:
-
-```
-python -u main.py --task iambic --data_dir train_data/gpt2_generations --save_dir ckpt/poetry/iambic_retrain_predictor --num_workers 20 --batch_size 128 --epoch_max_len 100000 --validation_freq 10  --lr 2e-4 --epochs 1500 > iambic_retrain_predictor.log
-```
-
-Rhyme predictor:
-
-```
-python -u main.py --task rhyme --data_dir train_data/gpt2_generations --save_dir ckpt/poetry/rhyme_retrain_predictor --num_workers 20 --batch_size 128 --epoch_max_len 100000 --validation_freq 10  --lr 2e-4 --epochs 1500 > rhyme_retrain_predictor.log
-```
-
-End of sentence predictor (referred to as "newline" in the code; 50 epochs is more than enough for this one):
-
-```
-python -u main.py --task newline --data_dir train_data/gpt2_generations --save_dir ckpt/poetry/newline_retrain_predictor --num_workers 20 --batch_size 128 --epoch_max_len 100000 --validation_freq 10  --lr 2e-4 --epochs 50 > newline_retrain_predictor.log
-```
-
-The same evaluation commands as before will work; just modify the paths in the command to point to `model_best.pth.tar`, `dataset_info`, and `rhyme_info` from your newly trained ckpt folders. 
-
-## Topic Control
-
-### Evaluation
-
-To generate outputs, run:
-
-```
-python -u evaluate_topic.py --ckpt ckpt/topic/future_word_predictor/model.pth.tar --dataset_info ckpt/topic/future_word_predictor/dataset_info --prefix_file topic_data/topic_prefixes.txt --wordlist_dir topic_data/wordlists --condition_lambda 4.0 --verbose --precondition_topk 200 --topk 10 --sample_size 3 --max_sample_batch 1 --length_cutoff 80 --log_file topic_preds.log
-```
-
-Then evaluate metrics using:
-
-```
-python eval_topic_metrics.py --log_file topic_preds.log --tw_dir topic_data/test_wordlists
-```
-
-You can also find our original generations and baselines in `topic_human_evals/`.
-
-### Training your own predictors
-
-Example command below.
-
-```
-python -u main.py --task topic --data_dir train_data/gpt2_generations --save_dir ckpt/topic/future_word_retrain_predictor --num_workers 20 --batch_size 128 --epoch_max_len 100000 --validation_freq 10  --lr 2e-4 --epochs 500 --glove_file train_data/glove.840B.300d.txt > future_word_retrain_predictor.log
-```
-
-The same evaluation commands as before will work; just modify the paths in the command to point to `model_best.pth.tar`, `dataset_info`, and `rhyme_info` from your newly trained ckpt folders. 
-
-## Machine Translation Formality
-
-### Evaluation
-
-To generate outputs, run:
-
-```
-python -u evaluate_formality.py --ckpt ckpt/formality/predictor_gyafc_entertainment_music/model.pth.tar --dataset_info ckpt/formality/predictor_gyafc_entertainment_music/dataset_info --in_file formality_data/fisher_test_oracle.es --model_path ckpt/formality/marian_finetune_fisher > formality_preds.log
-```
-
-The above command generates predictions using the Marian model finetuned on the Fisher dataset; remove the `--model_path` argument to get predictions with the un-finetuned Marian model from HuggingFace (referred to as 0-shot in the paper)
-
-Then evaluate metrics using:
-
-```
-python eval_formality_metrics.py --pred formality_preds.log --ref formality_data/test.noid.cleaned_0 formality_data/test.noid.cleaned_1 --ckpt ckpt/formality/test_evaluator_gyafc_family_relationships/model.pth.tar --dataset_info ckpt/formality/test_evaluator_gyafc_family_relationships/dataset_info
-```
-
-### Training your own predictors
-
-Example command below. (Reminder: you need to go get the GYAFC dataset following the instructions in https://github.com/raosudha89/GYAFC-corpus.)
-
-```
-python -u main.py --task formality --data_dir train_data/GYAFC_Corpus/Entertainment_Music --save_dir ckpt/formality/formality_retrain_predictor --num_workers 20 --batch_size 32 --epoch_max_len 1000000 --validation_freq 1 --lr 2e-5 --epochs 20 > formality_retrain_predictor.log
-```
-
-(The test-time formality evaluator is trained in the same way, just using the Family/Relationships half of the GYAFC dataset.)
-
-The same evaluation commands as before will work; just modify the paths in the command to point to `model_best.pth.tar`, `dataset_info`, and `rhyme_info` from your newly trained ckpt folders. 
-
-## Running FUDGE on your own data
-
-The code has been refactored so that the iambic (poetry), rhyme (poetry), newline (poetry), future word (topic), and formality (machine translation) are controlled by the `--task` flag to `main.py`. You should add your task as another option here, then modify the data processing in `data.py` and the model in `model.py` as needed for your task. (In `data.py` you probably won't need all the entries of the tuple that is expected of the loader; you can just put dummy entries in the ones you don't need.) You might also need to modify the loss computation in the `train` and `validate` functions in `main.py`. You'll probably want to write new evaluation scripts, though the existing poetry/topic/formality ones are hopefully helpful as references. 
-
-Alternatively, the general FUDGE framework is pretty simple, so you could always try reimplementing things yourself. A few additional details based on questions I've received: 
-
-(1) The formality task setup is likely closest to what you want if you're just trying to run the simplest form of FUDGE (take a language model, and use a classifier to optimize toward a single attribute) although you may need to swap out the Marian translation model/tokenizer we use. 
-
-(2) When you construct your training data, if you have an example in your data e.g. "This movie is great!" for positive sentiment, you want to learn on all the pairs (This, +), (This movie, +), (This movie is, +), etc., as that's one of the main points of our approach. 
-
-(3) For computational efficiency, we first filter the base model's next token probabilities down to the top 200 (Sec. 3.1 in the paper), before adding the classifier logits. This way you only need to evaluate your classifier on 200 continuations. Then afterward, you filter down again to whatever top-k/greedy/nucleus sampling you're using for evaluation (we use top-k with k=10 for poetry and topic, greedy for formality). 
-
-(4) You can use a pretrained LM backbone instead of a simple LSTM backbone for the predictor as well. This should work better when your dataset is smaller.