Update parquet files (step 100 of 249)

spaces/17TheWord/RealESRGAN/realesrgan/models/realesrgan_model.py

@@ -1,258 +0,0 @@
-import numpy as np
-import random
-import torch
-from basicsr.data.degradations import random_add_gaussian_noise_pt, random_add_poisson_noise_pt
-from basicsr.data.transforms import paired_random_crop
-from basicsr.models.srgan_model import SRGANModel
-from basicsr.utils import DiffJPEG, USMSharp
-from basicsr.utils.img_process_util import filter2D
-from basicsr.utils.registry import MODEL_REGISTRY
-from collections import OrderedDict
-from torch.nn import functional as F
-
-
-@MODEL_REGISTRY.register()
-class RealESRGANModel(SRGANModel):
-    """RealESRGAN Model for Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data.
-
-    It mainly performs:
-    1. randomly synthesize LQ images in GPU tensors
-    2. optimize the networks with GAN training.
-    """
-
-    def __init__(self, opt):
-        super(RealESRGANModel, self).__init__(opt)
-        self.jpeger = DiffJPEG(differentiable=False).cuda()  # simulate JPEG compression artifacts
-        self.usm_sharpener = USMSharp().cuda()  # do usm sharpening
-        self.queue_size = opt.get('queue_size', 180)
-
-    @torch.no_grad()
-    def _dequeue_and_enqueue(self):
-        """It is the training pair pool for increasing the diversity in a batch.
-
-        Batch processing limits the diversity of synthetic degradations in a batch. For example, samples in a
-        batch could not have different resize scaling factors. Therefore, we employ this training pair pool
-        to increase the degradation diversity in a batch.
-        """
-        # initialize
-        b, c, h, w = self.lq.size()
-        if not hasattr(self, 'queue_lr'):
-            assert self.queue_size % b == 0, f'queue size {self.queue_size} should be divisible by batch size {b}'
-            self.queue_lr = torch.zeros(self.queue_size, c, h, w).cuda()
-            _, c, h, w = self.gt.size()
-            self.queue_gt = torch.zeros(self.queue_size, c, h, w).cuda()
-            self.queue_ptr = 0
-        if self.queue_ptr == self.queue_size:  # the pool is full
-            # do dequeue and enqueue
-            # shuffle
-            idx = torch.randperm(self.queue_size)
-            self.queue_lr = self.queue_lr[idx]
-            self.queue_gt = self.queue_gt[idx]
-            # get first b samples
-            lq_dequeue = self.queue_lr[0:b, :, :, :].clone()
-            gt_dequeue = self.queue_gt[0:b, :, :, :].clone()
-            # update the queue
-            self.queue_lr[0:b, :, :, :] = self.lq.clone()
-            self.queue_gt[0:b, :, :, :] = self.gt.clone()
-
-            self.lq = lq_dequeue
-            self.gt = gt_dequeue
-        else:
-            # only do enqueue
-            self.queue_lr[self.queue_ptr:self.queue_ptr + b, :, :, :] = self.lq.clone()
-            self.queue_gt[self.queue_ptr:self.queue_ptr + b, :, :, :] = self.gt.clone()
-            self.queue_ptr = self.queue_ptr + b
-
-    @torch.no_grad()
-    def feed_data(self, data):
-        """Accept data from dataloader, and then add two-order degradations to obtain LQ images.
-        """
-        if self.is_train and self.opt.get('high_order_degradation', True):
-            # training data synthesis
-            self.gt = data['gt'].to(self.device)
-            self.gt_usm = self.usm_sharpener(self.gt)
-
-            self.kernel1 = data['kernel1'].to(self.device)
-            self.kernel2 = data['kernel2'].to(self.device)
-            self.sinc_kernel = data['sinc_kernel'].to(self.device)
-
-            ori_h, ori_w = self.gt.size()[2:4]
-
-            # ----------------------- The first degradation process ----------------------- #
-            # blur
-            out = filter2D(self.gt_usm, self.kernel1)
-            # random resize
-            updown_type = random.choices(['up', 'down', 'keep'], self.opt['resize_prob'])[0]
-            if updown_type == 'up':
-                scale = np.random.uniform(1, self.opt['resize_range'][1])
-            elif updown_type == 'down':
-                scale = np.random.uniform(self.opt['resize_range'][0], 1)
-            else:
-                scale = 1
-            mode = random.choice(['area', 'bilinear', 'bicubic'])
-            out = F.interpolate(out, scale_factor=scale, mode=mode)
-            # add noise
-            gray_noise_prob = self.opt['gray_noise_prob']
-            if np.random.uniform() < self.opt['gaussian_noise_prob']:
-                out = random_add_gaussian_noise_pt(
-                    out, sigma_range=self.opt['noise_range'], clip=True, rounds=False, gray_prob=gray_noise_prob)
-            else:
-                out = random_add_poisson_noise_pt(
-                    out,
-                    scale_range=self.opt['poisson_scale_range'],
-                    gray_prob=gray_noise_prob,
-                    clip=True,
-                    rounds=False)
-            # JPEG compression
-            jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range'])
-            out = torch.clamp(out, 0, 1)  # clamp to [0, 1], otherwise JPEGer will result in unpleasant artifacts
-            out = self.jpeger(out, quality=jpeg_p)
-
-            # ----------------------- The second degradation process ----------------------- #
-            # blur
-            if np.random.uniform() < self.opt['second_blur_prob']:
-                out = filter2D(out, self.kernel2)
-            # random resize
-            updown_type = random.choices(['up', 'down', 'keep'], self.opt['resize_prob2'])[0]
-            if updown_type == 'up':
-                scale = np.random.uniform(1, self.opt['resize_range2'][1])
-            elif updown_type == 'down':
-                scale = np.random.uniform(self.opt['resize_range2'][0], 1)
-            else:
-                scale = 1
-            mode = random.choice(['area', 'bilinear', 'bicubic'])
-            out = F.interpolate(
-                out, size=(int(ori_h / self.opt['scale'] * scale), int(ori_w / self.opt['scale'] * scale)), mode=mode)
-            # add noise
-            gray_noise_prob = self.opt['gray_noise_prob2']
-            if np.random.uniform() < self.opt['gaussian_noise_prob2']:
-                out = random_add_gaussian_noise_pt(
-                    out, sigma_range=self.opt['noise_range2'], clip=True, rounds=False, gray_prob=gray_noise_prob)
-            else:
-                out = random_add_poisson_noise_pt(
-                    out,
-                    scale_range=self.opt['poisson_scale_range2'],
-                    gray_prob=gray_noise_prob,
-                    clip=True,
-                    rounds=False)
-
-            # JPEG compression + the final sinc filter
-            # We also need to resize images to desired sizes. We group [resize back + sinc filter] together
-            # as one operation.
-            # We consider two orders:
-            #   1. [resize back + sinc filter] + JPEG compression
-            #   2. JPEG compression + [resize back + sinc filter]
-            # Empirically, we find other combinations (sinc + JPEG + Resize) will introduce twisted lines.
-            if np.random.uniform() < 0.5:
-                # resize back + the final sinc filter
-                mode = random.choice(['area', 'bilinear', 'bicubic'])
-                out = F.interpolate(out, size=(ori_h // self.opt['scale'], ori_w // self.opt['scale']), mode=mode)
-                out = filter2D(out, self.sinc_kernel)
-                # JPEG compression
-                jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range2'])
-                out = torch.clamp(out, 0, 1)
-                out = self.jpeger(out, quality=jpeg_p)
-            else:
-                # JPEG compression
-                jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range2'])
-                out = torch.clamp(out, 0, 1)
-                out = self.jpeger(out, quality=jpeg_p)
-                # resize back + the final sinc filter
-                mode = random.choice(['area', 'bilinear', 'bicubic'])
-                out = F.interpolate(out, size=(ori_h // self.opt['scale'], ori_w // self.opt['scale']), mode=mode)
-                out = filter2D(out, self.sinc_kernel)
-
-            # clamp and round
-            self.lq = torch.clamp((out * 255.0).round(), 0, 255) / 255.
-
-            # random crop
-            gt_size = self.opt['gt_size']
-            (self.gt, self.gt_usm), self.lq = paired_random_crop([self.gt, self.gt_usm], self.lq, gt_size,
-                                                                 self.opt['scale'])
-
-            # training pair pool
-            self._dequeue_and_enqueue()
-            # sharpen self.gt again, as we have changed the self.gt with self._dequeue_and_enqueue
-            self.gt_usm = self.usm_sharpener(self.gt)
-            self.lq = self.lq.contiguous()  # for the warning: grad and param do not obey the gradient layout contract
-        else:
-            # for paired training or validation
-            self.lq = data['lq'].to(self.device)
-            if 'gt' in data:
-                self.gt = data['gt'].to(self.device)
-                self.gt_usm = self.usm_sharpener(self.gt)
-
-    def nondist_validation(self, dataloader, current_iter, tb_logger, save_img):
-        # do not use the synthetic process during validation
-        self.is_train = False
-        super(RealESRGANModel, self).nondist_validation(dataloader, current_iter, tb_logger, save_img)
-        self.is_train = True
-
-    def optimize_parameters(self, current_iter):
-        # usm sharpening
-        l1_gt = self.gt_usm
-        percep_gt = self.gt_usm
-        gan_gt = self.gt_usm
-        if self.opt['l1_gt_usm'] is False:
-            l1_gt = self.gt
-        if self.opt['percep_gt_usm'] is False:
-            percep_gt = self.gt
-        if self.opt['gan_gt_usm'] is False:
-            gan_gt = self.gt
-
-        # optimize net_g
-        for p in self.net_d.parameters():
-            p.requires_grad = False
-
-        self.optimizer_g.zero_grad()
-        self.output = self.net_g(self.lq)
-
-        l_g_total = 0
-        loss_dict = OrderedDict()
-        if (current_iter % self.net_d_iters == 0 and current_iter > self.net_d_init_iters):
-            # pixel loss
-            if self.cri_pix:
-                l_g_pix = self.cri_pix(self.output, l1_gt)
-                l_g_total += l_g_pix
-                loss_dict['l_g_pix'] = l_g_pix
-            # perceptual loss
-            if self.cri_perceptual:
-                l_g_percep, l_g_style = self.cri_perceptual(self.output, percep_gt)
-                if l_g_percep is not None:
-                    l_g_total += l_g_percep
-                    loss_dict['l_g_percep'] = l_g_percep
-                if l_g_style is not None:
-                    l_g_total += l_g_style
-                    loss_dict['l_g_style'] = l_g_style
-            # gan loss
-            fake_g_pred = self.net_d(self.output)
-            l_g_gan = self.cri_gan(fake_g_pred, True, is_disc=False)
-            l_g_total += l_g_gan
-            loss_dict['l_g_gan'] = l_g_gan
-
-            l_g_total.backward()
-            self.optimizer_g.step()
-
-        # optimize net_d
-        for p in self.net_d.parameters():
-            p.requires_grad = True
-
-        self.optimizer_d.zero_grad()
-        # real
-        real_d_pred = self.net_d(gan_gt)
-        l_d_real = self.cri_gan(real_d_pred, True, is_disc=True)
-        loss_dict['l_d_real'] = l_d_real
-        loss_dict['out_d_real'] = torch.mean(real_d_pred.detach())
-        l_d_real.backward()
-        # fake
-        fake_d_pred = self.net_d(self.output.detach().clone())  # clone for pt1.9
-        l_d_fake = self.cri_gan(fake_d_pred, False, is_disc=True)
-        loss_dict['l_d_fake'] = l_d_fake
-        loss_dict['out_d_fake'] = torch.mean(fake_d_pred.detach())
-        l_d_fake.backward()
-        self.optimizer_d.step()
-
-        if self.ema_decay > 0:
-            self.model_ema(decay=self.ema_decay)
-
-        self.log_dict = self.reduce_loss_dict(loss_dict)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download LINK Free FieldIT (CRM) Current Version.md

@@ -1,26 +0,0 @@
-
-<h1>How to Download Free FieldIT (CRM) Current Version</h1>
-<p>FieldIT (CRM) is a customer relationship management software that helps you manage your contacts, tasks, appointments, documents, and more. It is designed for small and medium businesses that need a simple and affordable solution to organize their data and improve their productivity.</p>
-<p>If you want to download free FieldIT (CRM) current version, you can follow these steps:</p>
-<h2>Download free FieldIT (CRM) current version</h2><br /><p><b><b>Download Zip</b> &mdash; <a href="https://byltly.com/2uKz0T">https://byltly.com/2uKz0T</a></b></p><br /><br />
-<ol>
-<li>Go to <a href="https://download.cnet.com/FieldIT-CRM/3000-2652_4-75213029.html">this link</a> [^3^] and click on the green Download Now button.</li>
-<li>Save the file FieldITCRM.exe to your computer and run it.</li>
-<li>Follow the installation wizard to complete the setup.</li>
-<li>Launch FieldIT (CRM) and enter your name and email address to register for a free license.</li>
-<li>Enjoy using FieldIT (CRM) for your business needs.</li>
-</ol>
-<p>Note that the current version of FieldIT (CRM) is 3.8.20, which was released on December 28, 2012 [^3^]. It is compatible with Windows 2003, XP, Vista, 7, and 8 [^3^]. If you need more advanced features or support, you can upgrade to a paid version of FieldIT (CRM).</p>
-<p>If you are looking for other CRM software options, you can also check out Microsoft Dynamics 365 [^1^] or SAP CRM [^2^], which are more comprehensive and scalable solutions for larger enterprises. They offer various modules and enhancements for different business functions and industries. However, they also require more investment and technical expertise to implement and maintain.</p>
-<p>Whatever CRM software you choose, make sure it meets your business goals and requirements. A good CRM software can help you improve your customer satisfaction, loyalty, retention, and revenue.</p><p>Here are some additional tips on how to use CRM software effectively:</p>
-<ul>
-<li>Keep your data clean and updated. Make sure you enter accurate and complete information about your contacts, leads, opportunities, and activities. Avoid duplicate or outdated records that can cause confusion and errors.</li>
-<li>Segment your customers and prospects. Use criteria such as industry, location, size, revenue, needs, preferences, and behavior to group your customers and prospects into different categories. This can help you tailor your marketing campaigns, sales pitches, and service offerings to each segment.</li>
-<li>Automate your workflows and processes. Use the features and tools of your CRM software to automate repetitive and routine tasks such as sending emails, scheduling appointments, creating reports, and generating invoices. This can save you time and resources and reduce human errors.</li>
-<li>Analyze your data and performance. Use the dashboards, charts, graphs, and reports of your CRM software to monitor and measure your key performance indicators (KPIs) such as sales revenue, conversion rate, customer satisfaction, retention rate, and lifetime value. This can help you identify your strengths and weaknesses and make informed decisions.</li>
-<li>Integrate your CRM software with other systems and applications. Connect your CRM software with your email, calendar, social media, accounting, e-commerce, and other platforms that you use for your business. This can help you streamline your data flow and communication and enhance your productivity and efficiency.</li>
-</ul>
-<p>By following these tips, you can make the most out of your CRM software and boost your business growth.</p>
-<p></p> 7b8c122e87<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Excel 2016 Test Questions And Answers Pdf.md

@@ -1,16 +0,0 @@
-
-<h1>How to Prepare for Excel 2016 Test Questions and Answers PDF</h1>
-<p>If you are planning to take an Excel 2016 test, you might be looking for some resources to help you prepare. One of the best ways to study for an Excel 2016 test is to use a PDF file that contains questions and answers. A PDF file is a document that can be viewed on any device and printed easily. A PDF file that contains Excel 2016 test questions and answers can help you practice your skills, review your knowledge, and identify your strengths and weaknesses.</p>
-<p>However, not all PDF files that contain Excel 2016 test questions and answers are created equal. Some PDF files may have outdated, inaccurate, or irrelevant information. Some PDF files may have poor formatting, spelling, or grammar. Some PDF files may have too few or too many questions, or questions that are too easy or too hard. Therefore, you need to be careful when choosing a PDF file that contains Excel 2016 test questions and answers.</p>
-<h2>excel 2016 test questions and answers pdf</h2><br /><p><b><b>Download</b> &#10031; <a href="https://byltly.com/2uKA0w">https://byltly.com/2uKA0w</a></b></p><br /><br />
-<p>Here are some tips to help you find and use a good PDF file that contains Excel 2016 test questions and answers:</p>
-<ul>
-<li>Look for a reputable source. You should look for a PDF file that comes from a reliable source, such as a reputable website, a certified instructor, or a trusted publisher. You can check the source's credentials, reviews, ratings, or testimonials to verify its quality and credibility.</li>
-<li>Look for a recent version. You should look for a PDF file that is updated to reflect the latest changes and features of Excel 2016. You can check the date of publication, the edition number, or the version number to see if the PDF file is current and relevant.</li>
-<li>Look for a comprehensive coverage. You should look for a PDF file that covers all the topics and skills that are tested on the Excel 2016 exam. You can check the table of contents, the introduction, or the summary to see if the PDF file has a complete and balanced coverage of the exam content.</li>
-<li>Look for a clear format. You should look for a PDF file that has a clear and consistent format that makes it easy to read and understand. You can check the font size, the color scheme, the layout, the headings, the bullet points, the tables, the charts, or the images to see if the PDF file has a good visual presentation.</li>
-<li>Look for a correct answer key. You should look for a PDF file that has a correct and detailed answer key that explains how to solve each question. You can check the accuracy, the logic, the steps, the formulas, the functions, or the references to see if the PDF file has a good explanation of the answers.</li>
-</ul>
-<p>By following these tips, you can find and use a good PDF file that contains Excel 2016 test questions and answers. A good PDF file can help you prepare for your Excel 2016 test effectively and efficiently.</p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Addictive Drums Authorization Code 111 14.md

@@ -1,109 +0,0 @@
-
-<h1>Addictive Drums Authorization Code 111 14: How to Unlock the Full Potential of Your Drum Software</h1>
-
-<p>If you are a music producer, composer, or drummer, you probably know how amazing Addictive Drums 2 is. This software allows you to create realistic and expressive drum tracks with ease, using a variety of kits, presets, and effects. You can use it as a standalone application or as a plug-in in your favorite music production software.</p>
-
-<p>But what if you want to access more features and options in Addictive Drums 2? What if you want to customize your drum sounds, mix and match different kits, and tweak every parameter to your liking? Well, you need an authorization code to unlock the full potential of your drum software.</p>
-<h2>Addictive Drums Authorization Code 111 14</h2><br /><p><b><b>DOWNLOAD</b> &rarr; <a href="https://imgfil.com/2uxYJU">https://imgfil.com/2uxYJU</a></b></p><br /><br />
-
-<h2>What is Addictive Drums Authorization Code 111 14?</h2>
-
-<p>Addictive Drums Authorization Code 111 14 is a special code that you can use to activate Addictive Drums 2 on your computer. This code is provided by XLN Audio, the company that develops and distributes Addictive Drums 2. You can get this code by purchasing Addictive Drums 2 from their official website or from an authorized dealer.</p>
-
-<p>Once you have this code, you can enter it in the Addictive Drums 2 activation window and enjoy all the benefits of the full version of the software. You can use any kit, preset, or effect that you want, and you can also download and install additional content from the XLN Audio website. You can also use Addictive Drums 2 on up to three computers with the same code.</p>
-
-<h2>How to Activate Addictive Drums 2 with Authorization Code 111 14?</h2>
-
-<p>Activating Addictive Drums 2 with Authorization Code 111 14 is very easy and straightforward. Here are the steps you need to follow:</p>
-
-<ol>
-<li>Download and install Addictive Drums 2 from the XLN Audio website or from the installation disc that came with your purchase.</li>
-<li>Launch Addictive Drums 2 as a standalone application or as a plug-in in your music production software.</li>
-<li>Click on the "Activate Product" button in the lower right corner of the Addictive Drums 2 window.</li>
-<li>Enter your email address and password that you used to register your product on the XLN Audio website. If you don't have an account yet, you can create one for free.</li>
-<li>Enter your Addictive Drums Authorization Code 111 14 in the field provided and click on "Activate".</li>
-<li>Wait for the activation process to complete and restart Addictive Drums 2.</li>
-</ol>
-
-<p>Congratulations! You have successfully activated Addictive Drums 2 with Authorization Code 111 14. You can now enjoy all the features and options that this software has to offer.</p>
-
-<h2>Why Choose Addictive Drums Authorization Code 111 14?</h2>
-
-<p>Addictive Drums Authorization Code 111 14 is the best way to unlock the full potential of your drum software. Here are some of the reasons why you should choose this code:</p>
-
-<ul>
-<li>It is easy to use and activate. You don't need any complicated procedures or technical skills to activate Addictive Drums 2 with this code.</li>
-<li>It is secure and reliable. You don't have to worry about viruses, malware, or scams when you use this code. It is provided by XLN Audio, a reputable company that has been in the music industry for over a decade.</li>
-<li>It is affordable and worth it. You don't have to spend a fortune to get this code. It is reasonably priced and gives you access to a lot of value-added content and features that will enhance your drum production.</li>
-<li>It is compatible and flexible. You can use this code on any computer that meets the minimum system requirements for Addictive Drums 2. You can also use it on up to three computers with the same code.</li>
-</ul>
-
-<p>Addictive Drums Authorization Code 111 14 is the ultimate solution for anyone who wants to create professional and realistic drum tracks with ease. Don't miss this opportunity to get this code and experience the power of Addictive Drums 2.</p>
-<p></p>
-
-<h3>Get Your Addictive Drums Authorization Code 111 14 Today!</h3>
-
-<p>If you are ready to take your drum production to the next level, don't hesitate to get your Addictive Drums Authorization Code 111 14 today. You can get this code by visiting the XLN Audio website or by contacting an authorized dealer near you.</p>
-
-<p>Addictive Drums Authorization Code 111 14 is the key to unlocking the full potential of your drum software. Get it now and start creating amazing drum tracks with Addictive Drums 2!</p>
-<h4>What are the Benefits of Addictive Drums 2?</h4>
-
-<p>Addictive Drums 2 is not just another drum software. It is a complete drum production solution that offers many benefits for music producers, composers, and drummers. Here are some of the benefits of Addictive Drums 2:</p>
-
-<ul>
-<li>It is realistic and expressive. Addictive Drums 2 uses high-quality samples and advanced algorithms to create drum sounds that are realistic and dynamic. You can control the velocity, pitch, tone, and articulation of each drum hit with your keyboard, mouse, or MIDI controller. You can also use the built-in groove engine to create realistic drum patterns and variations.</li>
-<li>It is versatile and customizable. Addictive Drums 2 comes with a huge library of kits, presets, and effects that cover a wide range of genres and styles. You can mix and match different elements to create your own custom kits and sounds. You can also adjust the volume, pan, EQ, compression, reverb, and other parameters of each drum channel with the intuitive mixer.</li>
-<li>It is creative and inspiring. Addictive Drums 2 allows you to experiment and explore different possibilities with your drum tracks. You can use the beat transformer to change the feel and groove of your patterns. You can use the FX section to add distortion, modulation, delay, and other effects to your drums. You can also use the cloud sync feature to access new content and updates from XLN Audio.</li>
-</ul>
-
-<p>Addictive Drums 2 is a powerful and flexible drum software that will help you create professional and realistic drum tracks with ease.</p>
-
-<h4>How to Get the Best Out of Addictive Drums Authorization Code 111 14?</h4>
-
-<p>Addictive Drums Authorization Code 111 14 is a great way to activate Addictive Drums 2 on your computer. However, there are some tips and tricks that you can use to get the best out of this code and your drum software. Here are some of them:</p>
-
-<ul>
-<li>Make sure your computer meets the minimum system requirements for Addictive Drums 2. You need at least Windows 7 or Mac OS X 10.7, a dual-core CPU, 4 GB of RAM, and an internet connection.</li>
-<li>Register your product on the XLN Audio website to get access to additional content and updates. You can also join the XLN Audio community and get support and feedback from other users.</li>
-<li>Watch the tutorial videos and read the user manual to learn how to use Addictive Drums 2 effectively. You can also check out the FAQ section and the online help center for more information.</li>
-<li>Experiment with different kits, presets, and effects to find your own sound and style. You can also create your own custom kits and presets and save them for later use.</li>
-<li>Use MIDI loops or record your own patterns to create realistic and expressive drum tracks. You can also edit and quantize your MIDI data with the built-in editor.</li>
-</ul>
-
-<p>Addictive Drums Authorization Code 111 14 is a valuable tool that will help you unlock the full potential of your drum software. Use it wisely and enjoy creating amazing drum tracks with Addictive Drums 2!</p>
-<h4>Where to Buy Addictive Drums Authorization Code 111 14?</h4>
-
-<p>If you are interested in buying Addictive Drums Authorization Code 111 14, you have two options. You can either buy it directly from the XLN Audio website or from an authorized dealer near you.</p>
-
-<p>Buying from the XLN Audio website is the easiest and fastest way to get your code. You can choose from different payment methods and currencies, and you can also get instant access to your code and your product downloads. You can also benefit from the XLN Audio loyalty program and get discounts and rewards for your purchases.</p>
-
-<p>Buying from an authorized dealer is another option that you can consider. You can find a list of authorized dealers on the XLN Audio website or by contacting their customer support. Buying from an authorized dealer can give you some advantages, such as local support, warranty, and physical installation discs.</p>
-
-<p>Whichever option you choose, make sure you buy Addictive Drums Authorization Code 111 14 from a legitimate source. Avoid buying from unauthorized sellers or websites that offer suspiciously low prices or free codes. These codes may be fake, stolen, or expired, and they may not work or may cause problems with your software.</p>
-
-<h4>How to Troubleshoot Addictive Drums Authorization Code 111 14?</h4>
-
-<p>Addictive Drums Authorization Code 111 14 is a reliable and secure code that should work without any issues. However, if you encounter any problems with your code or your software activation, here are some tips and solutions that you can try:</p>
-
-<ul>
-<li>Make sure you enter your code correctly. Check for any typos, spaces, or extra characters in your code. You can also copy and paste your code from your email or your XLN Audio account to avoid errors.</li>
-<li>Make sure you have an internet connection. You need an internet connection to activate Addictive Drums 2 with your code. If your internet connection is slow or unstable, try using a different network or device.</li>
-<li>Make sure you have the latest version of Addictive Drums 2 installed. You can check for updates on the XLN Audio website or by using the XLN Online Installer application.</li>
-<li>Make sure you have enough disk space and memory on your computer. Addictive Drums 2 requires at least 4 GB of RAM and 15 GB of disk space to run smoothly.</li>
-<li>Contact XLN Audio customer support. If none of the above solutions work, you can contact XLN Audio customer support by email or phone. They will help you solve any issues with your code or your software activation.</li>
-</ul>
-
-<p>Addictive Drums Authorization Code 111 14 is a simple and effective way to activate Addictive Drums 2 on your computer. If you follow these tips and solutions, you should be able to enjoy your drum software without any problems.</p>
-<h4>Conclusion</h4>
-
-<p>Addictive Drums 2 is a powerful and versatile drum production software that can help you create realistic and expressive drum tracks with ease. Whether you use it as a standalone application or as a plug-in in your music production software, Addictive Drums 2 will give you access to a huge library of kits, presets, and effects that cover a wide range of genres and styles.</p>
-
-<p>To unlock the full potential of your drum software, you need Addictive Drums Authorization Code 111 14. This code will allow you to activate Addictive Drums 2 on your computer and enjoy all the features and options that this software has to offer. You can also use this code on up to three computers with the same code.</p>
-
-<p>Addictive Drums Authorization Code 111 14 is easy to use and activate. You can get this code by buying Addictive Drums 2 from the XLN Audio website or from an authorized dealer near you. You can also register your product on the XLN Audio website to get access to additional content and updates.</p>
-
-<p>If you have any problems with your code or your software activation, you can follow the tips and solutions that we have provided in this article. You can also contact XLN Audio customer support for more help and assistance.</p>
-
-<p>Addictive Drums Authorization Code 111 14 is the key to unlocking the full potential of your drum software. Get it now and start creating amazing drum tracks with Addictive Drums 2!</p> 3cee63e6c2<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/DFX Audio Enhancer 13.008 - Repack KpoJIuK .rar.md

@@ -1,6 +0,0 @@
-<h2>DFX Audio Enhancer 13.008 - Repack KpoJIuK .rar</h2><br /><p><b><b>Download Zip</b> --->>> <a href="https://imgfil.com/2uy1N6">https://imgfil.com/2uy1N6</a></b></p><br /><br />
-
-SCPH- .... PlayStation 2 SCPH 39001.rar 8.11 Mb . SCPH 30000-50000.pdf 2.17 Mb . 31584 . ... DFX Audio Enhancer 13.008 - Repack KpoJIuK .rar · Crack For ... 4d29de3e1b<br />
-<br />
-<br />
-<p></p>

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download Bullet Echo Mod Apk and Enjoy Free Shopping and Epic Battles.md

@@ -1,94 +0,0 @@
-<br />
-<h1>Free Download Bullet Echo Mod Apk: A Stealthy Battle Royale Game</h1>
-<p>If you are looking for a new and exciting action shooter game to play on your mobile device, you might want to check out Bullet Echo. This game is a PvP tactical team shooter that pits teams of players against each other in intense, competitive matches. You can choose from dozens of different heroes with unique play styles, guns, and abilities. You can also play in various game modes, such as Team vs Team, Solo, and Battle Royale.</p>
-<h2>free download bullet echo mod apk</h2><br /><p><b><b>Download Zip</b> > <a href="https://urlin.us/2uSTI0">https://urlin.us/2uSTI0</a></b></p><br /><br />
-<p>But what if you want to enjoy the game without spending any money or waiting for long hours to unlock new heroes and perks? Well, you can do that by downloading the Bullet Echo Mod Apk. This is a modified version of the original game that gives you unlimited money, free shopping, unlocked heroes, and more. In this article, we will tell you everything you need to know about Bullet Echo Mod Apk, including what it is, how to download and install it, and some tips and tricks to play it.</p>
-<h2>What is Bullet Echo?</h2>
-<p>Bullet Echo is a game developed by ZeptoLab, the creators of popular games like Cut the Rope, King of Thieves, and C.A.T.S. It is a top-down PvP tactical shooter that combines stealth, teamwork, and shooting skills. Here are some of the features of the game:</p>
-<h3>A top-down PvP tactical shooter</h3>
-<p>In Bullet Echo, you play as one of the heroes in a team of up to five players. Your goal is to eliminate the enemy team or be the last team standing when the battle ends. You can use your gun, your abilities, and your flashlight to fight your way through ever-changing environments. However, your vision is limited by the beam of your flashlight, so you have to rely on sound cues to locate your enemies and allies.</p>
-<h3>A game with multiple modes and heroes</h3>
-<p>Bullet Echo offers three main game modes that you can play solo or with friends online. These are:</p>
-<ul>
-<li>Team vs Team: This is a classic 5v5 team deathmatch mode where you have to kill more enemies than the other team.</li>
-<li>Solo: This is a free-for-all mode where 15 players compete against each other in a small map.</li>
-<li>Battle Royale: This is a mode where five teams of three players fight each other in a large map. The map shrinks over time and only one team or one player can survive.</li>
-</ul>
-<p>Besides these modes, you can also participate in championships, missions, and events to earn valuable resources and rewards.</p>
-<p>The game also features 21 heroes at launch and more heroes coming soon. Each hero has a unique set of abilities that can be used in combat. For example, some heroes can turn invisible, some can create electrical shields, some can heal themselves or their teammates, and some can launch rockets or grenades. You can unlock new heroes by playing online matches or by using resources that you earn or buy.</p>
-<p>How to get bullet echo mod apk for free<br />
-Bullet echo mod apk unlimited money and free shopping<br />
-Bullet echo mod apk latest version download<br />
-Bullet echo hack mod apk download for android<br />
-Bullet echo mod apk offline mode<br />
-Bullet echo mod apk with unlimited ammo and health<br />
-Bullet echo mod apk no root required<br />
-Bullet echo mod apk gameplay and features<br />
-Bullet echo mod apk download link and installation guide<br />
-Bullet echo mod apk review and rating<br />
-Bullet echo mod apk tips and tricks<br />
-Bullet echo mod apk best weapons and characters<br />
-Bullet echo mod apk cheats and codes<br />
-Bullet echo mod apk vs original game comparison<br />
-Bullet echo mod apk multiplayer mode and online battles<br />
-Bullet echo mod apk new update and patch notes<br />
-Bullet echo mod apk best settings and graphics<br />
-Bullet echo mod apk problems and solutions<br />
-Bullet echo mod apk support and feedback<br />
-Bullet echo mod apk alternatives and similar games<br />
-Download bullet echo mod apk from wonderapk.com[^1^]<br />
-Bullet echo mod apk free download without survey<br />
-Bullet echo mod apk file size and requirements<br />
-Bullet echo mod apk fun and addictive shooting game<br />
-Bullet echo mod apk missions and challenges<br />
-Bullet echo mod apk rewards and achievements<br />
-Bullet echo mod apk skins and customizations<br />
-Bullet echo mod apk maps and locations<br />
-Bullet echo mod apk enemies and bosses<br />
-Bullet echo mod apk sound and music</p>
-<h3>A game with stealth and sound mechanics</h3>
-<p>One of the most unique aspects of Bullet Echo is the stealth and sound mechanics. Unlike other shooter games, you cannot see the whole map or the enemies' positions. You can only see what your flashlight illuminates, which is a narrow cone of light in front of you. This means that you have to be careful about where you point your flashlight, as it can reveal your location to the enemies or blind your teammates. You also have to use sound cues to detect the enemies and allies. You can hear the footsteps, gunshots, and abilities of other players, as well as the ambient noises of the environment. You can use these sounds to locate and track your targets, or to avoid being detected by them. You can also use your abilities to create sound distractions or to silence your enemies. These mechanics make Bullet Echo a game that requires strategy, coordination, and stealth. You have to work with your team to plan your moves, communicate your positions, and execute your attacks. You also have to adapt to the changing situations and environments, as the maps are randomly generated and have different layouts, obstacles, and items.</p>
-<h2>What is Bullet Echo Mod Apk?</h2>
-<p>Bullet Echo Mod Apk is a modified version of the original game that gives you some advantages and features that are not available in the official version. These are:</p>
-<h3>A modified version of the original game</h3>
-<p>Bullet Echo Mod Apk is not an official app from ZeptoLab. It is a third-party app that has been modified by some developers or hackers to alter some aspects of the game. This means that it is not authorized by ZeptoLab and it may not be compatible with the latest updates or features of the game. It also means that it may contain some bugs, errors, or viruses that can harm your device or compromise your security.</p>
-<h3>A version with unlimited money and free shopping</h3>
-<p>One of the main benefits of Bullet Echo Mod Apk is that it gives you unlimited money and free shopping. This means that you can buy anything you want in the game without spending any real money or waiting for long hours. You can buy new heroes, perks, skins, weapons, and more with just a few clicks. You can also upgrade your heroes and perks to the maximum level without any restrictions.</p>
-<h3>A version with unlocked heroes and perks</h3>
-<p>Another benefit of Bullet Echo Mod Apk is that it gives you unlocked heroes and perks. This means that you can access all the heroes and perks in the game without having to unlock them by playing online matches or using resources. You can choose any hero you want from the start and use their abilities in combat. You can also use any perk you want to enhance your performance and customize your play style.</p>
-<h2>How to Download and Install Bullet Echo Mod Apk?</h2>
-<p>If you want to download and install Bullet Echo Mod Apk on your device, you have to follow these steps:</p>
-<h3>The download link and steps</h3>
-<ol>
-<li>Go to this link:  https://www.apkdone.com/bullet-echo/</li>
-<li>Click on the green button that says "Download APK (100 MB)"</li>
-<li>Wait for the download to finish and then open the file</li>
-<li>Click on "Install" and allow unknown sources if prompted</li>
-<li>Wait for the installation to finish and then open the app</li>
-</ol>
-<h3>The requirements and precautions</h3>
-<ul>
-<li>You need an Android device with Android 5.0 or higher to run Bullet Echo Mod Apk</li>
-<li>You need at least 100 MB of free storage space on your device to download and install Bullet Echo Mod Apk</li>
-<li>You need a stable internet connection to play online matches in Bullet Echo Mod Apk</li>
-<li>You should not use your real account or personal information when playing Bullet Echo Mod Apk, as it may get banned or hacked by ZeptoLab or other players</li>
-<li>You should not update Bullet Echo Mod Apk from Google Play Store or other sources, as it may overwrite the modded features or cause errors</li>
-<li>You should backup your data before installing Bullet Echo Mod Apk, as it may delete or corrupt your existing data</li>
-<li>You should uninstall Bullet Echo Mod Apk if you encounter any problems or if you want to switch back to the official version of the game</li>
-</ul>
-<h3>The benefits and drawbacks</h3>
-<table border="1">
-<tr><th>Benefits</th><th>Drawbacks</th></tr>
-<tr><td>You can enjoy unlimited money and free shopping in Bullet Echo Mod Apk</td><td>You may get banned or hacked by ZeptoLab or other players for using Bullet Echo Mod Apk</td></tr>
-<tr><td>You can access all the heroes and perks should use Bullet Echo Mod Apk at your own risk and discretion.</li>
-<li>Q: How can I update Bullet Echo Mod Apk?</li>
-<li>A: You should not update Bullet Echo Mod Apk from Google Play Store or other sources, as it may overwrite the modded features or cause errors. You should only update Bullet Echo Mod Apk from the same link that you downloaded it from, or from a trusted source that provides the latest version of the mod. You should also backup your data before updating Bullet Echo Mod Apk, as it may delete or corrupt your existing data.</li>
-<li>Q: How can I switch back to the official version of Bullet Echo?</li>
-<li>A: If you want to switch back to the official version of Bullet Echo, you have to uninstall Bullet Echo Mod Apk from your device. You can do this by going to your device settings, finding the app, and tapping on "Uninstall". You should also delete any residual files or folders that are related to Bullet Echo Mod Apk. Then, you can download and install the official version of Bullet Echo from Google Play Store or other sources.</li>
-<li>Q: Can I play Bullet Echo Mod Apk with other players who use the official version of the game?</li>
-<li>A: Yes, you can play Bullet Echo Mod Apk with other players who use the official version of the game. However, you may face unfair or unbalanced matches against them, as they may not have the same advantages and features that you have. You may also get reported or banned by them for using Bullet Echo Mod Apk, as it is considered cheating or hacking by ZeptoLab and other players.</li>
-<li>Q: Can I play Bullet Echo Mod Apk offline?</li>
-<li>A: No, you cannot play Bullet Echo Mod Apk offline. You need a stable internet connection to play online matches in Bullet Echo Mod Apk. You also need an internet connection to download and install Bullet Echo Mod Apk on your device.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Burger Please Mod Apk The Ultimate Fun Game with Unlimited Money.md

@@ -1,132 +0,0 @@
-
-<h1>Burger Please Mod APK Unlimited Money: How to Download and Play</h1>
-<p>Do you love burgers? Do you want to run your own burger shop? Do you want to have unlimited money, diamonds, coins, and cash in your game? If you answered yes to any of these questions, then you might be interested in <strong>Burger Please Mod APK Unlimited Money</strong>, a modified version of the popular casual game <strong>Burger Please</strong>. In this article, we will tell you everything you need to know about this mod, including what it is, how to download and install it, and how to play it. Let's get started!</p>
-<h2>burger please mod apk unlimited money</h2><br /><p><b><b>Download File</b> ->>->>->> <a href="https://jinyurl.com/2uNLp7">https://jinyurl.com/2uNLp7</a></b></p><br /><br />
- <h2>What is Burger Please?</h2>
-<p><strong>Burger Please</strong> is a casual game where you run your own burger shop and serve delicious burgers to your customers. You can customize your shop, upgrade your equipment, unlock new recipes, and create your own burger combinations. You can also compete with other players in the leaderboard, complete daily missions, and earn rewards.</p>
- <h3>A casual game where you run your own burger shop</h3>
-<p>The main mode of <strong>Burger Please</strong> is the <em>Career Mode</em>, where you start from a small burger stand and work your way up to a big burger empire. You will have to manage your time, resources, and customer satisfaction as you prepare and serve burgers according to their orders. You will also have to deal with different types of customers, such as kids, adults, celebrities, zombies, aliens, and more. Each customer has their own preferences, personality, and patience level, so you have to be careful not to make them angry or disappointed.</p>
- <h3>The features and gameplay of Burger Please</h3>
-<p><strong>Burger Please</strong> has many features and gameplay elements that make it fun and addictive. Some of them are:</p>
-<ul>
-<li><strong>Customization:</strong> You can customize your shop with different themes, decorations, furniture, and accessories. You can also customize your character with different outfits, hairstyles, accessories, and expressions.</li>
-<li><strong>Upgrades:</strong> You can upgrade your equipment, such as your grill, fryer, toaster, blender, etc., to make them faster, more efficient, and more durable. You can also upgrade your ingredients, such as your meat, cheese, lettuce, tomato, etc., to make them tastier, fresher, and more nutritious.</li>
-<li><strong>Recipes:</strong> You can unlock new recipes as you progress in the game. You can also create your own recipes by combining different ingredients. You can save your recipes in your cookbook and use them anytime.</li>
-<li><strong>Challenges:</strong> You can challenge yourself with different modes and levels in the game. You can play the <em>Time Attack Mode</em>, where you have to serve as many burgers as possible in a limited time. You can play the <em>Endless Mode</em>, where you have to serve burgers until you run out of ingredients or customers. You can also play the <em>Boss Mode</em>, where you have to face a special customer who will test your skills.</li>
-mod APK from a trusted and reliable source, such as a reputable website, forum, or blog.</li>
-    <li>You should always scan the mod APK with an antivirus or anti-malware program before installing it on your device.</li>
-    <li>You should always read the reviews and comments of other users who have used the mod APK before downloading and installing it.</li>
-    <li>You should always follow the instructions and requirements of the mod APK carefully and correctly.</li>
-  </ul>
-</li>
-</ul>
- <h2>How to Download and Install Burger Please Mod APK Unlimited Money?</h2>
-<p>If you have decided to use <strong>Burger Please Mod APK Unlimited Money</strong>, you will need to download and install it on your device. The process may vary depending on the type of device you have, but here are some general steps that you can follow:</p>
- <h3>The steps to download and install Burger Please Mod APK Unlimited Money on your Android device</h3>
-<ol>
-<li>Go to the link where you can download the mod APK file. You can search for it online or use the link provided by the source.</li>
-<li>Tap on the download button and wait for the file to be downloaded on your device.</li>
-<li>Once the file is downloaded, go to your device settings and enable the option to install apps from unknown sources. This will allow you to install the mod APK file.</li>
-<li>Locate the mod APK file in your device storage and tap on it to start the installation process.</li>
-<li>Follow the on-screen instructions and grant the necessary permissions to install the mod APK file.</li>
-<li>Wait for the installation to be completed and then launch the game from your app drawer or home screen.</li>
-<li>Enjoy playing <strong>Burger Please Mod APK Unlimited Money</strong> on your Android device.</li>
-</ol>
- <h3>The steps to download and install Burger Please Mod APK Unlimited Money on your PC using an emulator</h3>
-<ol>
-<li>Go to the link where you can download the mod APK file. You can search for it online or use the link provided by the source.</li>
-<li>Download and install an Android emulator on your PC. An emulator is a software that allows you to run Android apps on your PC. Some popular emulators are BlueStacks, NoxPlayer, LDPlayer, etc.</li>
-<li>Launch the emulator and sign in with your Google account. This will allow you to access the Google Play Store and other Google services on your PC.</li>
-<li>Drag and drop the mod APK file into the emulator or use the built-in browser to download it from the link.</li>
-<li>Install the mod APK file using the emulator's app installer or file manager.</li>
-<li>Launch the game from the emulator's app drawer or home screen.</li>
-<li>Enjoy playing <strong>Burger Please Mod APK Unlimited Money</strong> on your PC using an emulator.</li>
-</ol>
- <h3>The steps to download and install Burger Please Mod APK Unlimited Money on your iOS device using a third-party app store</h3>
-<ol>
-<li>Go to the link where you can download the mod IPA file. You can search for it online or use the link provided by the source. The mod IPA file is a modified version of the original game that works on iOS devices. The mod IPA file is not an official version of the game and it is not supported or endorsed by the original developers.</li>
-<li>Download and install a third-party app store on your iOS device. A third-party app store is an alternative to the Apple App Store that allows you to download and install apps that are not available or approved by Apple. Some popular third-party app stores are TutuApp, Panda Helper, AppValley, etc.</li>
-<li>Launch the third-party app store and search for <strong>Burger Please Mod IPA Unlimited Money</strong> or use the link provided by the source.</li>
-<li>Tap on the download button and wait for the file to be downloaded on your device.</li>
-<li>Once the file is downloaded, go to your device settings and trust the developer profile of the third-party app store. This will allow you to install the mod IPA file.</li>
-<li>Locate the mod IPA file in your device storage and tap on it to start the installation process.</li>
-<li>Follow the on-screen instructions and grant the necessary permissions to install the mod IPA file.</li>
-<li>Wait for the installation to be completed and then launch the game from your app drawer or home screen.</li>
-<li>Enjoy playing <strong>Burger Please Mod IPA Unlimited Money</strong> on your iOS device using a third-party app store.</li>
-</ol>
- <h2>How to Play Burger Please Mod APK Unlimited Money?</h2>
-<p>Now that you have downloaded and installed <strong>Burger Please Mod APK Unlimited Money</strong>, you might be wondering how to play it. Well, the gameplay is pretty much the same as the original game, except that you have unlimited resources and access to everything. However, if you want some tips and tricks to play it effectively and enjoyably, here are some suggestions:</p>
- <h3>The tips and tricks to play Burger Please Mod APK Unlimited Money effectively and enjoyably</h3>
-<ul>
-<li><strong>Experiment with different recipes:</strong> Since you have unlimited ingredients, you can try out different combinations and create your own recipes. You can also use the cookbook to save your recipes and use them anytime. You might discover some delicious and unique burgers that will impress your customers and yourself.</li>
-<li><strong>Upgrade your equipment and ingredients:</strong> Since you have unlimited money, diamonds, coins, and cash, you can upgrade your equipment and ingredients to the max level. This will make your burgers faster, better, and more profitable. You can also buy new equipment and ingredients that will enhance your gameplay and variety.</li>
-<li><strong>Customize your shop and character:</strong> Since you have unlimited money, diamonds, coins, and cash, you can customize your shop and character with any theme, decoration, furniture, accessory, outfit, hairstyle, etc. that you want. You can also change them anytime according to your mood or preference. You can make your shop and character look unique and attractive.</li>
-<li><strong>Compete with other players:</strong> Since you have unlimited money, diamonds, coins, and cash, you can compete with other players in the leaderboard without any fear or pressure. You can also challenge yourself with different modes and levels in the game. You can show off your skills and achievements to other players and prove that you are the best burger master.</li>
-<li><strong>Have fun:</strong> The most important tip is to have fun while playing <strong>Burger Please Mod APK Unlimited Money</strong>. Don't take it too seriously or get bored by having everything easy. Enjoy the game as a casual and relaxing activity that will make you happy and hungry.</li>
-</ul>
- <h3>The best strategies and techniques to play Burger Please Mod APK Unlimited Money successfully and competitively</h3>
-<ul>
-<li><strong>Plan ahead:</strong> Even though you have unlimited resources, you still need to plan ahead when preparing and serving burgers. You need to pay attention to the customer's order, the ingredient's availability, the equipment's condition, etc. You need to avoid wasting time or making mistakes that will affect your performance or customer satisfaction.</li>
-<li><strong>Prioritize your customers:</strong> Even though you have unlimited resources, you still need to prioritize your customers when serving burgers. You need to consider their preferences, personality, patience level, etc. You need to serve them quickly, accurately, politely, etc. You need to avoid making them angry or disappointed that will affect your reputation or income.</li>
-<li><strong>Balanc e your resources:</strong> Even though you have unlimited resources, you still need to balance your resources when buying and upgrading items. You need to consider the cost, benefit, quality, quantity, etc. of each item. You need to avoid overspending or underutilizing your resources that will affect your gameplay or variety.</li>
-<li><strong>Use your creativity:</strong> Even though you have unlimited resources, you still need to use your creativity when creating and customizing burgers. You need to experiment with different ingredients, recipes, combinations, etc. You need to make your burgers look appealing, delicious, and unique. You need to impress your customers and yourself with your creativity.</li>
-<li><strong>Have fun:</strong> The most important strategy is to have fun while playing <strong>Burger Please Mod APK Unlimited Money</strong>. Don't take it too seriously or get stressed by the competition or the challenge. Enjoy the game as a casual and relaxing activity that will make you happy and hungry.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>In conclusion, <strong>Burger Please Mod APK Unlimited Money</strong> is a modified version of the original game that gives you unlimited money, diamonds, coins, and cash in your game. It allows you to enjoy the game without any limitations or restrictions. However, it also has some benefits and drawbacks, risks and precautions, tips and tricks, and strategies and techniques that you should know before downloading and installing it. We hope that this article has helped you learn more about this mod and how to download and play it. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading and happy burger making!</p>
-<p>burger please mod apk latest version<br />
-burger please mod apk free download<br />
-burger please mod apk android 1<br />
-burger please mod apk unlimited coins<br />
-burger please mod apk hack<br />
-burger please mod apk offline<br />
-burger please mod apk no ads<br />
-burger please mod apk revdl<br />
-burger please mod apk rexdl<br />
-burger please mod apk happymod<br />
-burger please mod apk cheat<br />
-burger please mod apk 0.8.0<br />
-burger please mod apk terbaru<br />
-burger please mod apk premium<br />
-burger please mod apk pro<br />
-burger please mod apk vip<br />
-burger please mod apk unlocked<br />
-burger please mod apk full<br />
-burger please mod apk mega<br />
-burger please mod apk 2023<br />
-burger please hack apk download<br />
-burger please hack apk unlimited money<br />
-burger please cheat apk unlimited money<br />
-burger please cheat apk download<br />
-burger please cheat apk free<br />
-burger please unlimited money apk download<br />
-burger please unlimited money apk free<br />
-burger please unlimited money apk latest<br />
-burger please unlimited money apk offline<br />
-burger please unlimited money apk online<br />
-download game burger please mod apk<br />
-download game burger please mod apk unlimited money<br />
-download game burger please hack apk<br />
-download game burger please cheat apk<br />
-download game burger please unlimited money apk<br />
-game burger please mod apk free download<br />
-game burger please mod apk latest version<br />
-game burger please hack apk download<br />
-game burger please cheat apk download<br />
-game burger please unlimited money apk download</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about <strong>Burger Please Mod APK Unlimited Money</strong>:</p>
-<ol>
-<li><strong>Is Burger Please Mod APK Unlimited Money safe to use?</strong></li>
-<p>It depends on the source and the file that you download. Some mod APK files may be safe to use, while others may be fake or malicious. You should always download a mod APK file from a trusted and reliable source, such as a reputable website, forum, or blog. You should also scan the mod APK file with an antivirus or anti-malware program before installing it on your device.</p>
-<li><strong>Is Burger Please Mod APK Unlimited Money legal to use?</strong></li>
-<p>No, it is not legal to use <strong>Burger Please Mod APK Unlimited Money</strong>. It is a modified version of the original game that violates the terms and conditions of the game and the intellectual property rights of the original developers. Using a mod APK file may result in legal actions or penalties from the original developers or the authorities.</p>
-<li><strong>Can I play Burger Please Mod APK Unlimited Money online?</strong></li>
-<p>Yes, you can play <strong>Burger Please Mod APK Unlimited Money</strong> online with other players. However, you may face some issues or problems when playing online, such as lagging, crashing, banning, etc. You may also encounter some players who are using the same mod or other mods that may give them an unfair advantage or disadvantage.</p>
-<li><strong>Can I play Burger Please Mod APK Unlimited Money offline?</strong></li>
-<p>Yes, you can play <strong>Burger Please Mod APK Unlimited Money</strong> offline without an internet connection. However, you may not be able to access some features or functions of the game that require an internet connection, such as the leaderboard, the daily missions, the ads, etc.</p>
-<li><strong>Can I update Burger Please Mod APK Unlimited Money?</strong></li>
-<p>No, you cannot update <strong>Burger Please Mod APK Unlimited Money</strong>. Updating a mod APK file may cause some errors or issues in the game or remove the modifications. You may also lose your progress or account if you update a mod APK file. If you want to update the game, you will have to uninstall the mod APK file and install the original game from the Google Play Store or the Apple App Store.</p>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Ragnarok X APK - The 3D MMORPG Mobile Game that Brings Back the Classic Masterpiece.md

@@ -1,146 +0,0 @@
-<br />
-<h1>Download Ragnarok X APK: How to Play the Next Generation of the Classic MMORPG on Your Android Device</h1>
- <h2>Introduction</h2>
- <p>If you are a fan of the classic Ragnarok Online, you might be interested in trying out its latest mobile version, Ragnarok X: Next Generation. This game is an official remake of the original masterpiece, authorized by Gravity from South Korea. It features retro style, new classes, cross-server PvP, guild wars, pet taming, marriage system, and more. In this article, we will show you how to download Ragnarok X APK and play it on your Android device. We will also share some features, tips, and tricks for playing this game.</p>
- <h3>What is Ragnarok X: Next Generation?</h3>
- <p>Ragnarok X: Next Generation is a 3D MMORPG mobile game that is based on the classic Ragnarok Online. It is developed by Nuverse and published by Gravity in various regions. The game aims to recreate the original love and nostalgia of the classic game, while adding new elements and improvements. The game has been launched in Southeast Asia, Taiwan, Hong Kong, Macau, Japan, and Korea. It has received positive reviews from players and critics alike.</p>
-<h2>download ragnarok x apk</h2><br /><p><b><b>Download File</b> &#10001; &#10001; &#10001; <a href="https://jinyurl.com/2uNKI1">https://jinyurl.com/2uNKI1</a></b></p><br /><br />
- <h3>Why should you download Ragnarok X APK?</h3>
- <p>If you want to play Ragnarok X: Next Generation on your Android device, you might need to download its APK file. APK stands for Android Package Kit, which is a file format that contains all the necessary components for installing an app on an Android device. There are several reasons why you might want to download Ragnarok X APK:</p>
- <ul>
-<li>The game is not available in your region or country.</li>
-<li>The game is not compatible with your device or operating system.</li>
-<li>You want to access the latest version or features of the game before they are officially released.</li>
-<li>You want to avoid any potential errors or bugs that might occur during the installation process from the Google Play Store.</li>
-</ul>
- <h3>How to download Ragnarok X APK safely and easily?</h3>
- <p>Downloading Ragnarok X APK is not difficult, but you need to be careful about the source and the file. There are many websites that offer APK files for various apps and games, but not all of them are trustworthy or reliable. Some of them might contain malware, viruses, or other harmful content that could damage your device or compromise your privacy. Therefore, you need to follow these steps to download Ragnarok X APK safely and easily:</p>
- <ol>
-<li>Find a reputable website that offers Ragnarok X APK. You can use a search engine or a review site to find one. Some examples of trustworthy websites are , , and .</li>
-<li>Check the details and information about the APK file. Make sure it matches the version, size, developer, and description of the game. You can also read the comments and ratings from other users to see if they have any issues or complaints.</li>
-<li>Download the APK file to your device. You might need to enable the option to install apps from unknown sources in your device settings. This will allow you to install apps that are not from the Google Play Store.</li>
-<li>Install the APK file by tapping on it and following the instructions on the screen. You might need to grant some permissions to the app to run properly.</li>
-</ol>
- <p>Congratulations, you have successfully downloaded and installed Ragnarok X APK on your Android device. You can now launch the game and enjoy its features.</p>
- <h2>Features of Ragnarok X: Next Generation</h2>
- <p>Ragnarok X: Next Generation is not just a simple remake of the classic Ragnarok Online. It also offers many new and exciting features that will enhance your gaming experience. Here are some of the features that you can expect from this game:</p>
- <h3>Super Novice: The ultimate all-rounder class</h3>
- <p>One of the most unique features of Ragnarok X: Next Generation is the Super Novice class. This is a special class that can learn skills from all other classes, making it the most versatile and flexible class in the game. You can customize your Super Novice according to your preferences and play style. You can also equip any weapon or armor that you want, as long as you meet the requirements. However, the Super Novice also has some drawbacks, such as low HP and SP, and limited skill slots. Therefore, you need to be careful and strategic when playing as a Super Novice.</p>
- <h3>World of Champions: The cross-server PvP competition</h3>
- <p>If you are looking for some thrilling and competitive action, you should try out the World of Champions mode. This is a cross-server PvP mode that pits players from different servers against each other in a 5v5 battle. You can join this mode by registering in the World of Champions NPC in Prontera. You will be matched with other players based on your rank and level. The winning team will receive rewards such as honor points, zeny, and rare items. You can also use your honor points to exchange for exclusive costumes and accessories.</p>
- <h3>Guild vs Guild: The ultimate test of teamwork and strategy</h3>
- <p>Another feature that will test your skills and teamwork is the Guild vs Guild mode. This is a large-scale war mode that involves up to 50 guilds fighting for the control of castles. You can join this mode by being a member of a guild that has registered for the war. You will need to cooperate with your guildmates to attack or defend the castles, using various strategies and tactics. The guilds that successfully occupy the castles will receive rewards such as guild funds, zeny, and rare items. They will also have access to exclusive dungeons and quests.</p>
-<p>How to download ragnarok x apk on android<br />
-Ragnarok x apk latest version 2023<br />
-Ragnarok x next generation apk free download<br />
-Ragnarok x apk download for pc<br />
-Ragnarok x apk mod unlimited money<br />
-Download ragnarok x apk from google play<br />
-Ragnarok x apk offline installer<br />
-Ragnarok x apk size and requirements<br />
-Ragnarok x apk update and patch notes<br />
-Ragnarok x apk mirror and alternative links<br />
-Download ragnarok x apk english version<br />
-Ragnarok x apk obb data download<br />
-Ragnarok x apk hack and cheat tool<br />
-Download ragnarok x apk for ios<br />
-Ragnarok x apk gameplay and review<br />
-Ragnarok x apk error and fix guide<br />
-Download ragnarok x apk from official website<br />
-Ragnarok x apk features and benefits<br />
-Ragnarok x apk tips and tricks<br />
-Download ragnarok x apk for emulator<br />
-Ragnarok x apk best class and build<br />
-Ragnarok x apk redeem code and rewards<br />
-Download ragnarok x apk for tablet<br />
-Ragnarok x apk system compatibility test<br />
-Ragnarok x apk graphics and sound quality<br />
-Download ragnarok x apk old versions<br />
-Ragnarok x apk new events and promotions<br />
-Ragnarok x apk customer service and support<br />
-Download ragnarok x apk for mac<br />
-Ragnarok x apk ratings and reviews<br />
-Download ragnarok x apk from apkpure<br />
-Ragnarok x apk comparison with other games<br />
-Ragnarok x apk guide and walkthrough<br />
-Download ragnarok x apk from uptodown<br />
-Ragnarok x apk community and forum<br />
-Download ragnarok x apk from apkmirror<br />
-Ragnarok x apk collaboration with slime 2.0<br />
-Ragnarok x apk pet system and taming guide<br />
-Download ragnarok x apk from apkpure.com/ragnarox/com.play.rosea/download/apk(^3^)<br />
-Ragnarok x next generation 2nd anniversary celebration event(^2^)</p>
- <h3>Pet Taming: The adorable companions for your adventure</h3>
- <p>If you are looking for some cute and loyal companions for your adventure, you should try out the pet taming feature. This feature allows you to capture and tame various monsters in the game, such as Poring, Lunatic, Yoyo, Baphomet Jr., and more. You will need to use specific items to lure and tame them, such as apples, bananas, honey, etc. Once you have tamed them, they will follow you around and assist you in combat. They will also have their own skills and attributes that you can upgrade by feeding them and giving them affection.</p>
- <h3>Marriage System: The romantic journey with your loved one</h3>
- <p>If you are looking for some romance in your life, you should try out the marriage system feature. This feature allows you to propose to another player that you have a good relationship with, and get married in a beautiful ceremony. You will need to buy a ring, a wedding dress or suit, and a wedding invitation card to prepare for the wedding. You will also need to invite your friends and guildmates to witness your special day. Once you are married, you will receive benefits such as bonus stats, exclusive skills, and special quests.</p>
- <h2>Tips and Tricks for Playing Ragnarok X: Next Generation</h2>
- <p>Ragnarok X: Next Generation is a fun and immersive game that will keep you entertained for hours. However, it can also be challenging and complex at times, especially for beginners. Therefore, we have prepared some tips and tricks for playing this game that will help you improve your performance and enjoyment.</p>
- <h3>How to level up fast and efficiently?</h3>
- <p>One of the most important aspects of playing Ragnarok X: Next Generation is leveling up your character. Leveling up will increase your stats, unlock new skills, and allow you to access more content in the game. Here are some ways to level up fast and efficiently:</p>
- <ul>
-<li>Complete quests: Quests are one of the main sources of experience points in the game. You can find quests from NPCs in various towns and maps. Quests will also reward you with zeny, items, and other benefits.</li>
-<li>Join parties: Parties are groups of players that cooperate with each other in combat. Join ing parties will allow you to share experience points and loot with other players. You can also benefit from their skills and buffs. You can join parties by using the party finder feature or by inviting other players manually.</li>
-<li>Use items: Items are consumables that can boost your experience points gain and other aspects of your character. You can use items such as EXP potions, field manuals, battle manuals, etc. to increase your experience points gain. You can also use items such as food, scrolls, cards, etc. to enhance your stats and skills.</li>
-<li>Explore maps: Maps are the areas where you can find monsters, NPCs, quests, and other features in the game. Exploring maps will allow you to discover new places, encounter new monsters, and complete new quests. You can also gain experience points by killing monsters and collecting items.</li>
-</ul>
- <h3>How to earn zeny and upgrade your equipment?</h3>
- <p>Zeny is the main currency in Ragnarok X: Next Generation. You will need zeny to buy items, upgrade equipment, enhance skills, and perform other actions in the game. Equipment is the gear that you can equip on your character to improve your stats and abilities. Upgrading equipment will increase its quality and effectiveness. Here are some ways to earn zeny and upgrade your equipment:</p>
- <ul>
-<li>Sell items: Items are the things that you can collect, craft, or buy in the game. You can sell items that you don't need or want to other players or NPCs for zeny. You can use the auction house feature or the personal shop feature to sell items to other players. You can also use the NPC shops or the vending machine feature to sell items to NPCs.</li>
-<li>Craft items: Crafting is the process of creating new items from raw materials or existing items. You can craft items such as weapons, armor, accessories, potions, etc. by using the crafting feature or the blacksmith feature. You can use the crafted items for yourself or sell them for zeny.</li>
-<li>Upgrade items: Upgrading is the process of improving the quality and level of your equipment. You can upgrade your equipment by using the upgrade feature or the refine feature. You will need materials such as ores, crystals, eluniums, etc. to upgrade your equipment. Upgrading your equipment will increase its stats and effects.</li>
-<li>Enhance items: Enhancing is the process of adding extra effects or attributes to your equipment. You can enhance your equipment by using the enhance feature or the enchant feature. You will need materials such as cards, runes, gems, etc. to enhance your equipment. Enhancing your equipment will add special bonuses and abilities to it.</li>
-</ul>
- <h3>How to join a guild and participate in guild activities?</h3>
- <p>A guild is a group of players that share a common goal and interest in the game. Joining a guild will allow you to interact with other players, cooperate with them in combat, and enjoy various benefits and features in the game. Guild activities are events or modes that are exclusive for guild members. Participating in guild activities will allow you to earn rewards, improve your reputation, and have fun with your guildmates. Here are some ways to join a guild and participate in guild activities:</p>
- <ul>
-<li>Find a guild: Finding a guild is the first step to joining a guild. You can find a guild by using the guild finder feature or by browsing the guild list feature. You can also find a guild by asking other players or by checking online forums or communities.</li>
-<li>Apply for a guild: Applying for a guild is the second step to joining a guild. You can apply for a guild by sending a request to the guild leader or by accepting an invitation from a guild member. You will need to wait for the approval of the guild leader or the guild officer before you can join the guild.</li>
-<li>Contribute to a guild: Contributing to a guild is the third step to joining a guild. You can contribute to a guild by donating zeny, materials, or items to the guild fund or by completing guild quests or missions. Contributing to a guild will increase your contribution points and your reputation within the guild.</li>
-<li>Participate in guild activities: Participating in guild activities is the fourth step to joining a guild. You can participate in guild activities by joining the guild war, the guild dungeon, the guild raid, or the guild party. Participating in guild activities will earn you rewards such as zeny, items, honor points, or rare items. You will also have fun and bond with your guildmates.</li>
-</ul>
- <h3>How to customize your character and skills?</h3>
- <p>Customizing your character and skills is one of the most enjoyable aspects of playing Ragnarok X: Next Generation. Customizing your character and skills will allow you to express your personality, style, and preferences in the game. You can also optimize your performance and effectiveness in combat by choosing the best combination of skills and equipment for your character. Here are some ways to customize your character and skills:</p>
- <ul>
-<li>Choose a class: Choosing a class is the first step to customizing your character and skills. You can choose from six classes in the game: Swordsman, Thief, Archer, Mage, Acolyte, and Merchant. Each class has its own strengths, weaknesses, and roles in the game. You can also change your class later in the game by using the job change feature.</li>
-<li>Choose a hairstyle: Choosing a hairstyle is the second step to customizing your character and skills. You can choose from various hairstyles in the game, ranging from cute to cool to elegant. You can also change your hairstyle later in the game by using the barber shop feature or by buying hair coupons.</li>
-<li>Choose a costume: Choosing a costume is the third step to customizing your character and skills. You can choose from various costumes in the game, such as uniforms, suits, dresses, casual wear, etc. You can also change your costume later in the game by using the wardrobe feature or by buying costume coupons.</li>
-<li>Choose a skill build: Choosing a skill build is the fourth step to customizing your character and skills. You can choose from various skills in the game, depending on your class and level. You can also change your skill build later in the game by using the skill reset feature or by buying skill reset coupons.</li>
-</ul>
- <h3>How to enjoy the social aspects of the game?</h3>
- <p>Ragnarok X: Next Generation is not only a game, but also a social platform. You can interact with other players, make friends, chat, trade, and have fun with them in the game. You can also join various events and activities that are designed to enhance your social experience in the game. Here are some ways to enjoy the social aspects of the game:</p>
- <ul>
-<li>Use chat: Chat is one of the main ways to communicate with other players in the game. You can use chat to send messages, emojis, stickers, or voice messages to other players. You can also use chat to join different channels, such as world chat, guild chat, party chat, etc.</li>
-<li>Use friend: Friend is one of the main ways to connect with other players in the game. You can use friend to add other players as your friends, send them gifts, invite them to parties or guilds, or view their profiles.</li>
-<li>Use emoticon: Emoticon is one of the main ways to express yourself in the game. You can use emoticon to perform various actions or gestures with your character, such as waving, laughing, crying, dancing, etc. You can also use emoticon to interact with other players or NPCs.</li>
-<li>Use event: Event is one of the main ways to participate in various activities in the game. You can use event to join different events that are held regularly or occasionally in the game, such as festivals, concerts, quizzes, etc. You can also use event to earn rewards such as zeny, items, costumes, etc.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>Ragnarok X: Next Generation is a great game for fans of Ragnarok Online and MMORPGs in general. It offers a nostalgic and immersive experience that will keep you hooked for hours. It also offers many new and exciting features that will enhance your gaming experience. If you want to play this game on your Android device, you should download Ragnarok X APK from a reputable website and install it on your device. You should also follow our tips and tricks for playing this game that will help you improve your performance and enjoyment.</p>
- <h2>FAQs</h2>
- <p>Here are some frequently asked questions about Ragnarok X: Next Generation:</p>
- <ol>
-<li><b>Is Ragnarok X: Next Generation free to play?</b><br>
-Yes, Ragnarok X: Next Generation is free to play. However, it also has some optional in-app purchases that can enhance your gameplay or appearance. You can buy items such as zeny, diamonds, costumes, etc. with real money. However, these purchases are not necessary to enjoy the game.</li>
-<li><b>Is Ragnarok X: Next Generation compatible with my device?</b><br>
-Ragnarok X: Next Generation is compatible with most Android devices that have at least 2 GB of RAM and Android 5.0 or higher. However, some devices might have issues with the game due to various factors such as hardware, software, or network. If you encounter any problems with the game, you can contact the customer service or check the official website for solutions.</li>
-<li><b>Is Ragnarok X: Next Generation safe to download and play?</b><br>
-Yes, Ragnarok X: Next Generation is safe to download and play. The game is authorized by Gravity from South Korea and developed by Nuverse, a reputable game company. The game also has various security measures and policies to protect your privacy and data. However, you should be careful about the source and the file of the APK that you download, as some websites might offer fake or harmful APK files. You should also avoid using any third-party tools or hacks that might compromise your account or device.</li>
-<li><b>How can I contact the customer service or the community of Ragnarok X: Next Generation?</b><br>
-You can contact the customer service or the community of Ragnarok X: Next Generation by using the following methods:</p>
- <ul>
-<li>Customer service: You can use the customer service feature in the game to submit a ticket or chat with an agent. You can also email them at [email protected].</li>
-<li>Community: You can use the community feature in the game to join various groups or forums. You can also follow their official social media accounts such as Facebook, Instagram, Twitter, YouTube, etc.</li>
-</ul></li>
-<li><b>How can I support Ragnarok X: Next Generation?</b><br>
-You can support Ragnarok X: Next Generation by doing the following things:</p>
- <ul>
-<li>Play the game regularly and invite your friends to join you.</li>
-<li>Rate and review the game on the Google Play Store or other platforms.</li>
-<li>Share your feedback and suggestions with the developers and the customer service.</li>
-<li>Purchase items or services in the game to support its development and maintenance.</li>
-</ul></li>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/FM WhatsApp APK Download for Android - Latest Version 2023 with New Features.md

@@ -1,95 +0,0 @@
-
-<h1>FM WhatsApp 2023 APK Download: Everything You Need to Know</h1>
-<p>Are you looking for a way to enhance your WhatsApp experience with more features and customization options? If yes, then you might want to try FM WhatsApp, one of the most popular and advanced WhatsApp mods available. In this article, we will tell you everything you need to know about FM WhatsApp 2023 APK download, including what it is, what it offers, how to download and install it, how to update it, and some frequently asked questions. Let's get started!</p>
- <h2>What is FM WhatsApp?</h2>
-<p>FM WhatsApp is a modified version of the official WhatsApp app that adds more functionality and personalization to the original app. It is developed by Fouad Mokdad, a well-known modder who also created other popular WhatsApp mods like Fouad WhatsApp and YoWhatsApp. FM WhatsApp allows you to enjoy features that are not available in the official app, such as themes, fonts, emojis, privacy settings, anti-delete messages, status downloader, and much more.</p>
-<h2>fm whatsapp 2023 apk download</h2><br /><p><b><b>Download Zip</b> &ndash;&ndash;&ndash; <a href="https://jinyurl.com/2uNKsH">https://jinyurl.com/2uNKsH</a></b></p><br /><br />
- <h3>Features of FM WhatsApp</h3>
-<p>Here are some of the main features that you can get with FM WhatsApp:</p>
-<ul>
-<li>Anti-ban: You can use FM WhatsApp without worrying about getting banned by the official app.</li>
-<li>Customization: You can change the look and feel of your WhatsApp app with hundreds of themes, fonts, and emojis.</li>
-<li>Privacy: You can hide your online status, last seen, blue ticks, typing status, and more.</li>
-<li>Anti-delete messages: You can view messages and status updates that have been deleted by the sender.</li>
-<li>Media sharing: You can send up to 90 images at once and video files up to 700 MB.</li>
-<li>Image quality: You can increase the quality of images that you send or receive.</li>
-<li>And many more.</li>
-</ul>
- <h3>Benefits of FM WhatsApp</h3>
-<p>Here are some of the benefits that you can enjoy with FM WhatsApp:</p>
-<ul>
-<li>You can have more control over your WhatsApp app and customize it according to your preferences.</li>
-<li>You can access features that are not available in the official app and enhance your user experience.</li>
-<li>You can protect your privacy and security with more options and settings.</li>
-<li>You can communicate with your contacts more easily and conveniently with more media sharing options.</li>
-</ul>
- <h2>How to Download and Install FM WhatsApp 2023 APK on Android?</h2>
-<p>If you want to download and install FM WhatsApp 2023 APK on your Android device, you need to follow these steps:</p>
- <h3>Download FM WhatsApp APK File</h3>
-<p>First, you need to download the latest version of FM WhatsApp APK file from a reliable source. You can use this link to download the file. The file name is <code>FMWA9.25_By_FouadMODS.apk</code>, the file size is 50.2 MB, and the latest update is March 2022. Make sure that your device has enough storage space and a stable internet connection before downloading the file.</p>
- <h3>Enable Unknown Sources</h3>
-<p>Next, you need to enable unknown sources on your device to allow the installation of apps from sources other than the Google Play Store. To do this, go to <code>Settings > Security > Unknown Sources</code> and toggle it on. You may see a warning message, but you can ignore it and proceed.</p>
- <h3>Install FM WhatsApp APK File</h3>
-<p>Then, you need to locate the downloaded APK file on your device and tap on it to start the installation process. You may see a pop-up asking for permissions, but you can grant them and follow the instructions on the screen. The installation may take a few minutes, so please be patient.</p>
- <h3>Verify Your Phone Number</h3>
-<p>Finally, you need to verify your phone number to activate FM WhatsApp on your device. To do this, open the app and enter your phone number. You will receive a verification code via SMS or a phone call. Enter the code and confirm your account. You can also restore your chat backup from the official app if you have one. That's it! You have successfully installed FM WhatsApp 2023 APK on your Android device.</p>
- <h2>How to Update FM WhatsApp to the Latest Version?</h2>
-<p>If you want to update FM WhatsApp to the latest version, you need to follow these steps:</p>
-<p>fm whatsapp 2023 apk download latest version<br />
-fm whatsapp 2023 apk download for android<br />
-fm whatsapp 2023 apk download by fouad mods<br />
-fm whatsapp 2023 apk download free<br />
-fm whatsapp 2023 apk download update<br />
-fm whatsapp 2023 apk download new features<br />
-fm whatsapp 2023 apk download anti ban<br />
-fm whatsapp 2023 apk download link<br />
-fm whatsapp 2023 apk download official website<br />
-fm whatsapp 2023 apk download install<br />
-fm whatsapp 2023 apk download how to use<br />
-fm whatsapp 2023 apk download benefits<br />
-fm whatsapp 2023 apk download review<br />
-fm whatsapp 2023 apk download comparison<br />
-fm whatsapp 2023 apk download alternatives<br />
-fm whatsapp 2023 apk download tips and tricks<br />
-fm whatsapp 2023 apk download guide<br />
-fm whatsapp 2023 apk download tutorial<br />
-fm whatsapp 2023 apk download faq<br />
-fm whatsapp 2023 apk download support<br />
-fm whatsapp 2023 apk download problems and solutions<br />
-fm whatsapp 2023 apk download modded version<br />
-fm whatsapp 2023 apk download customization options<br />
-fm whatsapp 2023 apk download themes and fonts<br />
-fm whatsapp 2023 apk download emoji and stickers<br />
-fm whatsapp 2023 apk download privacy and security settings<br />
-fm whatsapp 2023 apk download hide online status and last seen<br />
-fm whatsapp 2023 apk download view deleted messages and statuses<br />
-fm whatsapp 2023 apk download send large files and images<br />
-fm whatsapp 2023 apk download increase quality of media sharing<br />
-fm whatsapp 2023 apk download backup and restore chats<br />
-fm whatsapp 2023 apk download transfer data to new phone<br />
-fm whatsapp 2023 apk download sync with other devices<br />
-fm whatsapp 2023 apk download group chat and video call features<br />
-fm whatsapp 2023 apk download broadcast messages and status updates<br />
-fm whatsapp 2023 apk download pin chats and mark as unread<br />
-fm whatsapp 2023 apk download mute notifications and block contacts<br />
-fm whatsapp 2023 apk download dark mode and night mode options<br />
-fm whatsapp 2023 apk download auto reply and schedule messages features<br />
-fm whatsapp 2023 apk download lock app and chats with password or fingerprint</p>
- <h3>Check for Updates</h3>
-<p>First, you need to check if there is a new version of FM WhatsApp available. To do this, open the app and go to <code>Menu > Fouad Mods > Updates</code>. You will see a message telling you if there is an update or not. If there is an update, you can tap on <code>Download</code> to get the latest APK file.</p>
- <h3>Download and Install the Latest Version</h3>
-<p>Next, you need to download and install the latest version of FM WhatsApp APK file on your device. To do this, follow the same steps as above for downloading and installing FM WhatsApp 2023 APK. You don't need to uninstall the previous version or enable unknown sources again. Just overwrite the existing app with the new one and verify your phone number again. You have successfully updated FM WhatsApp to the latest version.</p>
- <h2>FAQs about FM WhatsApp</h2>
-<p>Here are some of the frequently asked questions about FM WhatsApp:</p>
-<table>
-<tr><th>Question</th><th>Answer</th></tr>
-<tr><td>Is FM WhatsApp safe to use?</td><td>FM WhatsApp is safe to use as long as you download it from a trusted source and scan it for viruses before installing it. However, it is not an official app and it may violate some of the terms and conditions of WhatsApp. Therefore, use it at your own risk and discretion.</td></tr>
-<tr><td>Can I use FM WhatsApp with the official app?</td><td>Yes, you can use FM WhatsApp with the official app if you want to have two WhatsApp accounts on the same device. However, you need to use different phone numbers for each account and install them in separate folders.</td></tr>
-<tr><td>How can I backup my chats on FM WhatsApp?</td><td>You can backup your chats on FM WhatsApp by going to <code>Menu > Settings > Chats > Chat Backup</code>. You can choose to backup your chats locally or on Google Drive. You can also restore your chats from the backup when you reinstall or update FM WhatsApp.</td></tr>
-<tr><td>How can I change themes on FM WhatsApp?</td><td>You can change themes on FM WhatsApp by going to <code>Menu > Fouad Mods > Universal > Themes</code>. You can choose from hundreds of themes available or download more from the internet. You can also create your own theme by customizing various elements of the app.</td></tr>
-<tr><td>How can I contact the developer of FM WhatsApp?</td><td>You can contact the developer of FM WhatsApp by going to <code>Menu > Fouad Mods > About > Contact Me</code>. You can send him an email or follow him on social media platforms like Twitter, Instagram, and Telegram.</td></tr>
-</table>
- <h2>Conclusion</h2>
-<p>In conclusion, FM WhatsApp is a great alternative to the official WhatsApp app that offers more features and customization options. You can download and install FM WhatsApp 2023 APK on your Android device by following the steps mentioned in this article. You can also update it to the latest version whenever there is one available. However, you should be aware of the risks involved in using a modded app and use it responsibly. We hope that this article has helped you learn more about FM WhatsApp 2023 APK download and answered some of your questions.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Free 3D Models of Orange Trees - Easy to Customize and Render.md

@@ -1,136 +0,0 @@
-
-<h1>How to Find and Download Free Orange Tree 3D Models</h1>
- <p>If you are looking for realistic and high-quality orange tree 3D models for your project, you might be wondering where to find them online. Whether you need them for animation, rendering, game development, or any other purpose, you can save time and money by downloading free 3D models from various websites. In this article, we will show you how to find and download free orange tree 3D models from some of the most popular sources on the web.</p>
- <h2>Introduction</h2>
- <h3>What are orange tree 3D models and why are they useful?</h3>
- <p>An orange tree 3D model is a digital representation of an orange tree that can be used in various applications that require 3D graphics. A 3D model consists of vertices, edges, faces, and textures that define the shape, color, and appearance of the object. A 3D model can also have animations, rigging, lighting, and other features that make it more realistic and interactive.</p>
-<h2>orange tree 3d model free download</h2><br /><p><b><b>Download File</b> &#10084; <a href="https://jinyurl.com/2uNMqi">https://jinyurl.com/2uNMqi</a></b></p><br /><br />
- <p>Orange tree 3D models are useful for many reasons. For example, they can help you create stunning scenes and environments for your animations or games. They can also help you visualize and design your own garden or landscape. They can even be used for educational purposes, such as teaching students about botany or ecology.</p>
- <h3>Where can you find free orange tree 3D models online?</h3>
- <p>There are many websites that offer free 3D models of various objects, including orange trees. However, not all of them are reliable or easy to use. Some of them may have low-quality models, limited formats, or unclear licenses. Therefore, you need to be careful and selective when choosing a website to download free 3D models from.</p>
- <p>In this article, we will focus on three websites that are well-known and trusted by many 3D artists and enthusiasts. They are TurboSquid, Sketchfab, and CGTrader. These websites have a large collection of free orange tree 3D models that you can browse, download, and use in your projects. We will explain how to use each website and what to look for when downloading a model.</p>
- <h2>TurboSquid: A Popular Source of Free 3D Models</h2>
- <h3>What is TurboSquid and how does it work?</h3>
- <p>TurboSquid is one of the largest and oldest online marketplaces for 3D models. It was founded in 2000 and has over one million models in its catalog. TurboSquid allows anyone to buy or sell 3D models for various purposes. It also has a section dedicated to free 3D models that anyone can download and use without paying anything.</p>
- <p>TurboSquid works by connecting buyers and sellers of 3D models. Buyers can search for the models they need by using keywords, filters, categories, or collections. They can also preview the models in different views, check the details and ratings, and download them in various formats. Sellers can upload their models to TurboSquid and set their own prices or offer them for free. TurboSquid also has a quality assurance program called CheckMate that certifies the models that meet certain standards of quality and compatibility.</p>
- <h3>How to search for free orange tree 3D models on TurboSquid?</h3>
- <p>Searching for free orange tree 3D models on TurboSquid is easy and fast. Here are the steps you need to follow:</p>
- <h4>Filter by free, orange, and tree keywords</h4>
- <p>The first step is to go to the <a href="">free 3D models section</a> of TurboSquid. You will see a search bar where you can enter the keywords that describe the model you are looking for. In this case, you can type "free orange tree" and hit enter. You will see a list of results that match your query.</p>
-<p>orange tree 3d model free download<br />
-free 3d orange tree models turbosquid<br />
-free nature orange-tree 3d models for download<br />
-free 3d orange models turbosquid<br />
-orange tree 3d model free obj<br />
-free low poly orange tree 3d model<br />
-free 3d model of orange tree with fruits<br />
-free realistic orange tree 3d model<br />
-free 3d model of orange tree in pot<br />
-free animated orange tree 3d model<br />
-free game ready orange tree 3d model<br />
-free vr ready orange tree 3d model<br />
-free 3d model of orange tree branch<br />
-free 3d model of orange tree leaf<br />
-free 3d model of orange tree flower<br />
-free 3d model of orange fruit<br />
-free 3d model of sliced orange<br />
-free 3d model of peeled orange<br />
-free 3d model of orange juice<br />
-free 3d model of orange peel<br />
-free blender orange tree 3d model<br />
-free maya orange tree 3d model<br />
-free c4d orange tree 3d model<br />
-free max orange tree 3d model<br />
-free fbx orange tree 3d model<br />
-free stl orange tree 3d model<br />
-free gltf orange tree 3d model<br />
-free usdz orange tree 3d model<br />
-free dae orange tree 3d model<br />
-free ztl orange tree 3d model<br />
-how to make a free orange tree 3d model<br />
-where to find a free orange tree 3d model<br />
-best sites for free orange tree 3d models<br />
-top rated free orange tree 3d models<br />
-most downloaded free orange tree 3d models<br />
-most realistic free orange tree 3d models<br />
-most detailed free orange tree 3d models<br />
-most optimized free orange tree 3d models<br />
-most compatible free orange tree 3d models<br />
-most versatile free orange tree 3d models<br />
-high quality free orange tree 3d models<br />
-high resolution free orange tree 3d models<br />
-high poly free orange tree 3d models<br />
-low poly cartoon style free orange tree 3d models <br />
-low poly stylized free orange tree 3d models <br />
-low poly pixel art style free orange tree 3d models <br />
-low poly voxel style free orange tree 3d models <br />
-low poly flat style free orange tree 3d models <br />
-low poly minimalist style free orange tree 3d models</p>
- <h4>Sort by best match, quality, or poly count</h4>
- <p>The next step is to sort the results by the criteria that matter to you. You can use the drop-down menu on the top right corner of the page to choose how to sort the results. You can sort them by best match, quality, or poly count. Best match will show you the models that are most relevant to your query. Quality will show you the models that have the highest ratings or CheckMate certification. Poly count will show you the models that have the lowest or highest number of polygons.</p>
- <h4>Check the license, format, and details of each model</h4>
- <p>The final step is to check the license, format, and details of each model before downloading it. You can click on the thumbnail of each model to see more information about it. You will see a page that shows you the preview images, description, specifications, reviews, and related models of the model. You will also see a section that shows you the license, format, and download options of the model.</p>
- <p>The license tells you how you can use the model in your project. Some models are royalty-free, which means you can use them for any purpose without paying anything. Some models are editorial-only, which means you can only use them for non-commercial purposes such as news or education. Some models have custom licenses, which means you have to read and follow the terms and conditions of the seller.</p>
- <p>The format tells you what file types are available for the model. Some models have multiple formats, such as OBJ, FBX, 3DS, or STL. Some models have only one format, such as MAX or BLEND. You should choose the format that is compatible with your software or application.</p>
- <p>The download options tell you how you can get the model on your device. Some models have direct download links, which means you can download them instantly by clicking on them. Some models have email delivery links, which means you have to enter your email address and wait for the link to be sent to you.</p>
- <h4>Download the model and use it in your project</h4>
- <p>Once you have checked everything and found the model that suits your needs, you can download it and use it in your project. You should always respect the license and credit the seller if required. You should also check the quality and compatibility of the model before using it in your project. You may need to adjust some settings or parameters to make it look better or fit better in your scene.</p>
- <h2>Other Websites to Download Free Orange Tree 3D Models</h2>
- <h3>Sketchfab: A Platform for 3D and VR Content</h3>
- <h4>How to find and download free orange tree 3D models on Sketchfab?</h4>
- <p>Sketchfab is another popular platform for 3D and VR content. It was founded in 2012 and has over four million models in its library. Sketchfab allows anyone to upload, view, share, and download 3D models for various purposes. It also has a section dedicated to free 3D models that anyone can download and use without paying anything.</p>
- <p>Finding and downloading free orange tree 3D models on Sketchfab is similar to TurboSquid. Here are the steps you need to follow:</p>
- - Go to the <a href="">free 3D models section</a> of Sketchfab. - Type "orange tree" in the search bar and hit enter. - Use the filters on the left side of the page to narrow down your results by category, license, format, poly count, or tags. - Click on the thumbnail of each model to see more information about it. - Check the license, format, details, and preview of each model before downloading it. - Click on the download button on the bottom right corner of each model page. - Choose the format that is compatible with your software or application. - Download the model and use it in your project. <h3>CGTrader: A Marketplace for 3D Assets</h3>
- <h4>How to find and download free orange tree 3D models on CGTrader?</h4>
- <p>CGTrader is another marketplace for 3D assets. It was founded in 2011 and has over one million models in its catalog. CGTrader allows anyone to buy or sell 3D models for various purposes. It also has a section dedicated to free 3D models that anyone can download and use without paying anything.</p>
- <p>Finding and downloading free orange tree 3D models on CGTrader is similar to TurboSquid and Sketchfab. Here are the steps you need to follow:</p>
- - Go to the <a href="">free 3D models section</a> of CGTrader. - Type "orange tree" in the search bar and hit enter. - Use the filters on the left side of the page to narrow down your results by category, license, format, poly count, or tags. - Click on the thumbnail of each model to see more information about it. - Check the license, format, details, and preview of each model before downloading it. - Click on the download button on the bottom right corner of each model page. - Choose the format that is compatible with your software or application. - Download the model and use it in your project. <h2>Conclusion</h2>
- <h3>Summary of the main points</h3>
- <p>In this article, we have shown you how to find and download free orange tree 3D models from some of the most popular websites on the web. We have explained what orange tree 3D models are and why they are useful. We have also given you a step-by-step guide on how to use TurboSquid, Sketchfab, and CGTrader to search for, filter, check, and download free orange tree 3D models for your project.</p>
- <h3>Call to action and final remarks</h3>
- <p>We hope you have found this article helpful and informative. If you are looking for realistic and high-quality orange tree 3D models for your project, you can save time and money by downloading them for free from these websites. You can also explore other types of 3D models that are available for free or for a reasonable price.</p>
- <p>If you have any questions or feedback, please feel free to leave a comment below. We would love to hear from you and help you with your 3D modeling needs. Thank you for reading and happy downloading!</p>
- <h2>FAQs</h2>
- <h4>What are the benefits of using free orange tree 3D models?</h4>
- <p>Some of the benefits of using free orange tree 3D models are:</p>
-<ul>
-<li>You can save time and money by not having to create or buy your own models.</li>
-<li>You can enhance the realism and quality of your project by using models that are made by professional 3D artists.</li>
-<li>You can learn from the models by studying their structure, texture, lighting, and animation.</li>
-<li>You can support the 3D community by giving credit and feedback to the creators of the models.</li>
-</ul>
- <h4>What are the drawbacks of using free orange tree 3D models?</h4>
- <p>Some of the drawbacks of using free orange tree 3D models are:</p>
-<ul>
-<li>You may not find the exact model that matches your vision or requirements.</li>
-<li>You may have to deal with compatibility issues or errors when importing or exporting the models.</li>
-<li>You may have to follow certain restrictions or limitations when using the models in your project.</li>
-<li>You may have to compete with other users who are using the same models in their projects.</li>
-</ul>
- <h4>How can I improve the quality and performance of free orange tree 3D models?</h4>
- <p>Some of the ways you can improve the quality and performance of free orange tree 3D models are:</p>
-<ul>
-<li>You can optimize the poly count, texture size, and level of detail of the models to reduce the load on your system.</li>
-<li>You can adjust the lighting, shading, and rendering settings of your software or application to enhance the appearance of the models.</li>
-<li>You can modify or customize the models to suit your needs or preferences.</li>
-<li>You can combine or blend different models to create unique and diverse variations.</li>
-</ul>
- <h4>How can I avoid plagiarism or infringement when using free orange tree 3D models?</h4>
- <p>Some of the ways you can avoid plagiarism or infringement when using free orange tree 3D models are:</p>
-<ul>
-<li>You can always check the license and terms of use of each model before downloading and using it in your project.</li>
-<li>You can always give proper credit and attribution to the original creator or source of the model.</li>
-<li>You can always use the model for the intended purpose and not for any illegal or unethical activities.</li>
-<li>You can always respect the rights and reputation of the creator and other users of the model.</li>
-</ul>
- <h4>What are some tips and tricks for finding and downloading free orange tree 3D models?</h4>
- <p>Some of the tips and tricks for finding and downloading free orange tree 3D models are:</p>
-<ul>
-<li>You can use specific keywords, phrases, or tags to narrow down your search results.</li>
-<li>You can use advanced filters, such as category, license, format, poly count, or tags, to refine your search results.</li>
-<li>You can use collections, favorites, or bookmarks to save and organize the models that you like or want to use later.</li>
-<li>You can use ratings, reviews, or comments to evaluate the quality and popularity of the models.</li>
-<li>You can use previews, screenshots, or videos to see how the models look and behave in different situations.</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/pipelines/paint_by_example/pipeline_paint_by_example.py

@@ -1,536 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import inspect
-from typing import Callable, List, Optional, Union
-
-import numpy as np
-import paddle
-import PIL
-
-from paddlenlp.transformers import CLIPFeatureExtractor
-
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...pipeline_utils import DiffusionPipeline
-from ...schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
-from ...utils import logging
-from ..stable_diffusion import StableDiffusionPipelineOutput
-from ..stable_diffusion.safety_checker import StableDiffusionSafetyChecker
-from .image_encoder import PaintByExampleImageEncoder
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-def prepare_mask_and_masked_image(image, mask):
-    """
-    Prepares a pair (image, mask) to be consumed by the Paint by Example pipeline. This means that those inputs will be
-    converted to ``paddle.Tensor`` with shapes ``batch x channels x height x width`` where ``channels`` is ``3`` for the
-    ``image`` and ``1`` for the ``mask``.
-
-    The ``image`` will be converted to ``torch.float32`` and normalized to be in ``[-1, 1]``. The ``mask`` will be
-    binarized (``mask > 0.5``) and cast to ``torch.float32`` too.
-
-    Args:
-        image (Union[np.array, PIL.Image, paddle.Tensor]): The image to inpaint.
-            It can be a ``PIL.Image``, or a ``height x width x 3`` ``np.array`` or a ``channels x height x width``
-            ``paddle.Tensor`` or a ``batch x channels x height x width`` ``paddle.Tensor``.
-        mask (_type_): The mask to apply to the image, i.e. regions to inpaint.
-            It can be a ``PIL.Image``, or a ``height x width`` ``np.array`` or a ``1 x height x width``
-            ``paddle.Tensor`` or a ``batch x 1 x height x width`` ``paddle.Tensor``.
-
-
-    Raises:
-        ValueError: ``paddle.Tensor`` images should be in the ``[-1, 1]`` range. ValueError: ``paddle.Tensor`` mask
-        should be in the ``[0, 1]`` range. ValueError: ``mask`` and ``image`` should have the same spatial dimensions.
-        TypeError: ``mask`` is a ``paddle.Tensor`` but ``image`` is not
-            (ot the other way around).
-
-    Returns:
-        tuple[paddle.Tensor]: The pair (mask, masked_image) as ``paddle.Tensor`` with 4
-            dimensions: ``batch x channels x height x width``.
-    """
-    if isinstance(image, paddle.Tensor):
-        if not isinstance(mask, paddle.Tensor):
-            raise TypeError(f"`image` is a paddle.Tensor but `mask` (type: {type(mask)} is not")
-
-        # Batch single image
-        if image.ndim == 3:
-            assert image.shape[0] == 3, "Image outside a batch should be of shape (3, H, W)"
-            image = image.unsqueeze(0)
-
-        # Batch and add channel dim for single mask
-        if mask.ndim == 2:
-            mask = mask.unsqueeze(0).unsqueeze(0)
-
-        # Batch single mask or add channel dim
-        if mask.ndim == 3:
-            # Batched mask
-            if mask.shape[0] == image.shape[0]:
-                mask = mask.unsqueeze(1)
-            else:
-                mask = mask.unsqueeze(0)
-
-        assert image.ndim == 4 and mask.ndim == 4, "Image and Mask must have 4 dimensions"
-        assert image.shape[-2:] == mask.shape[-2:], "Image and Mask must have the same spatial dimensions"
-        assert image.shape[0] == mask.shape[0], "Image and Mask must have the same batch size"
-        assert mask.shape[1] == 1, "Mask image must have a single channel"
-
-        # Check image is in [-1, 1]
-        if image.min() < -1 or image.max() > 1:
-            raise ValueError("Image should be in [-1, 1] range")
-
-        # Check mask is in [0, 1]
-        if mask.min() < 0 or mask.max() > 1:
-            raise ValueError("Mask should be in [0, 1] range")
-
-        # paint-by-example inverses the mask
-        mask = 1 - mask
-
-        # Binarize mask
-        mask[mask < 0.5] = 0
-        mask[mask >= 0.5] = 1
-
-        # Image as float32
-        image = image.cast(paddle.float32)
-    elif isinstance(mask, paddle.Tensor):
-        raise TypeError(f"`mask` is a paddle.Tensor but `image` (type: {type(image)} is not")
-    else:
-        if isinstance(image, PIL.Image.Image):
-            image = [image]
-
-        image = np.concatenate([np.array(i.convert("RGB"))[None, :] for i in image], axis=0)
-        image = image.transpose(0, 3, 1, 2)
-        image = paddle.to_tensor(image).cast(paddle.float32) / 127.5 - 1.0
-
-        # preprocess mask
-        if isinstance(mask, PIL.Image.Image):
-            mask = [mask]
-
-        mask = np.concatenate([np.array(m.convert("L"))[None, None, :] for m in mask], axis=0)
-        mask = mask.astype(np.float32) / 255.0
-
-        # paint-by-example inverses the mask
-        mask = 1 - mask
-
-        mask[mask < 0.5] = 0
-        mask[mask >= 0.5] = 1
-        mask = paddle.to_tensor(mask)
-
-    masked_image = image * mask
-
-    return mask, masked_image
-
-
-class PaintByExamplePipeline(DiffusionPipeline):
-    r"""
-    Pipeline for text-guided image inpainting using Stable Diffusion. *This is an experimental feature*.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
-
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
-        text_encoder ([`CLIPTextModel`]):
-            Frozen text-encoder. Stable Diffusion uses the text portion of
-            [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
-            the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
-        tokenizer (`CLIPTokenizer`):
-            Tokenizer of class
-            [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
-        unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
-        safety_checker ([`StableDiffusionSafetyChecker`]):
-            Classification module that estimates whether generated images could be considered offensive or harmful.
-            Please, refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for details.
-        feature_extractor ([`CLIPFeatureExtractor`]):
-            Model that extracts features from generated images to be used as inputs for the `safety_checker`.
-    """
-    _optional_components = ["safety_checker"]
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        image_encoder: PaintByExampleImageEncoder,
-        unet: UNet2DConditionModel,
-        scheduler: Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler],
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPFeatureExtractor,
-        requires_safety_checker: bool = False,
-    ):
-        super().__init__()
-
-        self.register_modules(
-            vae=vae,
-            image_encoder=image_encoder,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.run_safety_checker
-    def run_safety_checker(self, image, dtype):
-        if self.safety_checker is not None:
-            safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pd")
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.cast(dtype)
-            )
-        else:
-            has_nsfw_concept = None
-        return image, has_nsfw_concept
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.decode_latents
-    def decode_latents(self, latents):
-        latents = 1 / 0.18215 * latents
-        image = self.vae.decode(latents).sample
-        image = (image / 2 + 0.5).clip(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
-        image = image.transpose([0, 2, 3, 1]).cast("float32").numpy()
-        return image
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_image_variation.StableDiffusionImageVariationPipeline.check_inputs
-    def check_inputs(self, image, height, width, callback_steps):
-        if (
-            not isinstance(image, paddle.Tensor)
-            and not isinstance(image, PIL.Image.Image)
-            and not isinstance(image, list)
-        ):
-            raise ValueError(
-                "`image` has to be of type `paddle.Tensor` or `PIL.Image.Image` or `List[PIL.Image.Image]` but is"
-                f" {type(image)}"
-            )
-
-        if height % 8 != 0 or width % 8 != 0:
-            raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
-
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents
-    def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, generator, latents=None):
-        shape = [batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor]
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        if latents is None:
-            if isinstance(generator, list):
-                shape = [
-                    1,
-                ] + shape[1:]
-                latents = [paddle.randn(shape, generator=generator[i], dtype=dtype) for i in range(batch_size)]
-                latents = paddle.concat(latents, axis=0)
-            else:
-                latents = paddle.randn(shape, generator=generator, dtype=dtype)
-        else:
-            if latents.shape != shape:
-                raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}")
-
-        # scale the initial noise by the standard deviation required by the scheduler
-        latents = latents * self.scheduler.init_noise_sigma
-        return latents
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_inpaint.StableDiffusionInpaintPipeline.prepare_mask_latents
-    def prepare_mask_latents(
-        self, mask, masked_image, batch_size, height, width, dtype, generator, do_classifier_free_guidance
-    ):
-        # resize the mask to latents shape as we concatenate the mask to the latents
-        # we do that before converting to dtype to avoid breaking in case we're using cpu_offload
-        # and half precision
-        mask = paddle.nn.functional.interpolate(
-            mask, size=(height // self.vae_scale_factor, width // self.vae_scale_factor)
-        )
-        mask = mask.cast(dtype)
-
-        masked_image = masked_image.cast(dtype)
-
-        # encode the mask image into latents space so we can concatenate it to the latents
-        if isinstance(generator, list):
-            masked_image_latents = [
-                self.vae.encode(masked_image[i : i + 1]).latent_dist.sample(generator=generator[i])
-                for i in range(batch_size)
-            ]
-            masked_image_latents = paddle.concat(masked_image_latents, axis=0)
-        else:
-            masked_image_latents = self.vae.encode(masked_image).latent_dist.sample(generator=generator)
-        masked_image_latents = 0.18215 * masked_image_latents
-
-        # duplicate mask and masked_image_latents for each generation per prompt, using mps friendly method
-        if mask.shape[0] < batch_size:
-            if not batch_size % mask.shape[0] == 0:
-                raise ValueError(
-                    "The passed mask and the required batch size don't match. Masks are supposed to be duplicated to"
-                    f" a total batch size of {batch_size}, but {mask.shape[0]} masks were passed. Make sure the number"
-                    " of masks that you pass is divisible by the total requested batch size."
-                )
-            mask = mask.tile([batch_size // mask.shape[0], 1, 1, 1])
-        if masked_image_latents.shape[0] < batch_size:
-            if not batch_size % masked_image_latents.shape[0] == 0:
-                raise ValueError(
-                    "The passed images and the required batch size don't match. Images are supposed to be duplicated"
-                    f" to a total batch size of {batch_size}, but {masked_image_latents.shape[0]} images were passed."
-                    " Make sure the number of images that you pass is divisible by the total requested batch size."
-                )
-            masked_image_latents = masked_image_latents.tile([batch_size // masked_image_latents.shape[0], 1, 1, 1])
-
-        mask = paddle.concat([mask] * 2) if do_classifier_free_guidance else mask
-        masked_image_latents = (
-            paddle.concat([masked_image_latents] * 2) if do_classifier_free_guidance else masked_image_latents
-        )
-
-        # aligning device to prevent device errors when concating it with the latent model input
-        masked_image_latents = masked_image_latents.cast(dtype)
-        return mask, masked_image_latents
-
-    def _encode_image(self, image, num_images_per_prompt, do_classifier_free_guidance):
-        # dtype = self.image_encoder.dtype
-
-        if not isinstance(image, paddle.Tensor):
-            image = self.feature_extractor(images=image, return_tensors="pd").pixel_values
-
-        # image = image.cast(dtype)
-        image_embeddings = self.image_encoder(image)
-
-        # duplicate image embeddings for each generation per prompt, using mps friendly method
-        bs_embed, seq_len, _ = image_embeddings.shape
-        image_embeddings = image_embeddings.tile([1, num_images_per_prompt, 1])
-        image_embeddings = image_embeddings.reshape([bs_embed * num_images_per_prompt, seq_len, -1])
-
-        if do_classifier_free_guidance:
-            uncond_embeddings = self.image_encoder.uncond_vector
-            uncond_embeddings = uncond_embeddings.tile([1, image_embeddings.shape[0], 1])
-            uncond_embeddings = uncond_embeddings.reshape([bs_embed * num_images_per_prompt, 1, -1])
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            image_embeddings = paddle.concat([uncond_embeddings, image_embeddings])
-
-        return image_embeddings
-
-    @paddle.no_grad()
-    def __call__(
-        self,
-        example_image: Union[paddle.Tensor, PIL.Image.Image],
-        image: Union[paddle.Tensor, PIL.Image.Image],
-        mask_image: Union[paddle.Tensor, PIL.Image.Image],
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 5.0,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[Union[paddle.Generator, List[paddle.Generator]]] = None,
-        latents: Optional[paddle.Tensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, paddle.Tensor], None]] = None,
-        callback_steps: Optional[int] = 1,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            example_image (`paddle.Tensor` or `PIL.Image.Image` or `List[PIL.Image.Image]`):
-                The exemplar image to guide the image generation.
-            image (`paddle.Tensor` or `PIL.Image.Image` or `List[PIL.Image.Image]`):
-                `Image`, or tensor representing an image batch which will be inpainted, *i.e.* parts of the image will
-                be masked out with `mask_image` and repainted according to `prompt`.
-            mask_image (`paddle.Tensor` or `PIL.Image.Image` or `List[PIL.Image.Image]`):
-                `Image`, or tensor representing an image batch, to mask `image`. White pixels in the mask will be
-                repainted, while black pixels will be preserved. If `mask_image` is a PIL image, it will be converted
-                to a single channel (luminance) before use. If it's a tensor, it should contain one color channel (L)
-                instead of 3, so the expected shape would be `(B, H, W, 1)`.
-            height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
-                The height in pixels of the generated image.
-            width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
-                The width in pixels of the generated image.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.0):
-                Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
-                [`schedulers.DDIMScheduler`], will be ignored for others.
-            generator (`torch.Generator`, *optional*):
-                One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
-                to make generation deterministic.
-            latents (`paddle.Tensor`, *optional*):
-                Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image
-                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
-                tensor will ge generated by sampling using the supplied random `generator`.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that will be called every `callback_steps` steps during inference. The function will be
-                called with the following arguments: `callback(step: int, timestep: int, latents: paddle.Tensor)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function will be called. If not specified, the callback will be
-                called at every step.
-
-        Returns:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
-            When returning a tuple, the first element is a list with the generated images, and the second element is a
-            list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
-            (nsfw) content, according to the `safety_checker`.
-        """
-        # 1. Define call parameters
-        if isinstance(image, PIL.Image.Image):
-            batch_size = 1
-        elif isinstance(image, list):
-            batch_size = len(image)
-        else:
-            batch_size = image.shape[0]
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # 2. Preprocess mask and image
-        mask, masked_image = prepare_mask_and_masked_image(image, mask_image)
-        height, width = masked_image.shape[-2:]
-
-        # 3. Check inputs
-        self.check_inputs(example_image, height, width, callback_steps)
-
-        # 4. Encode input image
-        image_embeddings = self._encode_image(example_image, num_images_per_prompt, do_classifier_free_guidance)
-
-        # 5. set timesteps
-        self.scheduler.set_timesteps(num_inference_steps)
-        timesteps = self.scheduler.timesteps
-
-        # 6. Prepare latent variables
-        num_channels_latents = self.vae.config.latent_channels
-        latents = self.prepare_latents(
-            batch_size * num_images_per_prompt,
-            num_channels_latents,
-            height,
-            width,
-            image_embeddings.dtype,
-            generator,
-            latents,
-        )
-
-        # 7. Prepare mask latent variables
-        mask, masked_image_latents = self.prepare_mask_latents(
-            mask,
-            masked_image,
-            batch_size * num_images_per_prompt,
-            height,
-            width,
-            image_embeddings.dtype,
-            generator,
-            do_classifier_free_guidance,
-        )
-
-        # 8. Check that sizes of mask, masked image and latents match
-        num_channels_mask = mask.shape[1]
-        num_channels_masked_image = masked_image_latents.shape[1]
-        if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:
-            raise ValueError(
-                f"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects"
-                f" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +"
-                f" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}"
-                f" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of"
-                " `pipeline.unet` or your `mask_image` or `image` input."
-            )
-
-        # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
-        # 10. Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = paddle.concat([latents] * 2) if do_classifier_free_guidance else latents
-
-                # concat latents, mask, masked_image_latents in the channel dimension
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-                latent_model_input = paddle.concat([latent_model_input, masked_image_latents, mask], axis=1)
-
-                # predict the noise residual
-                noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=image_embeddings).sample
-
-                # perform guidance
-                if do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
-        # 11. Post-processing
-        image = self.decode_latents(latents)
-
-        # 12. Run safety checker
-        image, has_nsfw_concept = self.run_safety_checker(image, image_embeddings.dtype)
-
-        # 13. Convert to PIL
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        if not return_dict:
-            return (image, has_nsfw_concept)
-
-        return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)

spaces/AI-Dashboards/CP.Matplotlib.NetworkX.Streamlit.PyVis.Graphviz/README.md

@@ -1,13 +0,0 @@
----
-title: 🕸️📈Graph NLP Matplotlib NetworkX Streamlit PyViz Graphviz🩺
-emoji: 📉🕸️📈
-colorFrom: pink
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.2.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

spaces/AI-Hobbyist/Hoyo-RVC/docs/training_tips_ko.md

@@ -1,53 +0,0 @@
-RVC 훈련에 대한 설명과 팁들
-======================================
-본 팁에서는 어떻게 데이터 훈련이 이루어지고 있는지 설명합니다.
-
-# 훈련의 흐름
-GUI의 훈련 탭의 단계를 따라 설명합니다.
-
-## step1
-실험 이름을 지정합니다. 또한, 모델이 피치(소리의 높낮이)를 고려해야 하는지 여부를 여기에서 설정할 수도 있습니다..
-각 실험을 위한 데이터는 `/logs/experiment name/`에 배치됩니다..
-
-## step2a
-음성 파일을 불러오고 전처리합니다.
-
-### 음성 파일 불러오기
-음성 파일이 있는 폴더를 지정하면 해당 폴더에 있는 음성 파일이 자동으로 가져와집니다.
-예를 들어 `C:Users\hoge\voices`를 지정하면 `C:Users\hoge\voices\voice.mp3`가 읽히지만 `C:Users\hoge\voices\dir\voice.mp3`는 읽히지 않습니다.
-
-음성 로드에는 내부적으로 ffmpeg를 이용하고 있으므로, ffmpeg로 대응하고 있는 확장자라면 자동적으로 읽힙니다.
-ffmpeg에서 int16으로 변환한 후 float32로 변환하고 -1과 1 사이에 정규화됩니다.
-
-### 잡음 제거
-음성 파일에 대해 scipy의 filtfilt를 이용하여 잡음을 처리합니다.
-
-### 음성 분할
-입력한 음성 파일은 먼저 일정 기간(max_sil_kept=5초?)보다 길게 무음이 지속되는 부분을 감지하여 음성을 분할합니다.무음으로 음성을 분할한 후에는 0.3초의 overlap을 포함하여 4초마다 음성을 분할합니다.4초 이내에 구분된 음성은 음량의 정규화를 실시한 후 wav 파일을 `/logs/실험명/0_gt_wavs`로, 거기에서 16k의 샘플링 레이트로 변환해 `/logs/실험명/1_16k_wavs`에 wav 파일로 저장합니다.
-
-## step2b
-### 피치 추출
-wav 파일에서 피치(소리의 높낮이) 정보를 추출합니다. parselmouth나 pyworld에 내장되어 있는 메서드으로 피치 정보(=f0)를 추출해, `/logs/실험명/2a_f0`에 저장합니다. 그 후 피치 정보를 로그로 변환하여 1~255 정수로 변환하고 `/logs/실험명/2b-f0nsf`에 저장합니다.
-
-### feature_print 추출
-HuBERT를 이용하여 wav 파일을 미리 embedding으로 변환합니다. `/logs/실험명/1_16k_wavs`에 저장한 wav 파일을 읽고 HuBERT에서 wav 파일을 256차원 feature들로 변환한 후 npy 형식으로 `/logs/실험명/3_feature256`에 저장합니다.
-
-## step3
-모델의 훈련을 진행합니다.
-
-### 초보자용 용어 해설
-심층학습(딥러닝)에서는 데이터셋을 분할하여 조금씩 학습을 진행합니다.한 번의 모델 업데이트(step) 단계 당 batch_size개의 데이터를 탐색하여 예측과 오차를 수정합니다. 데이터셋 전부에 대해 이 작업을 한 번 수행하는 이를 하나의 epoch라고 계산합니다.
-
-따라서 학습 시간은 단계당 학습 시간 x (데이터셋 내 데이터의 수 / batch size) x epoch 수가 소요됩니다. 일반적으로 batch size가 클수록 학습이 안정적이게 됩니다. (step당 학습 시간 ÷ batch size)는 작아지지만 GPU 메모리를 더 많이 사용합니다. GPU RAM은 nvidia-smi 명령어를 통해 확인할 수 있습니다. 실행 환경에 따라 배치 크기를 최대한 늘리면 짧은 시간 내에 학습이 가능합니다.
-
-### 사전 학습된 모델 지정
-RVC는 적은 데이터셋으로도 훈련이 가능하도록 사전 훈련된 가중치에서 모델 훈련을 시작합니다. 기본적으로 `rvc-location/pretrained/f0G40k.pth` 및 `rvc-location/pretrained/f0D40k.pth`를 불러옵니다. 학습을 할 시에, 모델 파라미터는 각 save_every_epoch별로 `logs/experiment name/G_{}.pth` 와 `logs/experiment name/D_{}.pth`로 저장이 되는데, 이 경로를 지정함으로써 학습을 재개하거나, 다른 실험에서 학습한 모델의 가중치에서 학습을 시작할 수 있습니다.
-
-### index의 학습
-RVC에서는 학습시에 사용된 HuBERT의 feature값을 저장하고, 추론 시에는 학습 시 사용한 feature값과 유사한 feature 값을 탐색해 추론을 진행합니다. 이 탐색을 고속으로 수행하기 위해 사전에 index을 학습하게 됩니다.
-Index 학습에는 근사 근접 탐색법 라이브러리인 Faiss를 사용하게 됩니다. `/logs/실험명/3_feature256`의 feature값을 불러와, 이를 모두 결합시킨 feature값을 `/logs/실험명/total_fea.npy`로서 저장, 그것을 사용해 학습한 index를`/logs/실험명/add_XXX.index`로 저장합니다.
-
-### 버튼 설명
-- モデルのトレーニング (모델 학습): step2b까지 실행한 후, 이 버튼을 눌러 모델을 학습합니다.
-- 特徴インデックスのトレーニング (특징 지수 훈련): 모델의 훈련 후, index를 학습합니다.
-- ワンクリックトレーニング (원클릭 트레이닝): step2b까지의 모델 훈련, feature index 훈련을 일괄로 실시합니다.

spaces/AIFILMS/audioldm-text-to-audio-generation/audioldm/clap/training/zero_shot.py

@@ -1,95 +0,0 @@
-# NOTE: This script is currently not supported for CLAP.
-import logging
-from contextlib import suppress
-
-import torch
-import torch.nn.functional as F
-from tqdm import tqdm
-
-from open_clip import tokenize
-from .imagenet_zeroshot_data import imagenet_classnames, openai_imagenet_template
-
-
-def zero_shot_classifier(model, classnames, templates, args):
-    with torch.no_grad():
-        zeroshot_weights = []
-        for classname in tqdm(classnames):
-            texts = [template(classname) for template in templates]  # format with class
-            texts = tokenize(texts).to(args.device)  # tokenize
-            if args.distributed and not args.horovod:
-                class_embeddings = model.module.encode_text(texts)
-            else:
-                class_embeddings = model.encode_text(texts)
-            class_embedding = F.normalize(class_embeddings, dim=-1).mean(dim=0)
-            class_embedding /= class_embedding.norm()
-            zeroshot_weights.append(class_embedding)
-        zeroshot_weights = torch.stack(zeroshot_weights, dim=1).to(args.device)
-    return zeroshot_weights
-
-
-def accuracy(output, target, topk=(1,)):
-    pred = output.topk(max(topk), 1, True, True)[1].t()
-    correct = pred.eq(target.view(1, -1).expand_as(pred))
-    return [
-        float(correct[:k].reshape(-1).float().sum(0, keepdim=True).cpu().numpy())
-        for k in topk
-    ]
-
-
-def run(model, classifier, dataloader, args):
-    autocast = torch.cuda.amp.autocast if args.precision == "amp" else suppress
-    with torch.no_grad():
-        top1, top5, n = 0.0, 0.0, 0.0
-        for images, target in tqdm(dataloader, unit_scale=args.batch_size):
-            images = images.to(args.device)
-            target = target.to(args.device)
-
-            with autocast():
-                # predict
-                if args.distributed and not args.horovod:
-                    image_features = model.module.encode_image(images)
-                else:
-                    image_features = model.encode_image(images)
-                image_features = F.normalize(image_features, dim=-1)
-                logits = 100.0 * image_features @ classifier
-
-            # measure accuracy
-            acc1, acc5 = accuracy(logits, target, topk=(1, 5))
-            top1 += acc1
-            top5 += acc5
-            n += images.size(0)
-
-    top1 = top1 / n
-    top5 = top5 / n
-    return top1, top5
-
-
-def zero_shot_eval(model, data, epoch, args):
-    if "imagenet-val" not in data and "imagenet-v2" not in data:
-        return {}
-    if args.zeroshot_frequency == 0:
-        return {}
-    if (epoch % args.zeroshot_frequency) != 0 and epoch != args.epochs:
-        return {}
-
-    logging.info("Starting zero-shot imagenet.")
-
-    logging.info("Building zero-shot classifier")
-    classifier = zero_shot_classifier(
-        model, imagenet_classnames, openai_imagenet_template, args
-    )
-
-    logging.info("Using classifier")
-    results = {}
-    if "imagenet-val" in data:
-        top1, top5 = run(model, classifier, data["imagenet-val"].dataloader, args)
-        results["imagenet-zeroshot-val-top1"] = top1
-        results["imagenet-zeroshot-val-top5"] = top5
-    if "imagenet-v2" in data:
-        top1, top5 = run(model, classifier, data["imagenet-v2"].dataloader, args)
-        results["imagenetv2-zeroshot-val-top1"] = top1
-        results["imagenetv2-zeroshot-val-top5"] = top5
-
-    logging.info("Finished zero-shot imagenet.")
-
-    return results

spaces/AIWaves/Software_Company/README.md

@@ -1,13 +0,0 @@
----
-title: Software Company
-emoji: 🐨
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.44.4
-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/AIWaves/Software_Company/src/agents/Component/ToolComponent.py

@@ -1,887 +0,0 @@
-from abc import abstractmethod
-import uuid
-from text2vec import semantic_search
-from utils import (
-    get_relevant_history,
-    load_knowledge_base_qa,
-    load_knowledge_base_UnstructuredFile,
-    get_embedding,
-    extract,
-)
-import json
-from typing import Dict, List
-import os
-from googleapiclient.discovery import build
-import requests
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from bs4 import BeautifulSoup
-import base64
-import re
-from datetime import datetime, timedelta
-from typing import Tuple, List, Any, Dict
-from email.mime.text import MIMEText
-from email.mime.multipart import MIMEMultipart
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-from tqdm import tqdm
-
-class ToolComponent:
-    def __init__(self):
-        pass
-
-    @abstractmethod
-    def func(self):
-        pass
-    
-class KnowledgeBaseComponent(ToolComponent):
-    """
-    Inject knowledge base
-    top_k : Top_k with the highest matching degree
-    type : "QA" or others
-    knowledge_base(json_path) : knowledge_base_path
-    """
-    def __init__(self, top_k, type, knowledge_base):
-        super().__init__()
-        self.top_k = top_k
-        self.type = type
-        self.knowledge_base = knowledge_base
-
-        if self.type == "QA":
-            (
-                self.kb_embeddings,
-                self.kb_questions,
-                self.kb_answers,
-                self.kb_chunks,
-            ) = load_knowledge_base_qa(self.knowledge_base)
-        else:
-            self.kb_embeddings, self.kb_chunks = load_knowledge_base_UnstructuredFile(
-                self.knowledge_base
-            )
-
-    def func(self, agent):
-        query = (
-            agent.long_term_memory[-1]["content"]
-            if len(agent.long_term_memory) > 0
-            else ""
-        )
-        knowledge = ""
-        query = extract(query, "query")
-        query_embedding = get_embedding(query)
-        hits = semantic_search(query_embedding, self.kb_embeddings, top_k=50)
-        hits = hits[0]
-        temp = []
-        if self.type == "QA":
-            for hit in hits:
-                matching_idx = hit["corpus_id"]
-                if self.kb_chunks[matching_idx] in temp:
-                    pass
-                else:
-                    knowledge = (
-                        knowledge
-                        + f"question:{self.kb_questions[matching_idx]},answer:{self.kb_answers[matching_idx]}\n\n"
-                    )
-                    temp.append(self.kb_answers[matching_idx])
-                    if len(temp) == 1:
-                        break
-            print(hits[0]["score"])
-            score = hits[0]["score"]
-            if score < 0.5:
-                return {"prompt": "No matching knowledge base"}
-            else:
-                return {"prompt": "The relevant content is: " + knowledge + "\n"}
-        else:
-            for hit in hits:
-                matching_idx = hit["corpus_id"]
-                if self.kb_chunks[matching_idx] in temp:
-                    pass
-                else:
-                    knowledge = knowledge + f"{self.kb_answers[matching_idx]}\n\n"
-                    temp.append(self.kb_answers[matching_idx])
-                    if len(temp) == self.top_k:
-                        break
-            print(hits[0]["score"])
-            score = hits[0]["score"]
-            if score < 0.5:
-                return {"prompt": "No matching knowledge base"}
-            else:
-                print(knowledge)
-                return {"prompt": "The relevant content is: " + knowledge + "\n"}
-
-
-class StaticComponent(ToolComponent):
-    "Return static response"
-    def __init__(self, output):
-        super().__init__()
-        self.output = output
-
-    def func(self, agent):
-        outputdict = {"response": self.output}
-        return outputdict
-
-
-class ExtractComponent(ToolComponent):
-    """
-    Extract keywords based on the current scene and store them in the environment
-    extract_words(list) : Keywords to be extracted
-    system_prompt & last_prompt : Prompt to extract keywords
-    """
-    def __init__(
-        self,
-        extract_words,
-        system_prompt,
-        last_prompt=None,
-    ):
-        super().__init__()
-        self.extract_words = extract_words
-        self.system_prompt = system_prompt
-        self.default_prompt = (
-            "Please strictly adhere to the following format for outputting:\n"
-        )
-        for extract_word in extract_words:
-            self.default_prompt += (
-                f"<{extract_word}> the content you need to extract </{extract_word}>"
-            )
-        self.last_prompt = last_prompt if last_prompt else self.default_prompt
-
-    def func(self, agent):
-        response = agent.LLM.get_response(
-            agent.long_term_memory,
-            self.system_prompt,
-            self.last_prompt,
-            stream=False,
-        )
-        for extract_word in self.extract_words:
-            key = extract(response, extract_word)
-            key = key if key else response
-            agent.environment.shared_memory[extract_word] = key
-
-        return {}
-
-
-"""Search sources: chatgpt/search engines/specific search sources/can even be multimodal (if it comes to clothing)"""
-
-
-class WebSearchComponent(ToolComponent):
-    """search engines"""
-
-    __ENGINE_NAME__: List = ["google", "bing"]
-
-    def __init__(self, engine_name: str, api: Dict):
-        """
-        :param engine_name: The name of the search engine used
-        :param api: Pass in a dictionary, such as {"bing":"key1", "google":"key2", ...}, of course each value can also be a list, or more complicated
-        """
-        super(WebSearchComponent, self).__init__()
-        """Determine whether the key and engine_name of the api are legal"""
-
-        assert engine_name in WebSearchComponent.__ENGINE_NAME__
-        for api_name in api:
-            assert api_name in WebSearchComponent.__ENGINE_NAME__
-
-        self.api = api
-        self.engine_name = engine_name
-
-        self.search: Dict = {"bing": self._bing_search, "google": self._google_search}
-
-    def _bing_search(self, query: str, **kwargs):
-        """Initialize search hyperparameters"""
-        subscription_key = self.api["bing"]
-        search_url = "https://api.bing.microsoft.com/v7.0/search"
-        headers = {"Ocp-Apim-Subscription-Key": subscription_key}
-        params = {
-            "q": query,
-            "textDecorations": True,
-            "textFormat": "HTML",
-            "count": 10,
-        }
-        """start searching"""
-        response = requests.get(search_url, headers=headers, params=params)
-        response.raise_for_status()
-        results = response.json()["webPages"]["value"]
-        """execute"""
-        metadata_results = []
-        for result in results:
-            metadata_result = {
-                "snippet": result["snippet"],
-                "title": result["name"],
-                "link": result["url"],
-            }
-            metadata_results.append(metadata_result)
-        return {"meta data": metadata_results}
-
-    def _google_search(self, query: str, **kwargs):
-        """Initialize search hyperparameters"""
-        api_key = self.api[self.engine_name]["api_key"]
-        cse_id = self.api[self.engine_name]["cse_id"]
-        service = build("customsearch", "v1", developerKey=api_key)
-        """start searching"""
-        results = (
-            service.cse().list(q=query, cx=cse_id, num=10, **kwargs).execute()["items"]
-        )
-        """execute"""
-        metadata_results = []
-        for result in results:
-            metadata_result = {
-                "snippet": result["snippet"],
-                "title": result["title"],
-                "link": result["link"],
-            }
-            metadata_results.append(metadata_result)
-        return {"meta data": metadata_results}
-
-    def func(self, agent, **kwargs) -> Dict:
-        query = (
-            agent.long_term_memory[-1]["content"]
-            if len(agent.long_term_memory) > 0
-            else " "
-        )
-        response = agent.LLM.get_response(
-            None,
-            system_prompt=f"Please analyze the provided conversation and identify keywords that can be used for a search engine query. Format the output as <keywords>extracted keywords</keywords>:\nConversation:\n{query}",
-            stream=False,
-        )
-        response = extract(response, "keywords")
-        query = response if response else query
-
-        search_results = self.search[self.engine_name](query=query, **kwargs)
-        information = ""
-        for i in search_results["meta data"][:5]:
-            information += i["snippet"]
-        return {
-            "prompt": "You can refer to the following information to reply:\n"
-            + information
-        }
-
-    def convert_search_engine_to(self, engine_name):
-        assert engine_name in WebSearchComponent.__ENGINE_NAME__
-        self.engine_name = engine_name
-
-
-class WebCrawlComponent(ToolComponent):
-    """Open a single web page for crawling"""
-
-    def __init__(self):
-        super(WebCrawlComponent, self).__init__()
-
-    def func(self, agent_dict) -> Dict:
-        url = agent_dict["url"]
-        print(f"crawling {url} ......")
-        content = ""
-        """Crawling content from url may need to be carried out according to different websites, such as wiki, baidu, zhihu, etc."""
-        driver = webdriver.Chrome()
-        try:
-            """open url"""
-            driver.get(url)
-
-            """wait 20 second"""
-            wait = WebDriverWait(driver, 20)
-            wait.until(EC.presence_of_element_located((By.TAG_NAME, "body")))
-
-            """crawl code"""
-            page_source = driver.page_source
-
-            """parse"""
-            soup = BeautifulSoup(page_source, "html.parser")
-
-            """concatenate"""
-            for paragraph in soup.find_all("p"):
-                content = f"{content}\n{paragraph.get_text()}"
-        except Exception as e:
-            print("Error:", e)
-        finally:
-            """quit"""
-            driver.quit()
-        return {"content": content.strip()}
-
-
-class MailComponent(ToolComponent):
-    __VALID_ACTION__ = ["read", "send"]
-
-    def __init__(
-        self, cfg_file: str, default_action: str = "read", name: str = "e-mail"
-    ):
-        """'../config/google_mail.json'"""
-        super(MailComponent, self).__init__(name)
-        self.name = name
-        assert (
-            default_action.lower() in self.__VALID_ACTION__
-        ), f"Action `{default_action}` is not allowed! The valid action is in `{self.__VALID_ACTION__}`"
-        self.action = default_action.lower()
-        self.credential = self._login(cfg_file)
-
-    def _login(self, cfg_file: str):
-        SCOPES = [
-            "https://www.googleapis.com/auth/gmail.readonly",
-            "https://www.googleapis.com/auth/gmail.send",
-        ]
-        creds = None
-        if os.path.exists("token.json"):
-            print("Login Successfully!")
-            creds = Credentials.from_authorized_user_file("token.json", SCOPES)
-        if not creds or not creds.valid:
-            print("Please authorize in an open browser.")
-            if creds and creds.expired and creds.refresh_token:
-                creds.refresh(Request())
-            else:
-                flow = InstalledAppFlow.from_client_secrets_file(cfg_file, SCOPES)
-                creds = flow.run_local_server(port=0)
-            # Save the credentials for the next run
-            with open("token.json", "w") as token:
-                token.write(creds.to_json())
-        return creds
-
-    def _read(self, mail_dict: dict):
-        credential = self.credential
-        state = mail_dict["state"] if "state" in mail_dict else None
-        time_between = (
-            mail_dict["time_between"] if "time_between" in mail_dict else None
-        )
-        sender_mail = mail_dict["sender_mail"] if "sender_mail" in mail_dict else None
-        only_both = mail_dict["only_both"] if "only_both" in mail_dict else False
-        order_by_time = (
-            mail_dict["order_by_time"] if "order_by_time" in mail_dict else "descend"
-        )
-        include_word = (
-            mail_dict["include_word"] if "include_word" in mail_dict else None
-        )
-        exclude_word = (
-            mail_dict["exclude_word"] if "exclude_word" in mail_dict else None
-        )
-        MAX_SEARCH_CNT = (
-            mail_dict["MAX_SEARCH_CNT"] if "MAX_SEARCH_CNT" in mail_dict else 50
-        )
-        number = mail_dict["number"] if "number" in mail_dict else 10
-        if state is None:
-            state = "all"
-        if time_between is not None:
-            assert isinstance(time_between, tuple)
-            assert len(time_between) == 2
-        assert state in ["all", "unread", "read", "sent"]
-        if only_both:
-            assert sender_mail is not None
-        if sender_mail is not None:
-            assert isinstance(sender_mail, str)
-        assert credential
-        assert order_by_time in ["descend", "ascend"]
-
-        def generate_query():
-            query = ""
-            if state in ["unread", "read"]:
-                query = f"is:{state}"
-            if state in ["sent"]:
-                query = f"in:{state}"
-            if only_both:
-                query = f"{query} from:{sender_mail} OR to:{sender_mail}"
-            if sender_mail is not None and not only_both:
-                query = f"{query} from:({sender_mail})"
-            if include_word is not None:
-                query = f"{query} {include_word}"
-            if exclude_word is not None:
-                query = f"{query} -{exclude_word}"
-            if time_between is not None:
-                TIME_FORMAT = "%Y/%m/%d"
-                t1, t2 = time_between
-                if t1 == "now":
-                    t1 = datetime.now().strftime(TIME_FORMAT)
-                if t2 == "now":
-                    t2 = datetime.now().strftime(TIME_FORMAT)
-                if isinstance(t1, str) and isinstance(t2, str):
-                    t1 = datetime.strptime(t1, TIME_FORMAT)
-                    t2 = datetime.strptime(t2, TIME_FORMAT)
-                elif isinstance(t1, str) and isinstance(t2, int):
-                    t1 = datetime.strptime(t1, TIME_FORMAT)
-                    t2 = t1 + timedelta(days=t2)
-                elif isinstance(t1, int) and isinstance(t2, str):
-                    t2 = datetime.strptime(t2, TIME_FORMAT)
-                    t1 = t2 + timedelta(days=t1)
-                else:
-                    assert False, "invalid time"
-                if t1 > t2:
-                    t1, t2 = t2, t1
-                query = f"{query} after:{t1.strftime(TIME_FORMAT)} before:{t2.strftime(TIME_FORMAT)}"
-            return query.strip()
-
-        def sort_by_time(data: List[Dict]):
-            if order_by_time == "descend":
-                reverse = True
-            else:
-                reverse = False
-            sorted_data = sorted(
-                data,
-                key=lambda x: datetime.strptime(x["time"], "%Y-%m-%d %H:%M:%S"),
-                reverse=reverse,
-            )
-            return sorted_data
-
-        try:
-            service = build("gmail", "v1", credentials=credential)
-            results = (
-                service.users()
-                .messages()
-                .list(userId="me", labelIds=["INBOX"], q=generate_query())
-                .execute()
-            )
-
-            messages = results.get("messages", [])
-            email_data = list()
-
-            if not messages:
-                print("No eligible emails.")
-                return None
-            else:
-                pbar = tqdm(total=min(MAX_SEARCH_CNT, len(messages)))
-                for cnt, message in enumerate(messages):
-                    pbar.update(1)
-                    if cnt >= MAX_SEARCH_CNT:
-                        break
-                    msg = (
-                        service.users()
-                        .messages()
-                        .get(
-                            userId="me",
-                            id=message["id"],
-                            format="full",
-                            metadataHeaders=None,
-                        )
-                        .execute()
-                    )
-
-                    subject = ""
-                    for header in msg["payload"]["headers"]:
-                        if header["name"] == "Subject":
-                            subject = header["value"]
-                            break
-
-                    sender = ""
-                    for header in msg["payload"]["headers"]:
-                        if header["name"] == "From":
-                            sender = re.findall(
-                                r"\b[\w\.-]+@[\w\.-]+\.\w+\b", header["value"]
-                            )[0]
-                            break
-                    body = ""
-                    if "parts" in msg["payload"]:
-                        for part in msg["payload"]["parts"]:
-                            if part["mimeType"] == "text/plain":
-                                data = part["body"]["data"]
-                                body = base64.urlsafe_b64decode(data).decode("utf-8")
-                                break
-
-                    email_info = {
-                        "sender": sender,
-                        "time": datetime.fromtimestamp(
-                            int(msg["internalDate"]) / 1000
-                        ).strftime("%Y-%m-%d %H:%M:%S"),
-                        "subject": subject,
-                        "body": body,
-                    }
-                    email_data.append(email_info)
-                pbar.close()
-            email_data = sort_by_time(email_data)[0:number]
-            return {"results": email_data}
-        except Exception as e:
-            print(e)
-            return None
-
-    def _send(self, mail_dict: dict):
-        recipient_mail = mail_dict["recipient_mail"]
-        subject = mail_dict["subject"]
-        body = mail_dict["body"]
-        credential = self.credential
-        service = build("gmail", "v1", credentials=credential)
-
-        message = MIMEMultipart()
-        message["to"] = recipient_mail
-        message["subject"] = subject
-
-        message.attach(MIMEText(body, "plain"))
-
-        raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode("utf-8")
-        try:
-            message = (
-                service.users()
-                .messages()
-                .send(userId="me", body={"raw": raw_message})
-                .execute()
-            )
-            return {"state": True}
-        except HttpError as error:
-            print(error)
-            return {"state": False}
-
-    def func(self, mail_dict: dict):
-        if "action" in mail_dict:
-            assert mail_dict["action"].lower() in self.__VALID_ACTION__
-            self.action = mail_dict["action"]
-        functions = {"read": self._read, "send": self._send}
-        return functions[self.action](mail_dict)
-
-    def convert_action_to(self, action_name: str):
-        assert (
-            action_name.lower() in self.__VALID_ACTION__
-        ), f"Action `{action_name}` is not allowed! The valid action is in `{self.__VALID_ACTION__}`"
-        self.action = action_name.lower()
-
-
-class WeatherComponet(ToolComponent):
-    def __init__(self, api_key, name="weather", TIME_FORMAT="%Y-%m-%d"):
-        super(WeatherComponet, self).__init__(name)
-        self.name = name
-        self.TIME_FORMAT = TIME_FORMAT
-        self.api_key = api_key
-
-    def _parse(self, data):
-        dict_data: dict = {}
-        for item in data["data"]:
-            date = item["datetime"]
-            dict_data[date] = {}
-            if "weather" in item:
-                dict_data[date]["description"] = item["weather"]["description"]
-            mapping = {
-                "temp": "temperature",
-                "max_temp": "max_temperature",
-                "min_temp": "min_temperature",
-                "precip": "accumulated_precipitation",
-            }
-            for key in ["temp", "max_temp", "min_temp", "precip"]:
-                if key in item:
-                    dict_data[date][mapping[key]] = item[key]
-        return dict_data
-
-    def _query(self, city_name, country_code, start_date, end_date):
-        """https://www.weatherbit.io/api/historical-weather-daily"""
-        # print(datetime.strftime(start_date, self.TIME_FORMAT), datetime.strftime(datetime.now(), self.TIME_FORMAT), end_date, datetime.strftime(datetime.now()+timedelta(days=1), self.TIME_FORMAT))
-        if start_date == datetime.strftime(
-            datetime.now(), self.TIME_FORMAT
-        ) and end_date == datetime.strftime(
-            datetime.now() + timedelta(days=1), self.TIME_FORMAT
-        ):
-            """today"""
-            url = f"https://api.weatherbit.io/v2.0/current?city={city_name}&country={country_code}&key={self.api_key}"
-        else:
-            url = f"https://api.weatherbit.io/v2.0/history/daily?&city={city_name}&country={country_code}&start_date={start_date}&end_date={end_date}&key={self.api_key}"
-        response = requests.get(url)
-        data = response.json()
-        return self._parse(data)
-
-    def func(self, weather_dict: Dict) -> Dict:
-        TIME_FORMAT = self.TIME_FORMAT
-        # Beijing, Shanghai
-        city_name = weather_dict["city_name"]
-        # CN, US
-        country_code = weather_dict["country_code"]
-        # 2020-02-02
-        start_date = datetime.strftime(
-            datetime.strptime(weather_dict["start_date"], self.TIME_FORMAT),
-            self.TIME_FORMAT,
-        )
-        end_date = weather_dict["end_date"] if "end_date" in weather_dict else None
-        if end_date is None:
-            end_date = datetime.strftime(
-                datetime.strptime(start_date, TIME_FORMAT) + timedelta(days=-1),
-                TIME_FORMAT,
-            )
-        else:
-            end_date = datetime.strftime(
-                datetime.strptime(weather_dict["end_date"], self.TIME_FORMAT),
-                self.TIME_FORMAT,
-            )
-        if datetime.strptime(start_date, TIME_FORMAT) > datetime.strptime(
-            end_date, TIME_FORMAT
-        ):
-            start_date, end_date = end_date, start_date
-        assert start_date != end_date
-        return self._query(city_name, country_code, start_date, end_date)
-
-
-class TranslateComponent(ToolComponent):
-    __SUPPORT_LANGUAGE__ = [
-        "af",
-        "am",
-        "ar",
-        "as",
-        "az",
-        "ba",
-        "bg",
-        "bn",
-        "bo",
-        "bs",
-        "ca",
-        "cs",
-        "cy",
-        "da",
-        "de",
-        "dsb",
-        "dv",
-        "el",
-        "en",
-        "es",
-        "et",
-        "eu",
-        "fa",
-        "fi",
-        "fil",
-        "fj",
-        "fo",
-        "fr",
-        "fr-CA",
-        "ga",
-        "gl",
-        "gom",
-        "gu",
-        "ha",
-        "he",
-        "hi",
-        "hr",
-        "hsb",
-        "ht",
-        "hu",
-        "hy",
-        "id",
-        "ig",
-        "ikt",
-        "is",
-        "it",
-        "iu",
-        "iu-Latn",
-        "ja",
-        "ka",
-        "kk",
-        "km",
-        "kmr",
-        "kn",
-        "ko",
-        "ku",
-        "ky",
-        "ln",
-        "lo",
-        "lt",
-        "lug",
-        "lv",
-        "lzh",
-        "mai",
-        "mg",
-        "mi",
-        "mk",
-        "ml",
-        "mn-Cyrl",
-        "mn-Mong",
-        "mr",
-        "ms",
-        "mt",
-        "mww",
-        "my",
-        "nb",
-        "ne",
-        "nl",
-        "nso",
-        "nya",
-        "or",
-        "otq",
-        "pa",
-        "pl",
-        "prs",
-        "ps",
-        "pt",
-        "pt-PT",
-        "ro",
-        "ru",
-        "run",
-        "rw",
-        "sd",
-        "si",
-        "sk",
-        "sl",
-        "sm",
-        "sn",
-        "so",
-        "sq",
-        "sr-Cyrl",
-        "sr-Latn",
-        "st",
-        "sv",
-        "sw",
-        "ta",
-        "te",
-        "th",
-        "ti",
-        "tk",
-        "tlh-Latn",
-        "tlh-Piqd",
-        "tn",
-        "to",
-        "tr",
-        "tt",
-        "ty",
-        "ug",
-        "uk",
-        "ur",
-        "uz",
-        "vi",
-        "xh",
-        "yo",
-        "yua",
-        "yue",
-        "zh-Hans",
-        "zh-Hant",
-        "zu",
-    ]
-
-    def __init__(
-        self, api_key, location, default_target_language="zh-cn", name="translate"
-    ):
-        super(TranslateComponent, self).__init__(name)
-        self.name = name
-        self.api_key = api_key
-        self.location = location
-        self.default_target_language = default_target_language
-
-    def func(self, translate_dict: Dict) -> Dict:
-        content = translate_dict["content"]
-        target_language = self.default_target_language
-        if "target_language" in translate_dict:
-            target_language = translate_dict["target_language"]
-        assert (
-            target_language in self.__SUPPORT_LANGUAGE__
-        ), f"language `{target_language}` is not supported."
-
-        endpoint = "https://api.cognitive.microsofttranslator.com"
-
-        path = "/translate"
-        constructed_url = endpoint + path
-
-        params = {"api-version": "3.0", "to": target_language}
-
-        headers = {
-            "Ocp-Apim-Subscription-Key": self.api_key,
-            "Ocp-Apim-Subscription-Region": self.location,
-            "Content-type": "application/json",
-            "X-ClientTraceId": str(uuid.uuid4()),
-        }
-
-        body = [{"text": content}]
-
-        request = requests.post(
-            constructed_url, params=params, headers=headers, json=body
-        )
-        response = request.json()
-        response = json.dumps(
-            response,
-            sort_keys=True,
-            ensure_ascii=False,
-            indent=4,
-            separators=(",", ": "),
-        )
-        response = eval(response)
-        return {"result": response[0]["translations"][0]["text"]}
-
-
-class APIComponent(ToolComponent):
-    def __init__(self):
-        super(APIComponent, self).__init__()
-
-    def func(self, agent) -> Dict:
-        pass
-
-
-class FunctionComponent(ToolComponent):
-    def __init__(
-        self,
-        functions,
-        function_call="auto",
-        response_type="response",
-        your_function=None,
-    ):
-        super().__init__()
-        self.functions = functions
-        self.function_call = function_call
-        self.parameters = {}
-        self.available_functions = {}
-        self.response_type = response_type
-        if your_function:
-            function_name = your_function["name"]
-            function_content = your_function["content"]
-            exec(function_content)
-            self.available_functions[function_name] = eval(function_name)
-
-        for function in self.functions:
-            self.parameters[function["name"]] = list(
-                function["parameters"]["properties"].keys()
-            )
-            self.available_functions[function["name"]] = eval(function["name"])
-
-    def func(self, agent):
-        messages = agent.long_term_memory
-        outputdict = {}
-        query = agent.long_term_memory[-1].content if len(agent.long_term_memory) > 0 else " "
-        relevant_history = get_relevant_history(
-            query,
-            agent.long_term_memory[:-1],
-            agent.chat_embeddings[:-1],
-        )
-        response = agent.LLM.get_response(
-            messages,
-            None,
-            functions=self.functions,
-            stream=False,
-            function_call=self.function_call,
-            relevant_history=relevant_history,
-        )
-        response_message = response
-        if response_message.get("function_call"):
-            function_name = response_message["function_call"]["name"]
-            fuction_to_call = self.available_functions[function_name]
-            function_args = json.loads(response_message["function_call"]["arguments"])
-            input_args = {}
-            for args_name in self.parameters[function_name]:
-                input_args[args_name] = function_args.get(args_name)
-            function_response = fuction_to_call(**input_args)
-            if self.response_type == "response":
-                outputdict["response"] = function_response
-            elif self.response_type == "prompt":
-                outputdict["prompt"] = function_response
-
-        return outputdict
-
-
-class CodeComponent(ToolComponent):
-    def __init__(self, file_name, keyword) -> None:
-        super().__init__()
-        self.file_name = file_name
-        self.keyword = keyword
-        self.system_prompt = (
-            "you need to extract the modified code as completely as possible."
-        )
-        self.last_prompt = (
-            f"Please strictly adhere to the following format for outputting: \n"
-        )
-        self.last_prompt += (
-            f"<{self.keyword}> the content you need to extract </{self.keyword}>"
-        )
-
-    def func(self, agent):
-        response = agent.LLM.get_response(
-            agent.long_term_memory,
-            self.system_prompt,
-            self.last_prompt,
-            stream=False,
-        )
-        code = extract(response, self.keyword)
-        code = code if code else response
-        os.makedirs("output_code", exist_ok=True)
-        file_name = "output_code/" + self.file_name
-        codes = code.split("\n")
-        if codes[0] == "```python":
-            codes.remove(codes[0])
-        if codes[-1] == "```":
-            codes.remove(codes[-1])
-        code = "\n".join(codes)
-        with open(file_name, "w", encoding="utf-8") as f:
-            f.write(code)
-        return {}

spaces/Abeer123/Pokemon_Digimon/README.md

@@ -1,13 +0,0 @@
----
-title: Pokemon Digimon
-emoji: 💻
-colorFrom: gray
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.11.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/AchyuthGamer/OpenGPT/g4f/Provider/Equing.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-import json
-from abc import ABC, abstractmethod
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class Equing(BaseProvider):
-    url: str              = 'https://next.eqing.tech/'
-    working               = False
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-    supports_gpt_4        = False
-
-    @staticmethod
-    @abstractmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-
-        headers = {
-            'authority'         : 'next.eqing.tech',
-            'accept'            : 'text/event-stream',
-            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
-            'cache-control'     : 'no-cache',
-            'content-type'      : 'application/json',
-            'origin'            : 'https://next.eqing.tech',
-            'plugins'           : '0',
-            'pragma'            : 'no-cache',
-            'referer'           : 'https://next.eqing.tech/',
-            'sec-ch-ua'         : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"',
-            'sec-ch-ua-mobile'  : '?0',
-            'sec-ch-ua-platform': '"macOS"',
-            'sec-fetch-dest'    : 'empty',
-            'sec-fetch-mode'    : 'cors',
-            'sec-fetch-site'    : 'same-origin',
-            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
-            'usesearch'         : 'false',
-            'x-requested-with'  : 'XMLHttpRequest'
-        }
-
-        json_data = {
-            'messages'          : messages,
-            'stream'            : stream,
-            'model'             : model,
-            'temperature'       : kwargs.get('temperature', 0.5),
-            'presence_penalty'  : kwargs.get('presence_penalty', 0),
-            'frequency_penalty' : kwargs.get('frequency_penalty', 0),
-            'top_p'             : kwargs.get('top_p', 1),
-        }
-
-        response = requests.post('https://next.eqing.tech/api/openai/v1/chat/completions',
-            headers=headers, json=json_data, stream=stream)
-        
-        if not stream:
-            yield response.json()["choices"][0]["message"]["content"]
-            return
-        
-        for line in response.iter_content(chunk_size=1024):
-            if line:
-                if b'content' in line:
-                        line_json = json.loads(line.decode('utf-8').split('data: ')[1])
-                        token = line_json['choices'][0]['delta'].get('content')
-                        if token:
-                            yield token
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"

spaces/AgentVerse/agentVerse/ui/.github/CODE_OF_CONDUCT.md

@@ -1,84 +0,0 @@
-# Code of Conduct
-
-## 1. Purpose
-
-A primary goal of Phaser is to be inclusive to the largest number of contributors, with the most varied and diverse backgrounds possible. As such, we are committed to providing a friendly, safe and welcoming environment for all, regardless of gender, sexual orientation, ability, ethnicity, socioeconomic status, and religion (or lack thereof).
-
-This code of conduct outlines our expectations for all those who participate in our community, as well as the consequences for unacceptable behavior.
-
-We invite all those who participate in Phaser to help us create safe and positive experiences for everyone.
-
-## 2. Open Source Citizenship
-
-A supplemental goal of this Code of Conduct is to increase open source citizenship by encouraging participants to recognize and strengthen the relationships between our actions and their effects on our community.
-
-Communities mirror the societies in which they exist and positive action is essential to counteract the many forms of inequality and abuses of power that exist in society.
-
-If you see someone who is making an extra effort to ensure our community is welcoming, friendly, and encourages all participants to contribute to the fullest extent, we want to know.
-
-## 3. Expected Behavior
-
-The following behaviors are expected and requested of all community members:
-
-*   Participate in an authentic and active way. In doing so, you contribute to the health and longevity of this community.
-*   Exercise consideration and respect in your speech and actions.
-*   Attempt collaboration before conflict.
-*   Refrain from demeaning, discriminatory, or harassing behavior and speech.
-*   Be mindful of your surroundings and of your fellow participants. Alert community leaders if you notice a dangerous situation, someone in distress, or violations of this Code of Conduct, even if they seem inconsequential.
-*   Remember that community event venues may be shared with members of the public; please be respectful to all patrons of these locations.
-
-## 4. Unacceptable Behavior
-
-The following behaviors are considered harassment and are unacceptable within our community:
-
-*   Violence, threats of violence or violent language directed against another person.
-*   Sexist, racist, homophobic, transphobic, ableist or otherwise discriminatory jokes and language.
-*   Posting or displaying sexually explicit or violent material.
-*   Posting or threatening to post other people’s personally identifying information ("doxing").
-*   Personal insults, particularly those related to gender, sexual orientation, race, religion, or disability.
-*   Inappropriate photography or recording.
-*   Inappropriate physical contact. You should have someone’s consent before touching them.
-*   Unwelcome sexual attention. This includes, sexualized comments or jokes; inappropriate touching, groping, and unwelcomed sexual advances.
-*   Deliberate intimidation, stalking or following (online or in person).
-*   Advocating for, or encouraging, any of the above behavior.
-*   Sustained disruption of community events, including talks and presentations.
-
-## 5. Consequences of Unacceptable Behavior
-
-Unacceptable behavior from any community member, including sponsors and those with decision-making authority, will not be tolerated.
-
-Anyone asked to stop unacceptable behavior is expected to comply immediately.
-
-If a community member engages in unacceptable behavior, the community organizers may take any action they deem appropriate, up to and including a temporary ban or permanent expulsion from the community without warning (and without refund in the case of a paid event).
-
-## 6. Reporting Guidelines
-
-If you are subject to or witness unacceptable behavior, or have any other concerns, please notify a community organizer as soon as possible. [email protected].
-
-
-
-Additionally, community organizers are available to help community members engage with local law enforcement or to otherwise help those experiencing unacceptable behavior feel safe. In the context of in-person events, organizers will also provide escorts as desired by the person experiencing distress.
-
-## 7. Addressing Grievances
-
-If you feel you have been falsely or unfairly accused of violating this Code of Conduct, you should notify Photon Storm Ltd with a concise description of your grievance. Your grievance will be handled in accordance with our existing governing policies.
-
-
-
-## 8. Scope
-
-We expect all community participants (contributors, paid or otherwise; sponsors; and other guests) to abide by this Code of Conduct in all community venues–online and in-person–as well as in all one-on-one communications pertaining to community business.
-
-This code of conduct and its related procedures also applies to unacceptable behavior occurring outside the scope of community activities when such behavior has the potential to adversely affect the safety and well-being of community members.
-
-## 9. Contact info
-
-[email protected]
-
-## 10. License and attribution
-
-This Code of Conduct is distributed under a [Creative Commons Attribution-ShareAlike license](http://creativecommons.org/licenses/by-sa/3.0/).
-
-Portions of text derived from the [Django Code of Conduct](https://www.djangoproject.com/conduct/) and the [Geek Feminism Anti-Harassment Policy](http://geekfeminism.wikia.com/wiki/Conference_anti-harassment/Policy).
-
-Retrieved on November 22, 2016 from [http://citizencodeofconduct.org/](http://citizencodeofconduct.org/)

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

@@ -1,39 +0,0 @@
-import Audio from './audio/Audio';
-import Ball from './ball/Ball';
-import Bars from './bars/Bars';
-import Box from './box/Box';
-import Clock from './clock/Clock';
-import Cube from './cube/Cube';
-import Custom from './custom/Custom';
-import Dots from './dots/Dots';
-import Facebook from './facebook/Facebook';
-import Grid from './grid/Grid';
-import Los from './los/Los';
-import Orbit from './orbit/Orbit';
-import Oval from './oval/Oval';
-import Pie from './pie/Pie';
-import Puff from './puff/Puff';
-import Radio from './radio/Radio';
-import Rings from './rings/Rings';
-import Spinner from './spinner/Spinner';
-
-export {
-    Audio,
-    Ball,
-    Bars,
-    Box,
-    Clock,
-    Cube,
-    Custom,
-    Dots,
-    Facebook,
-    Grid,
-    Los,
-    Orbit,
-    Oval,
-    Pie,
-    Puff,
-    Radio,
-    Rings,
-    Spinner
-}

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

@@ -1,413 +0,0 @@
-# Copyright 2023 Katherine Crowson and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import math
-import warnings
-from dataclasses import dataclass
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import torch
-from scipy import integrate
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from ..utils import BaseOutput
-from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin
-
-
-@dataclass
-# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->LMSDiscrete
-class LMSDiscreteSchedulerOutput(BaseOutput):
-    """
-    Output class for the scheduler's step function output.
-
-    Args:
-        prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
-            Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the
-            denoising loop.
-        pred_original_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
-            The predicted denoised sample (x_{0}) based on the model output from the current timestep.
-            `pred_original_sample` can be used to preview progress or for guidance.
-    """
-
-    prev_sample: torch.FloatTensor
-    pred_original_sample: Optional[torch.FloatTensor] = None
-
-
-# Copied from diffusers.schedulers.scheduling_ddpm.betas_for_alpha_bar
-def betas_for_alpha_bar(
-    num_diffusion_timesteps,
-    max_beta=0.999,
-    alpha_transform_type="cosine",
-):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
-    (1-beta) over time from t = [0,1].
-
-    Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
-    to that part of the diffusion process.
-
-
-    Args:
-        num_diffusion_timesteps (`int`): the number of betas to produce.
-        max_beta (`float`): the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-        alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar.
-                     Choose from `cosine` or `exp`
-
-    Returns:
-        betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
-    """
-    if alpha_transform_type == "cosine":
-
-        def alpha_bar_fn(t):
-            return math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2
-
-    elif alpha_transform_type == "exp":
-
-        def alpha_bar_fn(t):
-            return math.exp(t * -12.0)
-
-    else:
-        raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}")
-
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar_fn(t2) / alpha_bar_fn(t1), max_beta))
-    return torch.tensor(betas, dtype=torch.float32)
-
-
-class LMSDiscreteScheduler(SchedulerMixin, ConfigMixin):
-    """
-    Linear Multistep Scheduler for discrete beta schedules. Based on the original k-diffusion implementation by
-    Katherine Crowson:
-    https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181
-
-    [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
-    function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
-    [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
-    [`~SchedulerMixin.from_pretrained`] functions.
-
-    Args:
-        num_train_timesteps (`int`): number of diffusion steps used to train the model.
-        beta_start (`float`): the starting `beta` value of inference.
-        beta_end (`float`): the final `beta` value.
-        beta_schedule (`str`):
-            the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
-            `linear` or `scaled_linear`.
-        trained_betas (`np.ndarray`, optional):
-            option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc.
-        use_karras_sigmas (`bool`, *optional*, defaults to `False`):
-            This parameter controls whether to use Karras sigmas (Karras et al. (2022) scheme) for step sizes in the
-            noise schedule during the sampling process. If True, the sigmas will be determined according to a sequence
-            of noise levels {σi} as defined in Equation (5) of the paper https://arxiv.org/pdf/2206.00364.pdf.
-        prediction_type (`str`, default `epsilon`, optional):
-            prediction type of the scheduler function, one of `epsilon` (predicting the noise of the diffusion
-            process), `sample` (directly predicting the noisy sample`) or `v_prediction` (see section 2.4
-            https://imagen.research.google/video/paper.pdf)
-        timestep_spacing (`str`, default `"linspace"`):
-            The way the timesteps should be scaled. Refer to Table 2. of [Common Diffusion Noise Schedules and Sample
-            Steps are Flawed](https://arxiv.org/abs/2305.08891) for more information.
-        steps_offset (`int`, default `0`):
-            an offset added to the inference steps. You can use a combination of `offset=1` and
-            `set_alpha_to_one=False`, to make the last step use step 0 for the previous alpha product, as done in
-            stable diffusion.
-    """
-
-    _compatibles = [e.name for e in KarrasDiffusionSchedulers]
-    order = 1
-
-    @register_to_config
-    def __init__(
-        self,
-        num_train_timesteps: int = 1000,
-        beta_start: float = 0.0001,
-        beta_end: float = 0.02,
-        beta_schedule: str = "linear",
-        trained_betas: Optional[Union[np.ndarray, List[float]]] = None,
-        use_karras_sigmas: Optional[bool] = False,
-        prediction_type: str = "epsilon",
-        timestep_spacing: str = "linspace",
-        steps_offset: int = 0,
-    ):
-        if trained_betas is not None:
-            self.betas = torch.tensor(trained_betas, dtype=torch.float32)
-        elif beta_schedule == "linear":
-            self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)
-        elif beta_schedule == "scaled_linear":
-            # this schedule is very specific to the latent diffusion model.
-            self.betas = (
-                torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2
-            )
-        elif beta_schedule == "squaredcos_cap_v2":
-            # Glide cosine schedule
-            self.betas = betas_for_alpha_bar(num_train_timesteps)
-        else:
-            raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
-
-        self.alphas = 1.0 - self.betas
-        self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
-
-        sigmas = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5)
-        sigmas = np.concatenate([sigmas[::-1], [0.0]]).astype(np.float32)
-        self.sigmas = torch.from_numpy(sigmas)
-
-        # setable values
-        self.num_inference_steps = None
-        self.use_karras_sigmas = use_karras_sigmas
-        self.set_timesteps(num_train_timesteps, None)
-        self.derivatives = []
-        self.is_scale_input_called = False
-
-    @property
-    def init_noise_sigma(self):
-        # standard deviation of the initial noise distribution
-        if self.config.timestep_spacing in ["linspace", "trailing"]:
-            return self.sigmas.max()
-
-        return (self.sigmas.max() ** 2 + 1) ** 0.5
-
-    def scale_model_input(
-        self, sample: torch.FloatTensor, timestep: Union[float, torch.FloatTensor]
-    ) -> torch.FloatTensor:
-        """
-        Scales the denoising model input by `(sigma**2 + 1) ** 0.5` to match the K-LMS algorithm.
-
-        Args:
-            sample (`torch.FloatTensor`): input sample
-            timestep (`float` or `torch.FloatTensor`): the current timestep in the diffusion chain
-
-        Returns:
-            `torch.FloatTensor`: scaled input sample
-        """
-        if isinstance(timestep, torch.Tensor):
-            timestep = timestep.to(self.timesteps.device)
-        step_index = (self.timesteps == timestep).nonzero().item()
-        sigma = self.sigmas[step_index]
-        sample = sample / ((sigma**2 + 1) ** 0.5)
-        self.is_scale_input_called = True
-        return sample
-
-    def get_lms_coefficient(self, order, t, current_order):
-        """
-        Compute a linear multistep coefficient.
-
-        Args:
-            order (TODO):
-            t (TODO):
-            current_order (TODO):
-        """
-
-        def lms_derivative(tau):
-            prod = 1.0
-            for k in range(order):
-                if current_order == k:
-                    continue
-                prod *= (tau - self.sigmas[t - k]) / (self.sigmas[t - current_order] - self.sigmas[t - k])
-            return prod
-
-        integrated_coeff = integrate.quad(lms_derivative, self.sigmas[t], self.sigmas[t + 1], epsrel=1e-4)[0]
-
-        return integrated_coeff
-
-    def set_timesteps(self, num_inference_steps: int, device: Union[str, torch.device] = None):
-        """
-        Sets the timesteps used for the diffusion chain. Supporting function to be run before inference.
-
-        Args:
-            num_inference_steps (`int`):
-                the number of diffusion steps used when generating samples with a pre-trained model.
-            device (`str` or `torch.device`, optional):
-                the device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
-        """
-        self.num_inference_steps = num_inference_steps
-
-        # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
-        if self.config.timestep_spacing == "linspace":
-            timesteps = np.linspace(0, self.config.num_train_timesteps - 1, num_inference_steps, dtype=float)[
-                ::-1
-            ].copy()
-        elif self.config.timestep_spacing == "leading":
-            step_ratio = self.config.num_train_timesteps // self.num_inference_steps
-            # creates integer timesteps by multiplying by ratio
-            # casting to int to avoid issues when num_inference_step is power of 3
-            timesteps = (np.arange(0, num_inference_steps) * step_ratio).round()[::-1].copy().astype(float)
-            timesteps += self.config.steps_offset
-        elif self.config.timestep_spacing == "trailing":
-            step_ratio = self.config.num_train_timesteps / self.num_inference_steps
-            # creates integer timesteps by multiplying by ratio
-            # casting to int to avoid issues when num_inference_step is power of 3
-            timesteps = (np.arange(self.config.num_train_timesteps, 0, -step_ratio)).round().copy().astype(float)
-            timesteps -= 1
-        else:
-            raise ValueError(
-                f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."
-            )
-
-        sigmas = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5)
-        log_sigmas = np.log(sigmas)
-        sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas)
-
-        if self.use_karras_sigmas:
-            sigmas = self._convert_to_karras(in_sigmas=sigmas)
-            timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas])
-
-        sigmas = np.concatenate([sigmas, [0.0]]).astype(np.float32)
-
-        self.sigmas = torch.from_numpy(sigmas).to(device=device)
-        if str(device).startswith("mps"):
-            # mps does not support float64
-            self.timesteps = torch.from_numpy(timesteps).to(device, dtype=torch.float32)
-        else:
-            self.timesteps = torch.from_numpy(timesteps).to(device=device)
-
-        self.derivatives = []
-
-    # copied from diffusers.schedulers.scheduling_euler_discrete._sigma_to_t
-    def _sigma_to_t(self, sigma, log_sigmas):
-        # get log sigma
-        log_sigma = np.log(sigma)
-
-        # get distribution
-        dists = log_sigma - log_sigmas[:, np.newaxis]
-
-        # get sigmas range
-        low_idx = np.cumsum((dists >= 0), axis=0).argmax(axis=0).clip(max=log_sigmas.shape[0] - 2)
-        high_idx = low_idx + 1
-
-        low = log_sigmas[low_idx]
-        high = log_sigmas[high_idx]
-
-        # interpolate sigmas
-        w = (low - log_sigma) / (low - high)
-        w = np.clip(w, 0, 1)
-
-        # transform interpolation to time range
-        t = (1 - w) * low_idx + w * high_idx
-        t = t.reshape(sigma.shape)
-        return t
-
-    # copied from diffusers.schedulers.scheduling_euler_discrete._convert_to_karras
-    def _convert_to_karras(self, in_sigmas: torch.FloatTensor) -> torch.FloatTensor:
-        """Constructs the noise schedule of Karras et al. (2022)."""
-
-        sigma_min: float = in_sigmas[-1].item()
-        sigma_max: float = in_sigmas[0].item()
-
-        rho = 7.0  # 7.0 is the value used in the paper
-        ramp = np.linspace(0, 1, self.num_inference_steps)
-        min_inv_rho = sigma_min ** (1 / rho)
-        max_inv_rho = sigma_max ** (1 / rho)
-        sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
-        return sigmas
-
-    def step(
-        self,
-        model_output: torch.FloatTensor,
-        timestep: Union[float, torch.FloatTensor],
-        sample: torch.FloatTensor,
-        order: int = 4,
-        return_dict: bool = True,
-    ) -> Union[LMSDiscreteSchedulerOutput, Tuple]:
-        """
-        Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
-        process from the learned model outputs (most often the predicted noise).
-
-        Args:
-            model_output (`torch.FloatTensor`): direct output from learned diffusion model.
-            timestep (`float`): current timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-            order: coefficient for multi-step inference.
-            return_dict (`bool`): option for returning tuple rather than LMSDiscreteSchedulerOutput class
-
-        Returns:
-            [`~schedulers.scheduling_utils.LMSDiscreteSchedulerOutput`] or `tuple`:
-            [`~schedulers.scheduling_utils.LMSDiscreteSchedulerOutput`] if `return_dict` is True, otherwise a `tuple`.
-            When returning a tuple, the first element is the sample tensor.
-
-        """
-        if not self.is_scale_input_called:
-            warnings.warn(
-                "The `scale_model_input` function should be called before `step` to ensure correct denoising. "
-                "See `StableDiffusionPipeline` for a usage example."
-            )
-
-        if isinstance(timestep, torch.Tensor):
-            timestep = timestep.to(self.timesteps.device)
-        step_index = (self.timesteps == timestep).nonzero().item()
-        sigma = self.sigmas[step_index]
-
-        # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
-        if self.config.prediction_type == "epsilon":
-            pred_original_sample = sample - sigma * model_output
-        elif self.config.prediction_type == "v_prediction":
-            # * c_out + input * c_skip
-            pred_original_sample = model_output * (-sigma / (sigma**2 + 1) ** 0.5) + (sample / (sigma**2 + 1))
-        elif self.config.prediction_type == "sample":
-            pred_original_sample = model_output
-        else:
-            raise ValueError(
-                f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`"
-            )
-
-        # 2. Convert to an ODE derivative
-        derivative = (sample - pred_original_sample) / sigma
-        self.derivatives.append(derivative)
-        if len(self.derivatives) > order:
-            self.derivatives.pop(0)
-
-        # 3. Compute linear multistep coefficients
-        order = min(step_index + 1, order)
-        lms_coeffs = [self.get_lms_coefficient(order, step_index, curr_order) for curr_order in range(order)]
-
-        # 4. Compute previous sample based on the derivatives path
-        prev_sample = sample + sum(
-            coeff * derivative for coeff, derivative in zip(lms_coeffs, reversed(self.derivatives))
-        )
-
-        if not return_dict:
-            return (prev_sample,)
-
-        return LMSDiscreteSchedulerOutput(prev_sample=prev_sample, pred_original_sample=pred_original_sample)
-
-    # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler.add_noise
-    def add_noise(
-        self,
-        original_samples: torch.FloatTensor,
-        noise: torch.FloatTensor,
-        timesteps: torch.FloatTensor,
-    ) -> torch.FloatTensor:
-        # Make sure sigmas and timesteps have the same device and dtype as original_samples
-        sigmas = self.sigmas.to(device=original_samples.device, dtype=original_samples.dtype)
-        if original_samples.device.type == "mps" and torch.is_floating_point(timesteps):
-            # mps does not support float64
-            schedule_timesteps = self.timesteps.to(original_samples.device, dtype=torch.float32)
-            timesteps = timesteps.to(original_samples.device, dtype=torch.float32)
-        else:
-            schedule_timesteps = self.timesteps.to(original_samples.device)
-            timesteps = timesteps.to(original_samples.device)
-
-        step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
-
-        sigma = sigmas[step_indices].flatten()
-        while len(sigma.shape) < len(original_samples.shape):
-            sigma = sigma.unsqueeze(-1)
-
-        noisy_samples = original_samples + noise * sigma
-        return noisy_samples
-
-    def __len__(self):
-        return self.config.num_train_timesteps

spaces/Andy1621/uniformer_image_segmentation/configs/ocrnet/ocrnet_r101-d8_512x1024_40k_b8_cityscapes.py

@@ -1,5 +0,0 @@
-_base_ = [
-    '../_base_/models/ocrnet_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))

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

@@ -1,39 +0,0 @@
-import abc
-
-from pip._internal.index.package_finder import PackageFinder
-from pip._internal.metadata.base import BaseDistribution
-from pip._internal.req import InstallRequirement
-
-
-class AbstractDistribution(metaclass=abc.ABCMeta):
-    """A base class for handling installable artifacts.
-
-    The requirements for anything installable are as follows:
-
-     - we must be able to determine the requirement name
-       (or we can't correctly handle the non-upgrade case).
-
-     - for packages with setup requirements, we must also be able
-       to determine their requirements without installing additional
-       packages (for the same reason as run-time dependencies)
-
-     - we must be able to create a Distribution object exposing the
-       above metadata.
-    """
-
-    def __init__(self, req: InstallRequirement) -> None:
-        super().__init__()
-        self.req = req
-
-    @abc.abstractmethod
-    def get_metadata_distribution(self) -> BaseDistribution:
-        raise NotImplementedError()
-
-    @abc.abstractmethod
-    def prepare_distribution_metadata(
-        self,
-        finder: PackageFinder,
-        build_isolation: bool,
-        check_build_deps: bool,
-    ) -> None:
-        raise NotImplementedError()

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

@@ -1,146 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import re
-import string
-import urllib.parse
-from typing import List, Optional as TOptional, Set
-
-from pip._vendor.pyparsing import (  # noqa
-    Combine,
-    Literal as L,
-    Optional,
-    ParseException,
-    Regex,
-    Word,
-    ZeroOrMore,
-    originalTextFor,
-    stringEnd,
-    stringStart,
-)
-
-from .markers import MARKER_EXPR, Marker
-from .specifiers import LegacySpecifier, Specifier, SpecifierSet
-
-
-class InvalidRequirement(ValueError):
-    """
-    An invalid requirement was found, users should refer to PEP 508.
-    """
-
-
-ALPHANUM = Word(string.ascii_letters + string.digits)
-
-LBRACKET = L("[").suppress()
-RBRACKET = L("]").suppress()
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-COMMA = L(",").suppress()
-SEMICOLON = L(";").suppress()
-AT = L("@").suppress()
-
-PUNCTUATION = Word("-_.")
-IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
-IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
-
-NAME = IDENTIFIER("name")
-EXTRA = IDENTIFIER
-
-URI = Regex(r"[^ ]+")("url")
-URL = AT + URI
-
-EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
-EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
-
-VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
-VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
-
-VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
-VERSION_MANY = Combine(
-    VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
-)("_raw_spec")
-_VERSION_SPEC = Optional((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY)
-_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")
-
-VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
-VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
-
-MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
-MARKER_EXPR.setParseAction(
-    lambda s, l, t: Marker(s[t._original_start : t._original_end])
-)
-MARKER_SEPARATOR = SEMICOLON
-MARKER = MARKER_SEPARATOR + MARKER_EXPR
-
-VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
-URL_AND_MARKER = URL + Optional(MARKER)
-
-NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
-
-REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
-# pyparsing isn't thread safe during initialization, so we do it eagerly, see
-# issue #104
-REQUIREMENT.parseString("x[]")
-
-
-class Requirement:
-    """Parse a requirement.
-
-    Parse a given requirement string into its parts, such as name, specifier,
-    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
-    string.
-    """
-
-    # TODO: Can we test whether something is contained within a requirement?
-    #       If so how do we do that? Do we need to test against the _name_ of
-    #       the thing as well as the version? What about the markers?
-    # TODO: Can we normalize the name and extra name?
-
-    def __init__(self, requirement_string: str) -> None:
-        try:
-            req = REQUIREMENT.parseString(requirement_string)
-        except ParseException as e:
-            raise InvalidRequirement(
-                f'Parse error at "{ requirement_string[e.loc : e.loc + 8]!r}": {e.msg}'
-            )
-
-        self.name: str = req.name
-        if req.url:
-            parsed_url = urllib.parse.urlparse(req.url)
-            if parsed_url.scheme == "file":
-                if urllib.parse.urlunparse(parsed_url) != req.url:
-                    raise InvalidRequirement("Invalid URL given")
-            elif not (parsed_url.scheme and parsed_url.netloc) or (
-                not parsed_url.scheme and not parsed_url.netloc
-            ):
-                raise InvalidRequirement(f"Invalid URL: {req.url}")
-            self.url: TOptional[str] = req.url
-        else:
-            self.url = None
-        self.extras: Set[str] = set(req.extras.asList() if req.extras else [])
-        self.specifier: SpecifierSet = SpecifierSet(req.specifier)
-        self.marker: TOptional[Marker] = req.marker if req.marker else None
-
-    def __str__(self) -> str:
-        parts: List[str] = [self.name]
-
-        if self.extras:
-            formatted_extras = ",".join(sorted(self.extras))
-            parts.append(f"[{formatted_extras}]")
-
-        if self.specifier:
-            parts.append(str(self.specifier))
-
-        if self.url:
-            parts.append(f"@ {self.url}")
-            if self.marker:
-                parts.append(" ")
-
-        if self.marker:
-            parts.append(f"; {self.marker}")
-
-        return "".join(parts)
-
-    def __repr__(self) -> str:
-        return f"<Requirement('{self}')>"

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

@@ -1,19 +0,0 @@
-"""
-Timer context manager, only used in debug.
-
-"""
-
-from time import time
-
-import contextlib
-from typing import Generator
-
-
-@contextlib.contextmanager
-def timer(subject: str = "time") -> Generator[None, None, None]:
-    """print the elapsed time. (only used in debugging)"""
-    start = time()
-    yield
-    elapsed = time() - start
-    elapsed_ms = elapsed * 1000
-    print(f"{subject} elapsed {elapsed_ms:.1f}ms")

spaces/AtomdffAI/wechatgpt4atom/bot/bot.py

@@ -1,13 +0,0 @@
-"""
-Auto-replay chat robot abstract class
-"""
-
-
-class Bot(object):
-    def reply(self, query, context=None):
-        """
-        bot auto-reply content
-        :param req: received message
-        :return: reply content
-        """
-        raise NotImplementedError

spaces/Bart92/RVC_HF/i18n/scan_i18n.py

@@ -1,75 +0,0 @@
-import ast
-import glob
-import json
-from collections import OrderedDict
-
-
-def extract_i18n_strings(node):
-    i18n_strings = []
-
-    if (
-        isinstance(node, ast.Call)
-        and isinstance(node.func, ast.Name)
-        and node.func.id == "i18n"
-    ):
-        for arg in node.args:
-            if isinstance(arg, ast.Str):
-                i18n_strings.append(arg.s)
-
-    for child_node in ast.iter_child_nodes(node):
-        i18n_strings.extend(extract_i18n_strings(child_node))
-
-    return i18n_strings
-
-
-# scan the directory for all .py files (recursively)
-# for each file, parse the code into an AST
-# for each AST, extract the i18n strings
-
-strings = []
-for filename in glob.iglob("**/*.py", recursive=True):
-    with open(filename, "r") as f:
-        code = f.read()
-        if "I18nAuto" in code:
-            tree = ast.parse(code)
-            i18n_strings = extract_i18n_strings(tree)
-            print(filename, len(i18n_strings))
-            strings.extend(i18n_strings)
-code_keys = set(strings)
-"""
-n_i18n.py
-gui_v1.py 26
-app.py 16
-infer-web.py 147
-scan_i18n.py 0
-i18n.py 0
-lib/train/process_ckpt.py 1
-"""
-print()
-print("Total unique:", len(code_keys))
-
-
-standard_file = "i18n/locale/zh_CN.json"
-with open(standard_file, "r", encoding="utf-8") as f:
-    standard_data = json.load(f, object_pairs_hook=OrderedDict)
-standard_keys = set(standard_data.keys())
-
-# Define the standard file name
-unused_keys = standard_keys - code_keys
-print("Unused keys:", len(unused_keys))
-for unused_key in unused_keys:
-    print("\t", unused_key)
-
-missing_keys = code_keys - standard_keys
-print("Missing keys:", len(missing_keys))
-for missing_key in missing_keys:
-    print("\t", missing_key)
-
-code_keys_dict = OrderedDict()
-for s in strings:
-    code_keys_dict[s] = s
-
-# write back
-with open(standard_file, "w", encoding="utf-8") as f:
-    json.dump(code_keys_dict, f, ensure_ascii=False, indent=4, sort_keys=True)
-    f.write("\n")

spaces/Benson/text-generation/Examples/Descargar Amp Letras De Fuera De Mi Vientre Por Prospa Ochimana.md

@@ -1,56 +0,0 @@
-
-<h1>Descargar & Letras de Fuera de mi vientre por Prospa Ochimana</h1>
-<p>¿Estás buscando una poderosa e inspiradora canción gospel que despierte tu espíritu y te llene de alegría? Si es así, entonces deberías escuchar Out of My Belly de Prospa Ochimana. Esta canción es una obra maestra que bendecirá tu vida y te acercará a Dios.</p>
-<p>En este artículo, te diremos todo lo que necesitas saber sobre esta canción, incluyendo cómo descargarla, cuáles son las letras, y cuál es el significado detrás de ellas. ¡Vamos a empezar! </p>
-<h2>descargar amp; letras de fuera de mi vientre por prospa ochimana</h2><br /><p><b><b>Download File</b> ->>> <a href="https://bltlly.com/2v6MLe">https://bltlly.com/2v6MLe</a></b></p><br /><br />
- <h2>¿Qué está fuera de mi vientre acerca de? </h2>
-<p>Fuera de mi vientre es una canción que expresa el deseo de liberar el río de agua viva que fluye desde dentro de cada creyente. La canción está basada en las palabras de Jesús en Juan 7:38, donde dijo, "El que cree en Mí, como la Escritura ha dicho, de su corazón fluirán ríos de agua viva." </p>
-<p>La canción declara que cada vez que este río fluye, la vida se libera. Cada cosa muerta vuelve a la vida a medida que hacen contacto con este río. Es un río que da vida que sana, entrega, restaura y transforma. La canción también invita a todos los que tienen sed a venir a Jesús y beber de este río. </p>
- <h2>¿Quién es Prospa Ochimana? </h2>
-<p>Prospa Ochimana es un cantante de gospel y compositor nigeriano que es conocido por ser un adorador. También es el CEO de Tornveil Music International, un sello discográfico gospel en Nigeria que abrió en enero de 2020. </p>
-<p>Prospa Ochimana proviene de la tribu Ankpa, estado de Kogi, Nigeria, pero actualmente vive en Abuja. Nació el 6 de noviembre y se graduó de la Universidad Estatal de Nasarawa, Keffi, donde obtuvo un título en Lingüística.</p>
-
- <h2>¿Por qué es popular Fuera de mi vientre? </h2>
-<p>Out of My Belly es una de las canciones más populares de Prospa Ochimana. Fue lanzado en noviembre de 2020 y desde entonces ha ganado millones de visitas y descargas en línea. La canción también ha sido interpretada en vivo en varios eventos y conciertos por Prospa Ochimana y otros cantantes de gospel. </p>
-<p>La razón por la que esta canción es popular es porque resuena con muchas personas que tienen hambre de más de Dios y Su presencia. La canción también inspira a la gente a aprovechar su potencial y propósito como vasos de la gloria de Dios. La canción también tiene una melodía pegadiza y un mensaje poderoso que eleva y anima a los oyentes. </p>
-<p></p>
- <h2>¿Dónde se puede descargar Fuera de mi vientre? </h2>
-<p>Si quieres descargar Out of My Belly de Prospa Ochimana, tienes varias opciones para elegir. Puede descargarlo desde su sitio web oficial , o desde otras plataformas como YouTube , Spotify , Apple Music , Amazon Music , y más. </p>
-<h2>¿Cuáles son los beneficios de descargar Out of My Belly? </h2>
-<p>Descargar Out of My Belly de Prospa Ochimana tiene muchos beneficios para ti como oyente. Algunos de ellos son:</p>
-<ul>
-<li>Puedes escuchar la canción sin conexión en cualquier momento y en cualquier lugar que quieras. </li>
-<li>Puedes disfrutar del audio y video de alta calidad de la canción. </li>
-<li>Puedes compartir la canción con tus amigos y familiares a través de las redes sociales u otros medios. </li>
-<li>Puedes apoyar al artista y su ministerio comprando su música. </li>
-<li>Puedes experimentar el poder y la presencia de Dios mientras escuchas la canción. </li>
-</ul>
- <h2>¿Cuáles son las letras de Fuera de mi vientre? </h2>
-<p>Las letras de Fuera de mi vientre por Prospa Ochimana son las siguientes:</p>
-<código>
-
- <h2>¿Cuál es el significado de la letra? </h2>
-<p>El significado de las letras de Out of My Belly de Prospa Ochimana es que cada creyente tiene una fuente de vida y poder dentro de ellos, que es el Espíritu Santo. El Espíritu Santo es el río que fluye de dentro de nosotros y nos da todo lo que necesitamos. Él es quien nos sana, nos libera, nos restaura y nos transforma. Él es también el que nos permite ser una bendición para los demás al liberar Su vida a través de nosotros. </p>
-<p>La canción también nos recuerda que necesitamos venir a Jesús y beber de Él si tenemos sed de más de Él. Él es la fuente de agua viva que satisface nuestros anhelos más profundos. Él es también el que nos invita a creer en Él y recibir Su promesa de ríos de agua viva que fluye de nuestros corazones. </p>
- <h2>¿Cómo puedes cantar junto con Out of My Belly? </h2>
-<p>Si quieres cantar junto con Out of My Belly de Prospa Ochimana, puedes seguir estos pasos:</p>
-<ol>
-<li>Descarga la canción desde cualquier plataforma que prefieras. </li>
-<li>Escucha la canción y aprende la melodía y la letra. </li>
-<li>Encuentra una versión de karaoke o instrumental de la canción en línea o crea la tuya propia usando una aplicación o software. </li>
-<li>Practica el canto junto con el karaoke o la versión instrumental hasta que lo domines. </li>
-<li>Canta junto con la canción original y disfruta! </li>
-</ol>
- <h2>Conclusión</h2>
-<p>En conclusión, Out of My Belly de Prospa Ochimana es una maravillosa canción gospel que te inspirará a liberar el río de agua viva que fluye desde tu interior. La canción es también un testimonio de cómo Dios puede usar a cualquiera que esté dispuesto a ser Su recipiente. La canción está disponible para su descarga en varias plataformas y tiene letras increíbles que transmiten un mensaje poderoso. Esperamos que haya disfrutado de este artículo y haya aprendido algo nuevo. Si lo hizo, por favor compártalo con sus amigos y familiares. Y no te olvides de descargar y cantar junto con Out of My Belly de Prospa Ochimana! </p>
- <h2>Preguntas frecuentes</h2>
-
- <h3>Q: ¿Cuándo fue liberado Out of My Belly? </h3>
-<p>A: Out of My Belly fue lanzado el 27 de noviembre de 2020. </p>
- <h3>Q: ¿Quién produjo Fuera de mi vientre? </h3>
-<p>A: Fuera de mi vientre fue producido por Sunny Pee.</p>
- <h3>P: ¿Cuántas visitas tiene Out of My Belly en YouTube? </h3>
-<p>A: A partir del 20 de junio de 2023, Out of My Belly tiene más de 20 de junio de 2023, Out of My Belly tiene más de 1.1 millones de visitas en YouTube. El video oficial de la canción fue subido por Prospa Ochimana el 27 de noviembre de 2020. El video muestra a Prospa Ochimana cantando la canción con una banda en vivo y un coro en un entorno de estudio. El video también tiene subtítulos para la letra de la canción. Puede ver el video aquí o haciendo clic en la imagen de abajo. <img src="( 1 )" alt="Fuera de mi vientre por Prospa Ochimana video de YouTube">
- También hay otras versiones de la canción en YouTube, como un video lírico y una presentación en vivo . Puedes echarles un vistazo si quieres ver diferentes formas de presentar la canción. Espero que hayas disfrutado de este artículo y hayas aprendido algo nuevo. Si lo hiciste, por favor compártelo con tus amigos y familiares. ¡Y no olvides descargar y cantar junto con Out of My Belly de Prospa Ochimana! </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BigChungux/Pet_Survey2/app.py

@@ -1,172 +0,0 @@
-### ----------------------------- ###
-###           libraries           ###
-### ----------------------------- ###
-
-import gradio as gr
-import pandas as pd
-import numpy as np
-from sklearn.model_selection import train_test_split
-from sklearn.linear_model import LogisticRegression
-from sklearn import metrics
-
-
-### ------------------------------ ###
-###       data transformation      ###
-### ------------------------------ ###
-
-# load dataset
-uncleaned_data = pd.read_csv('data.csv')
-
-# remove timestamp from dataset (always first column)
-uncleaned_data = uncleaned_data.iloc[: , 1:]
-data = pd.DataFrame()
-
-# keep track of which columns are categorical and what 
-# those columns' value mappings are
-# structure: {colname1: {...}, colname2: {...} }
-cat_value_dicts = {}
-final_colname = uncleaned_data.columns[len(uncleaned_data.columns) - 1]
-
-# for each column...
-for (colname, colval) in uncleaned_data.iteritems():
-
-  # check if col is already a number; if so, add col directly
-  # to new dataframe and skip to next column
-  if isinstance(colval.values[0], (np.integer, float)):
-    data[colname] = uncleaned_data[colname].copy()
-    continue
-
-  # structure: {0: "lilac", 1: "blue", ...}
-  new_dict = {}
-  val = 0 # first index per column
-  transformed_col_vals = [] # new numeric datapoints
-
-  # if not, for each item in that column...
-  for (row, item) in enumerate(colval.values):
-    
-    # if item is not in this col's dict...
-    if item not in new_dict:
-      new_dict[item] = val
-      val += 1
-    
-    # then add numerical value to transformed dataframe
-    transformed_col_vals.append(new_dict[item])
-  
-  # reverse dictionary only for final col (0, 1) => (vals)
-  if colname == final_colname:
-    new_dict = {value : key for (key, value) in new_dict.items()}
-
-  cat_value_dicts[colname] = new_dict
-  data[colname] = transformed_col_vals
-
-
-### -------------------------------- ###
-###           model training         ###
-### -------------------------------- ###
-
-# select features and predicton; automatically selects last column as prediction
-cols = len(data.columns)
-num_features = cols - 1
-x = data.iloc[: , :num_features]
-y = data.iloc[: , num_features:]
-
-# split data into training and testing sets
-x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
-
-# instantiate the model (using default parameters)
-model = LogisticRegression()
-model.fit(x_train, y_train.values.ravel())
-y_pred = model.predict(x_test)
-
-
-### -------------------------------- ###
-###        article generation        ###
-### -------------------------------- ###
-# borrow file reading function from reader.py
-
-def get_feat():
-  feats = [abs(x) for x in model.coef_[0]]
-  max_val = max(feats)
-  idx = feats.index(max_val)
-  return data.columns[idx]
-  
-acc = str(round(metrics.accuracy_score(y_test, y_pred) * 100, 1)) + "%"
-most_imp_feat = get_feat()
-# info = get_article(acc, most_imp_feat)
-
-
-
-### ------------------------------- ###
-###        interface creation       ###
-### ------------------------------- ###
-
-
-# predictor for generic number of features
-def general_predictor(*args):
-  features = []
-
-  # transform categorical input
-  for colname, arg in zip(data.columns, args):
-    if (colname in cat_value_dicts):
-      features.append(cat_value_dicts[colname][arg])
-    else:
-      features.append(arg)
-
-  # predict single datapoint
-  new_input = [features]
-  result = model.predict(new_input)
-  return cat_value_dicts[final_colname][result[0]]
-
-# add data labels to replace those lost via star-args
-
-
-block = gr.Blocks()
-
-with open('info.md') as f:
-  with block:
-    gr.Markdown(f.readline())
-    gr.Markdown('Take the quiz to get a personalized recommendation using AI.')
-    
-    with gr.Row():
-      with gr.Box():
-        inputls = []
-        for colname in data.columns:
-          # skip last column
-          if colname == final_colname:
-            continue
-          
-          # access categories dict if data is categorical
-          # otherwise, just use a number input
-          if colname in cat_value_dicts:
-            radio_options = list(cat_value_dicts[colname].keys())
-            inputls.append(gr.inputs.Dropdown(choices=radio_options, type="value", label=colname))
-          else:
-            # add numerical input
-            inputls.append(gr.inputs.Number(label=colname))
-          gr.Markdown("<br />")
-        
-        submit = gr.Button("Click to see your personalized result!", variant="primary")
-        gr.Markdown("<br />")
-        output = gr.Textbox(label="Your recommendation:", placeholder="your recommendation will appear here")
-        
-        submit.click(fn=general_predictor, inputs=inputls, outputs=output)
-        gr.Markdown("<br />")
-        
-        with gr.Row():
-          with gr.Box():
-            gr.Markdown(f"<h3>Accuracy: </h3>{acc}")
-          with gr.Box():
-            gr.Markdown(f"<h3>Most important feature: </h3>{most_imp_feat}")
-        
-        gr.Markdown("<br />")
-        
-        with gr.Box():
-          gr.Markdown('''⭐ Note that model accuracy is based on the uploaded data.csv and reflects how well the AI model can give correct recommendations for <em>that dataset</em>. Model accuracy and most important feature can be helpful for understanding how the model works, but <em>should not be considered absolute facts about the real world</em>.''')
-        
-      with gr.Box():
-        with open('info.md') as f:
-          f.readline()
-          gr.Markdown(f.read())
-
-# show the interface
-block.launch()

spaces/Billyosoro/ESRGAN/realesrgan/utils.py

@@ -1,280 +0,0 @@
-import cv2
-import math
-import numpy as np
-import os
-import queue
-import threading
-import torch
-from basicsr.utils.download_util import load_file_from_url
-from torch.nn import functional as F
-
-ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-
-class RealESRGANer():
-    """A helper class for upsampling images with RealESRGAN.
-
-    Args:
-        scale (int): Upsampling scale factor used in the networks. It is usually 2 or 4.
-        model_path (str): The path to the pretrained model. It can be urls (will first download it automatically).
-        model (nn.Module): The defined network. Default: None.
-        tile (int): As too large images result in the out of GPU memory issue, so this tile option will first crop
-            input images into tiles, and then process each of them. Finally, they will be merged into one image.
-            0 denotes for do not use tile. Default: 0.
-        tile_pad (int): The pad size for each tile, to remove border artifacts. Default: 10.
-        pre_pad (int): Pad the input images to avoid border artifacts. Default: 10.
-        half (float): Whether to use half precision during inference. Default: False.
-    """
-
-    def __init__(self, scale, model_path, model=None, tile=0, tile_pad=10, pre_pad=10, half=False):
-        self.scale = scale
-        self.tile_size = tile
-        self.tile_pad = tile_pad
-        self.pre_pad = pre_pad
-        self.mod_scale = None
-        self.half = half
-
-        # initialize model
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        # if the model_path starts with https, it will first download models to the folder: realesrgan/weights
-        if model_path.startswith('https://'):
-            model_path = load_file_from_url(
-                url=model_path, model_dir=os.path.join(ROOT_DIR, 'realesrgan/weights'), progress=True, file_name=None)
-        loadnet = torch.load(model_path, map_location=torch.device('cpu'))
-        # prefer to use params_ema
-        if 'params_ema' in loadnet:
-            keyname = 'params_ema'
-        else:
-            keyname = 'params'
-        model.load_state_dict(loadnet[keyname], strict=True)
-        model.eval()
-        self.model = model.to(self.device)
-        if self.half:
-            self.model = self.model.half()
-
-    def pre_process(self, img):
-        """Pre-process, such as pre-pad and mod pad, so that the images can be divisible
-        """
-        img = torch.from_numpy(np.transpose(img, (2, 0, 1))).float()
-        self.img = img.unsqueeze(0).to(self.device)
-        if self.half:
-            self.img = self.img.half()
-
-        # pre_pad
-        if self.pre_pad != 0:
-            self.img = F.pad(self.img, (0, self.pre_pad, 0, self.pre_pad), 'reflect')
-        # mod pad for divisible borders
-        if self.scale == 2:
-            self.mod_scale = 2
-        elif self.scale == 1:
-            self.mod_scale = 4
-        if self.mod_scale is not None:
-            self.mod_pad_h, self.mod_pad_w = 0, 0
-            _, _, h, w = self.img.size()
-            if (h % self.mod_scale != 0):
-                self.mod_pad_h = (self.mod_scale - h % self.mod_scale)
-            if (w % self.mod_scale != 0):
-                self.mod_pad_w = (self.mod_scale - w % self.mod_scale)
-            self.img = F.pad(self.img, (0, self.mod_pad_w, 0, self.mod_pad_h), 'reflect')
-
-    def process(self):
-        # model inference
-        self.output = self.model(self.img)
-
-    def tile_process(self):
-        """It will first crop input images to tiles, and then process each tile.
-        Finally, all the processed tiles are merged into one images.
-
-        Modified from: https://github.com/ata4/esrgan-launcher
-        """
-        batch, channel, height, width = self.img.shape
-        output_height = height * self.scale
-        output_width = width * self.scale
-        output_shape = (batch, channel, output_height, output_width)
-
-        # start with black image
-        self.output = self.img.new_zeros(output_shape)
-        tiles_x = math.ceil(width / self.tile_size)
-        tiles_y = math.ceil(height / self.tile_size)
-
-        # loop over all tiles
-        for y in range(tiles_y):
-            for x in range(tiles_x):
-                # extract tile from input image
-                ofs_x = x * self.tile_size
-                ofs_y = y * self.tile_size
-                # input tile area on total image
-                input_start_x = ofs_x
-                input_end_x = min(ofs_x + self.tile_size, width)
-                input_start_y = ofs_y
-                input_end_y = min(ofs_y + self.tile_size, height)
-
-                # input tile area on total image with padding
-                input_start_x_pad = max(input_start_x - self.tile_pad, 0)
-                input_end_x_pad = min(input_end_x + self.tile_pad, width)
-                input_start_y_pad = max(input_start_y - self.tile_pad, 0)
-                input_end_y_pad = min(input_end_y + self.tile_pad, height)
-
-                # input tile dimensions
-                input_tile_width = input_end_x - input_start_x
-                input_tile_height = input_end_y - input_start_y
-                tile_idx = y * tiles_x + x + 1
-                input_tile = self.img[:, :, input_start_y_pad:input_end_y_pad, input_start_x_pad:input_end_x_pad]
-
-                # upscale tile
-                try:
-                    with torch.no_grad():
-                        output_tile = self.model(input_tile)
-                except RuntimeError as error:
-                    print('Error', error)
-                print(f'\tTile {tile_idx}/{tiles_x * tiles_y}')
-
-                # output tile area on total image
-                output_start_x = input_start_x * self.scale
-                output_end_x = input_end_x * self.scale
-                output_start_y = input_start_y * self.scale
-                output_end_y = input_end_y * self.scale
-
-                # output tile area without padding
-                output_start_x_tile = (input_start_x - input_start_x_pad) * self.scale
-                output_end_x_tile = output_start_x_tile + input_tile_width * self.scale
-                output_start_y_tile = (input_start_y - input_start_y_pad) * self.scale
-                output_end_y_tile = output_start_y_tile + input_tile_height * self.scale
-
-                # put tile into output image
-                self.output[:, :, output_start_y:output_end_y,
-                            output_start_x:output_end_x] = output_tile[:, :, output_start_y_tile:output_end_y_tile,
-                                                                       output_start_x_tile:output_end_x_tile]
-
-    def post_process(self):
-        # remove extra pad
-        if self.mod_scale is not None:
-            _, _, h, w = self.output.size()
-            self.output = self.output[:, :, 0:h - self.mod_pad_h * self.scale, 0:w - self.mod_pad_w * self.scale]
-        # remove prepad
-        if self.pre_pad != 0:
-            _, _, h, w = self.output.size()
-            self.output = self.output[:, :, 0:h - self.pre_pad * self.scale, 0:w - self.pre_pad * self.scale]
-        return self.output
-
-    @torch.no_grad()
-    def enhance(self, img, outscale=None, alpha_upsampler='realesrgan'):
-        h_input, w_input = img.shape[0:2]
-        # img: numpy
-        img = img.astype(np.float32)
-        if np.max(img) > 256:  # 16-bit image
-            max_range = 65535
-            print('\tInput is a 16-bit image')
-        else:
-            max_range = 255
-        img = img / max_range
-        if len(img.shape) == 2:  # gray image
-            img_mode = 'L'
-            img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
-        elif img.shape[2] == 4:  # RGBA image with alpha channel
-            img_mode = 'RGBA'
-            alpha = img[:, :, 3]
-            img = img[:, :, 0:3]
-            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-            if alpha_upsampler == 'realesrgan':
-                alpha = cv2.cvtColor(alpha, cv2.COLOR_GRAY2RGB)
-        else:
-            img_mode = 'RGB'
-            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-
-        # ------------------- process image (without the alpha channel) ------------------- #
-        self.pre_process(img)
-        if self.tile_size > 0:
-            self.tile_process()
-        else:
-            self.process()
-        output_img = self.post_process()
-        output_img = output_img.data.squeeze().float().cpu().clamp_(0, 1).numpy()
-        output_img = np.transpose(output_img[[2, 1, 0], :, :], (1, 2, 0))
-        if img_mode == 'L':
-            output_img = cv2.cvtColor(output_img, cv2.COLOR_BGR2GRAY)
-
-        # ------------------- process the alpha channel if necessary ------------------- #
-        if img_mode == 'RGBA':
-            if alpha_upsampler == 'realesrgan':
-                self.pre_process(alpha)
-                if self.tile_size > 0:
-                    self.tile_process()
-                else:
-                    self.process()
-                output_alpha = self.post_process()
-                output_alpha = output_alpha.data.squeeze().float().cpu().clamp_(0, 1).numpy()
-                output_alpha = np.transpose(output_alpha[[2, 1, 0], :, :], (1, 2, 0))
-                output_alpha = cv2.cvtColor(output_alpha, cv2.COLOR_BGR2GRAY)
-            else:  # use the cv2 resize for alpha channel
-                h, w = alpha.shape[0:2]
-                output_alpha = cv2.resize(alpha, (w * self.scale, h * self.scale), interpolation=cv2.INTER_LINEAR)
-
-            # merge the alpha channel
-            output_img = cv2.cvtColor(output_img, cv2.COLOR_BGR2BGRA)
-            output_img[:, :, 3] = output_alpha
-
-        # ------------------------------ return ------------------------------ #
-        if max_range == 65535:  # 16-bit image
-            output = (output_img * 65535.0).round().astype(np.uint16)
-        else:
-            output = (output_img * 255.0).round().astype(np.uint8)
-
-        if outscale is not None and outscale != float(self.scale):
-            output = cv2.resize(
-                output, (
-                    int(w_input * outscale),
-                    int(h_input * outscale),
-                ), interpolation=cv2.INTER_LANCZOS4)
-
-        return output, img_mode
-
-
-class PrefetchReader(threading.Thread):
-    """Prefetch images.
-
-    Args:
-        img_list (list[str]): A image list of image paths to be read.
-        num_prefetch_queue (int): Number of prefetch queue.
-    """
-
-    def __init__(self, img_list, num_prefetch_queue):
-        super().__init__()
-        self.que = queue.Queue(num_prefetch_queue)
-        self.img_list = img_list
-
-    def run(self):
-        for img_path in self.img_list:
-            img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
-            self.que.put(img)
-
-        self.que.put(None)
-
-    def __next__(self):
-        next_item = self.que.get()
-        if next_item is None:
-            raise StopIteration
-        return next_item
-
-    def __iter__(self):
-        return self
-
-
-class IOConsumer(threading.Thread):
-
-    def __init__(self, opt, que, qid):
-        super().__init__()
-        self._queue = que
-        self.qid = qid
-        self.opt = opt
-
-    def run(self):
-        while True:
-            msg = self._queue.get()
-            if isinstance(msg, str) and msg == 'quit':
-                break
-
-            output = msg['output']
-            save_path = msg['save_path']
-            cv2.imwrite(save_path, output)
-        print(f'IO worker {self.qid} is done.')

spaces/CVPR/MonoScene/monoscene/.ipynb_checkpoints/monoscene_model-checkpoint.py

@@ -1,22 +0,0 @@
-from transformers import PreTrainedModel
-from .config import MonoSceneConfig
-from monoscene.monoscene import MonoScene
-
-
-
-class MonoSceneModel(PreTrainedModel):
-    config_class = ResnetConfig
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.model = MonoScene(
-            dataset=config.dataset,
-            n_classes=config.n_classes,
-            feature=config.feature,
-            project_scale=config.project_scale,
-            full_scene_size=config.full_scene_size
-        )
-     
-
-    def forward(self, tensor):
-        return self.model.forward(tensor)

spaces/Chris4K/llms_compare/app.py

@@ -1,274 +0,0 @@
-import os, requests
-import gradio as gr
-HF_READ_API_KEY = os.environ["HF_READ_API_KEY"]
-
-### This code loads the models and undertakes inference locally ###
-
-# from transformers import GPTNeoForCausalLM, GPT2Tokenizer
-# from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM
-# model = GPTNeoForCausalLM.from_pretrained("EleutherAI/gpt-neo-2.7B")
-# tokenizer = GPT2Tokenizer.from_pretrained("EleutherAI/gpt-neo-2.7B")
-# tokenizer = T5Tokenizer.from_pretrained("google/flan-t5-small")
-# model = T5ForConditionalGeneration.from_pretrained("google/flan-t5-small")
-
-model_list = ['google/flan-t5-small', 'google/flan-t5-base', 'google/flan-t5-large', 'google/flan-t5-xl', 'google/flan-t5-xxl', 
-              'gpt2-medium', 'gpt2-large', 'gpt2-xl',
-              'EleutherAI/gpt-neo-1.3B', 'EleutherAI/gpt-neo-2.7B', 'EleutherAI/gpt-neo-6b', 'EleutherAI/gpt-neox-20b',
-              'bigscience/bloom-1b7', 'bigscience/bloom-3b', 'bigscience/bloom-7b1'
-              ]
-
-def load_model(model_name):
-    if model_name == 'EleutherAI/gpt-neo-2.7B' or model_name == 'gpt2-medium' or model_name == 'gpt2-large':
-        model = AutoModelForCausalLM.from_pretrained(model_name)
-    else:
-        model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    tokenizer.pad_token = tokenizer.eos_token
-    # tokenizer.padding_side = "left"
-    return model, tokenizer
-
-def maybe_is_truncated(s):
-    punct = [".", "!", "?", '"']
-    if s[-1] in punct:
-        return False
-    return True
-
-def load_and_generate(model_name, prompt):
-    model, tokenizer = load_model(model_name)
-
-    temperature=0.25
-    tokens = tokenizer(prompt, return_tensors="pt")
-    max_length = len(tokens.input_ids[0])+5
-    input_ids = tokens.input_ids
-    attention_mask = tokens.attention_mask
-    # see huggingface.co/docs/transformers/main_classes/text_generation
-    gen_tokens = model.generate(
-        input_ids=input_ids,
-        attention_mask=attention_mask,
-        pad_token_id=tokenizer.eos_token_id,
-        do_sample=True,
-        temperature=temperature,
-        # max_length=max_length,
-        max_new_tokens=max_length, 
-        # use_cache=False, 
-        # penalty_alpha=0.1,
-        # top_k=100, 
-        # early_stopping=False
-    )
-    gen_text = tokenizer.batch_decode(gen_tokens)[0]
-
-    max_times = 20
-    while maybe_is_truncated(gen_text) and max_times > 0:
-        tokens = tokenizer(gen_text, return_tensors="pt")
-        max_length = len(tokens.input_ids[0])+5
-        input_ids = tokens.input_ids
-        attention_mask = tokens.attention_mask
-
-        gen_tokens = model.generate(
-            input_ids=input_ids,
-            attention_mask=attention_mask,
-            pad_token_id=tokenizer.eos_token_id,
-            do_sample=True,
-            temperature=temperature,
-            max_length=max_length,
-            # max_new_tokens=100,
-            # use_cache=True,
-            # penalty_alpha=0.1,
-            # top_k=100, 
-            # early_stopping=False
-        )
-
-        gen_text = tokenizer.batch_decode(gen_tokens)[0]
-
-        max_times -= 1
-
-    return gen_text.replace("<pad>", "").replace("</s>", "")
-
-### This code for the inference api ###
-
-def generate_from_api(query, model_name, temperature, max_tokens):
-    headers = {f"Authorization": f"Bearer {HF_READ_API_KEY}", 
-               "wait_for_model": "true", 
-               "temperature": str(temperature), 
-               "max_tokens": str(max_tokens),
-               "max_time": str(120)}
-    
-    model_api_url = f"https://api-inference.huggingface.co/models/{model_name}"
-
-    payload = {"inputs": query}
-    response = requests.post(model_api_url, headers=headers, json=payload)
-    while response.status_code != 200:
-        response = requests.post(model_api_url, headers=headers, json=payload)
-    return response.json()[0]['generated_text']
-
-def generate_from_api_check(query, model_name, temperature, max_tokens):
-    headers = {f"Authorization": f"Bearer {HF_READ_API_KEY}", 
-               "wait_for_model": "true", 
-               "temperature": str(temperature), 
-               "max_tokens": str(max_tokens),
-               "max_time": str(120)}
-    
-    model_api_url = f"https://api-inference.huggingface.co/models/{model_name}"
-
-    payload = {"inputs": query}
-    response = requests.post(model_api_url, headers=headers, json=payload)
-    while response.status_code != 200:
-        response = requests.post(model_api_url, headers=headers, json=payload)
-
-    max_times = 20
-    gen_text = response.json()[0]['generated_text']
-    while maybe_is_truncated(gen_text) and max_times > 0:
-        headers = {f"Authorization": f"Bearer {HF_READ_API_KEY}", 
-                    "wait_for_model": "true", 
-                    "temperature": str(temperature), 
-                    "max_tokens": str(max_tokens + len(gen_text)),
-                    "max_time": str(120)}
-        payload = {"inputs": query + ' ' + gen_text}
-        response = requests.post(model_api_url, headers=headers, json=payload)
-        while response.status_code != 200:
-            response = requests.post(model_api_url, headers=headers, json=payload)
-        gen_text = response.json()[0]['generated_text']
-        max_times -= 1
-        
-    return gen_text
-
-
-with gr.Blocks(css='style.css') as demo:
-    gr.HTML("""
-    <div style="text-align: center; max-width: 1240px; margin: 0 auto;">
-    <h1 style="font-weight: 200; font-size: 20px; margin-bottom:8px; margin-top:0px;">
-    Different Strokes (Prompts) for Different Folks (LLMs)
-    </h1>
-    <hr style="margin-bottom:5px; margin-top:5px;">
-    <h4 style="font-weight: 50; font-size: 14px; margin-bottom:0px; margin-top:0px;">
-    After reading <a href="https://github.com/dair-ai/Prompt-Engineering-Guide">Prompt Engineering Guide</a>, which is a good guide when starting to learn about prompts for large language models (LLMs), specifically OpenAI's LLMs, I was interested in seeing the results with for other LLMs. Hence, did up a simple demonstration of different prompts for different popular LLMs of different sizes. The prompt examples are taken from the Prompt Engineering Guide, and the LLMs that you can select below are all available on Hugging Face. If you are interested in comparing them with the prompts from OpenAI's model, you can refer to the writeup in the <a href="https://github.com/dair-ai/Prompt-Engineering-Guide">Prompt Engineering Guide</a> itself.
-    </h4>
-    <hr style="margin-bottom:5px; margin-top:5px;">
-    <h5 style="font-weight: 50; font-size: 12px; margin-bottom:0px; margin-top:0px;">
-    Note: Larger models will take a while, especially on the first run.
-    </h5>
-    </div>
-    """)
-
-    with gr.Column(elem_id="col-container"):  
-        with gr.Row(variant="compact"):
-
-            model_name = gr.Dropdown(
-                 model_list, 
-                 label="Select model",
-                 value=model_list[0],
-                 ).style(
-                container=False,
-            )
-
-            temperature = gr.Slider(
-                0.1, 100.0, value=1.0, label="Temperature",
-            ).style(
-                container=False,
-            )
-
-            max_tokens = gr.Slider(
-                10, 2250, step=1, value=100, label="Max. tokens (in output)",
-            ).style(
-                container=False,
-            )
-
-            check_truncated = gr.Checkbox(
-                label="Check for truncated output",
-                value=False,
-            ).style(
-                container=False,
-            )
-
-        with gr.Row(variant="compact"):
-            prompt = gr.Textbox(
-                label="Enter your prompt",
-                show_label=False,
-                # max_lines=2,
-                placeholder="Select your prompt from the examples below",
-            ).style(
-                container=False,
-            )
-            process = gr.Button("Generate").style(full_width=False)
-        
-        with gr.Row():
-            output=gr.Textbox(
-                label="LLM output",
-                show_label=True)
-            
-        gr.HTML("""
-        <div>
-        <h4 style="font-weight: 50; font-size: 14px; margin-bottom:0px; margin-top:0px;">
-        Prompt examples. Select the prompt you would like to test, and it will appear (properly formatted) in the input box above.
-        </h4>
-        </div>
-        """)
-        with gr.Tab("Introduction"):
-            example_set_1 = gr.Examples(label = 'Simple Prompt vs. Instruct then Prompt.', 
-                                        examples=["The sky is ", "Complete the following sentence: The sky is ",],
-                                        inputs=[prompt])
-            example_set_2 = gr.Examples(label = 'Few Shot Prompt.', 
-                                        examples=["This is awesome! // Positive\nThis is bad! // Negative\nWow that movie was rad! // Positive\nWhat a horrible show! //",],
-                                        inputs=[prompt])
-            example_set_3 = gr.Examples(label = 'Explicitly Specify the Instruction', 
-                                        examples=["### Instruction ###\nTranslate the text below to Spanish:\nText: 'hello!'",],
-                                        inputs=[prompt])
-            example_set_4 = gr.Examples(label = 'Be Very Specific', 
-                                        examples=["Extract the name of places in the following text.\nDesired format:\nPlace: <comma_separated_list_of_company_names>\nInput: 'Although these developments are encouraging to researchers, much is still a mystery. “We often have a black box between the brain and the effect we see in the periphery,” says Henrique Veiga-Fernandes, a neuroimmunologist at the Champalimaud Centre for the Unknown in Lisbon. “If we want to use it in the therapeutic context, we actually need to understand the mechanism.'",],
-                                        inputs=[prompt])
-            example_set_5 = gr.Examples(label = 'Precision', 
-                                        examples=["Explain the concept of deep learning. Keep the explanation short, only a few sentences, and don't be too descriptive.", "Use 2-3 sentences to explain the concept of deep learning to a high school student."],
-                                        inputs=[prompt])
-            example_set_6 = gr.Examples(label = 'Focus on What LLM Should Do', 
-                                        examples=["The following is an agent that recommends movies to a customer. The agent is responsible to recommend a movie from the top global trending movies. It should refrain from asking users for their preferences and avoid asking for personal information. If the agent doesn't have a movie to recommend, it should respond 'Sorry, couldn't find a movie to recommend today.'.\nCustomer: Please recommend a movie based on my interests.\nAgent:"],
-                                        inputs=[prompt])      
-              
-        with gr.Tab("Basic Tasks"):
-            example_set_7 = gr.Examples(label = 'Explain vs. Summarize', 
-                                        examples=["Explain antibiotics.\nA:", "Antibiotics are a type of medication used to treat bacterial infections. They work by either killing the bacteria or preventing them from reproducing, allowing the body’s immune system to fight off the infection. Antibiotics are usually taken orally in the form of pills, capsules, or liquid solutions, or sometimes administered intravenously. They are not effective against viral infections, and using them inappropriately can lead to antibiotic resistance.\nExplain the above in one sentence:",],
-                                        inputs=[prompt])
-            example_set_8 = gr.Examples(label = 'Information Extraction', 
-                                        examples=["Author-contribution statements and acknowledgements in research papers should state clearly and specifically whether, and to what extent, the authors used AI technologies such as ChatGPT in the preparation of their manuscript and analysis. They should also indicate which LLMs were used. This will alert editors and reviewers to scrutinize manuscripts more carefully for potential biases, inaccuracies and improper source crediting. Likewise, scientific journals should be transparent about their use of LLMs, for example when selecting submitted manuscripts.\nMention the large language model based product mentioned in the paragraph above:",],
-                                        inputs=[prompt])
-            example_set_9 = gr.Examples(label = 'Question and Answer', 
-                                        examples=["Answer the question based on the context below. Keep the answer short and concise. Respond 'Unsure about answer' if not sure about the answer.\nContext: Teplizumab traces its roots to a New Jersey drug company called Ortho Pharmaceutical. There, scientists generated an early version of the antibody, dubbed OKT3. Originally sourced from mice, the molecule was able to bind to the surface of T cells and limit their cell-killing potential. In 1986, it was approved to help prevent organ rejection after kidney transplants, making it the first therapeutic antibody allowed for human use.\nQuestion: What was OKT3 originally sourced from?\nAnswer:",],
-                                        inputs=[prompt])
-            example_set_10 = gr.Examples(label = 'Text Classification', 
-                                        examples=["Classify the text into neutral, negative or positive.\nText: I think the food was okay.\nSentiment:","Classify the text into neutral, negative or positive.\nText: I think the vacation is okay.\nSentiment: neutral\nText: I think the food was okay.\nSentiment:"],
-                                        inputs=[prompt])    
-            example_set_11 = gr.Examples(label = 'Conversation', 
-                                        examples=["The following is a conversation with an AI research assistant. The assistant tone is technical and scientific.\nHuman: Hello, who are you?\nAI: Greeting! I am an AI research assistant. How can I help you today?\nHuman: Can you tell me about the creation of blackholes?\nAI:", "The following is a conversation with an AI research assistant. The assistant answers should be easy to understand even by primary school students.\nHuman: Hello, who are you?\nAI: Greeting! I am an AI research assistant. How can I help you today?\nHuman: Can you tell me about the creation of black holes?\nAI: "],
-                                        inputs=[prompt])
-            example_set_12 = gr.Examples(label = 'Reasoning', 
-                                        examples=["The odd numbers in this group add up to an even number: 15, 32, 5, 13, 82, 7, 1.\nA: ", "The odd numbers in this group add up to an even number: 15, 32, 5, 13, 82, 7, 1.\nSolve by breaking the problem into steps. First, identify the odd numbers, add them, and indicate whether the result is odd or even."],
-                                        inputs=[prompt])   
-            
-
-        with gr.Tab("Interesting Techniques"):
-            example_set_13 = gr.Examples(label = 'Zero Shot, i.e., no examples at all', 
-                                        examples=["Classify the text into neutral, negative or positive.\nText: I think the vacation is okay.\nSentiment:",],
-                                        inputs=[prompt])
-            example_set_14 = gr.Examples(label = 'Few Shot, i.e., only a few examples', 
-                                        examples=["The odd numbers in this group add up to an even number: 4, 8, 9, 15, 12, 2, 1.\nA: The answer is False.\n\nThe odd numbers in this group add up to an even number: 17,  10, 19, 4, 8, 12, 24.\nA: The answer is True.\n\nThe odd numbers in this group add up to an even number: 16,  11, 14, 4, 8, 13, 24.\nA: The answer is True.\n\nThe odd numbers in this group add up to an even number: 17,  9, 10, 12, 13, 4, 2.\nA: The answer is False.\n\nThe odd numbers in this group add up to an even number: 15, 32, 5, 13, 82, 7, 1.\nA: ",],
-                                        inputs=[prompt])
-            example_set_15 = gr.Examples(label = 'Chain of Thought, i.e., go through a series of rational steps', 
-                                        examples=["The odd numbers in this group add up to an even number: 4, 8, 9, 15, 12, 2, 1.\nA: Adding all the odd numbers (9, 15, 1) gives 25. The answer is False.\n\nThe odd numbers in this group add up to an even number: 15, 32, 5, 13, 82, 7, 1.\nA:",],
-                                        inputs=[prompt])
-            example_set_16 = gr.Examples(label = 'Zero Shot Chain of Thought, i.e., think step by step, but no examples provided', 
-                                        examples=["I went to the market and bought 10 apples. I gave 2 apples to the neighbor and 2 to the repairman. I then went and bought 5 more apples and ate 1. How many apples did I remain with?\nLet's think step by step.",],
-                                        inputs=[prompt])            
-            example_set_17 = gr.Examples(label = 'Self Consistency, i.e., give examples to encourage the model to be consistent', 
-                                        examples=["Q: There are 15 trees in the grove. Grove workers will plant trees in the grove today. After they are done,there will be 21 trees. How many trees did the grove workers plant today?\nA: We start with 15 trees. Later we have 21 trees. The difference must be the number of trees they planted.\nSo, they must have planted 21 - 15 = 6 trees. The answer is 6.\n\nQ: If there are 3 cars in the parking lot and 2 more cars arrive, how many cars are in the parking lot?\nA: There are 3 cars in the parking lot already. 2 more arrive. Now there are 3 + 2 = 5 cars. The answer is 5.\n\nQ: Olivia has $23. She bought five bagels for $3 each. How much money does she have left?\nA: She bought 5 bagels for $3 each. This means she spent 5\n\nQ: When I was 6 my sister was half my age. Now I’m 70 how old is my sister?\nA:",],
-                                        inputs=[prompt])
-            example_set_18 = gr.Examples(label = 'Generating Knowledge, i.e., use examples to generate knowledge', 
-                                        examples=["Input: Greece is larger than mexico.\nKnowledge: Greece is approximately 131,957 sq km, while Mexico is approximately 1,964,375 sq km, making Mexico 1,389% larger than Greece.\n\nInput: Glasses always fog up.\nKnowledge: Condensation occurs on eyeglass lenses when water vapor from your sweat, breath, and ambient humidity lands on a cold surface, cools, and then changes into tiny drops of liquid, forming a film that you see as fog. Your lenses will be relatively cool compared to your breath, especially when the outside air is cold.\n\nInput: A fish is capable of thinking.\nKnowledge: Fish are more intelligent than they appear. In many areas, such as memory, their cognitive powers match or exceed those of ’higher’ vertebrates including non-human primates. Fish’s long-term memories help them keep track of complex social relationships.\n\nInput: A common effect of smoking lots of cigarettes in one’s lifetime is a higher than normal chance of getting lung cancer.\nKnowledge: Those who consistently averaged less than one cigarette per day over their lifetime had nine times the risk of dying from lung cancer than never smokers. Among people who smoked between one and 10 cigarettes per day, the risk of dying from lung cancer was nearly 12 times higher than that of never smokers.\n\nInput: Part of golf is trying to get a higher point total than others.\nKnowledge:",],
-                                        inputs=[prompt])
-                        
-        # process.click(load_and_generate, inputs=[model_name, prompt], outputs=[output])
-        if check_truncated:
-            process.click(generate_from_api_check, inputs=[prompt, model_name, temperature, max_tokens], outputs=[output])
-        else:   
-            process.click(generate_from_api, inputs=[prompt, model_name, temperature, max_tokens], outputs=[output])
-
-# demo.launch(server_port=8080)
-demo.launch()

spaces/ChristopherMarais/Andrew_AI-BB_classification-beta/mysite/andrew_alpha/static/andrew_alpha.js

@@ -1,208 +0,0 @@
-// Get token from cookie 
-function getCookie(name) {
-  let cookieValue = null;
-  if (document.cookie && document.cookie !== '') {
-    const cookies = document.cookie.split(';');
-    for (let i = 0; i < cookies.length; i++) {
-      const cookie = cookies[i].trim();
-      // Does this cookie string begin with the name we want?
-      if (cookie.substring(0, name.length + 1) === (name + '=')) {
-        cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
-        break;
-      }
-    }
-  }
-  return cookieValue;
-}
-
-// Get the video element
-const video = document.getElementById("videoElement");
-const captureButton = document.getElementById("captureButton");
-const uploadButton = document.getElementById("uploadButton");
-const capturedFrame = document.getElementById("capturedFrame");
-const webcamFeed = document.getElementById("webcamFeed");
-const processedFrame = document.getElementById("processedFrame");
-// Get CSRF token from cookie
-const csrftoken = getCookie('csrftoken');
-// Get reference to form
-const form = document.getElementById('myForm');
-
-// Check if the browser supports getUserMedia
-if (navigator.mediaDevices.getUserMedia) {
-  // Request access to the webcam
-  navigator.mediaDevices
-    .getUserMedia({ video: true })
-    .then(function (stream) {
-      // Set the video source to the stream from the webcam
-      video.srcObject = stream;
-    })
-    .catch(function (error) {
-      console.error("Error accessing the webcam:", error);
-      const message = document.createElement("p");
-      webcamFeed.innerHTML = "No webcam detected.";
-      document.body.appendChild(message);
-    });
-} else {
-  console.error("getUserMedia is not supported by this browser");
-}
-
-
-// Variable to store latest captured frame URL
-let latestFrameURL;
-
-// Add click handler to capture button
-captureButton.addEventListener("click", function() {
-
-  // Remove previously displayed captured frame (if any)
-  while (capturedFrame.firstChild) {
-    capturedFrame.firstChild.remove();
-  }
-
-  // Clear processed image display
-  while (processedFrame.firstChild) {
-    processedFrame.firstChild.remove();
-  }
-
-  // Create canvas element 
-  const canvas = document.createElement("canvas");
-  const context = canvas.getContext("2d");
-
-  // Set canvas dimensions to match video
-  canvas.width = video.videoWidth; 
-  canvas.height = video.videoHeight;
-
-  // Draw current video frame to canvas
-  context.drawImage(video, 0, 0, canvas.width, canvas.height);
-
-  // Convert canvas to data URL
-  const dataURL = canvas.toDataURL("image/png");
-
-  // Save data URL to reuse when appending to form
-  latestFrameURL = dataURL;
-
-  // Create img element for captured frame
-  const capturedImage = document.createElement("img");
-  capturedImage.src = latestFrameURL;
-
-  // Append to captured frame div
-  capturedFrame.appendChild(capturedImage);
-  if (canvas) {
-
-    // Convert canvas to blob
-    canvas.toBlob(function(blob) {
-
-      // Create file from blob
-      const file = new File([blob], 'capturedImage.jpg', {type: 'image/jpeg'})
-
-      // Create FormData
-      const formData = new FormData();
-
-      // Append file 
-      formData.append('image', file);
-
-      // Headers with token
-      const headers = new Headers();
-      headers.append('X-CSRFToken', csrftoken);
-
-      // Send FormData
-      fetch('/process_uploaded_image/', {
-        method: 'POST',
-        headers: headers,
-        body: formData
-      })
-      .then(response => response.blob())
-      .then(blob => {
-
-        // Create image from blob
-        const img = document.createElement('img');
-        img.src = URL.createObjectURL(blob);
-
-        // Replace original image with processed one
-        while (capturedFrame.firstChild) {
-          capturedFrame.firstChild.remove();
-        }
-        document.getElementById('capturedFrame').appendChild(img);
-
-        // Display processed image
-        // Append to DOM
-        // document.getElementById('processedFrame').appendChild(img);
-      
-      })
-      .catch(error => {
-        console.error('Error processing image'); 
-      });
-
-    }, 'image/jpeg');
-
-  } else {
-    console.error("Canvas not found"); 
-  }
-
-});
-
-// Add event listener to upload button
-uploadButton.addEventListener("click", function () {
-  const fileInput = document.createElement("input");
-  fileInput.type = "file";
-
-  fileInput.addEventListener("change", function () {
-    const fileReader = new FileReader();
-
-    fileReader.addEventListener("load", function () {
-      const uploadedImageURL = fileReader.result;
-
-      // Remove previously displayed captured frame (if any)
-      while (capturedFrame.firstChild) {
-        capturedFrame.firstChild.remove();
-      }
-      // Clear processed image display
-      while (processedFrame.firstChild) {
-        processedFrame.firstChild.remove();
-      }
-
-      // Create an image element for displaying uploaded image
-      const uploadedImage = document.createElement("img");
-      uploadedImage.src = uploadedImageURL;
-      const imageFile = fileInput.files[0];
-      let formData = new FormData();
-      formData.append('image', imageFile);
-
-      fetch('/process_uploaded_image/', {
-        method: 'POST',
-        body: formData
-      })
-      .then(response => response.blob())
-      .then(blob => {
-
-        // Create image from blob
-        const img = document.createElement('img');
-        img.src = URL.createObjectURL(blob);
-
-        // Replace original image with processed one
-        while (capturedFrame.firstChild) {
-          capturedFrame.firstChild.remove();
-        }
-        document.getElementById('capturedFrame').appendChild(img);
-
-        // Display processed image
-        // Append to DOM
-        // document.getElementById('processedFrame').appendChild(img);
-      
-      })
-      .catch(error => {
-        console.error('Error processing image');
-      });
-
-
-      // Append uploaded image to captured frame div
-      capturedFrame.appendChild(uploadedImage);
-      
-    });
-
-    if (fileInput.files.length > 0) {
-      fileReader.readAsDataURL(fileInput.files[0]);
-    }
-  });
-
-  fileInput.click();
-});

spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/config/system/help_system.js

@@ -1,84 +0,0 @@
-export const helpCfg = {
-  "themeSet": false,
-  "title": "ws帮助",
-  "subTitle": "Yunzai-Bot & ws-plugin",
-  "colWidth": 265,
-  "theme": "all",
-  "themeExclude": [
-    "default"
-  ],
-  "colCount": 3,
-  "bgBlur": true
-}
-export const helpList = [
-  {
-    "group": "连接管理",
-    "list": [
-      {
-        "icon": 80,
-        "title": "#ws添加连接",
-        "desc": "添加一个新的连接"
-      },
-      {
-        "icon": 63,
-        "title": "#ws删除连接",
-        "desc": "删除一个已有的连接 "
-      },
-      {
-        "icon": 66,
-        "title": "#ws关闭连接",
-        "desc": "不会删除已有连接,同时不进行连接"
-      },
-      {
-        "icon": 65,
-        "title": "#ws打开连接",
-        "desc": "打开已关闭的连接"
-      },
-      {
-        "icon": 79,
-        "title": "#ws查看连接",
-        "desc": "查看已有的所有连接名字和状态"
-      },
-      {
-        "icon": 64,
-        "title": "#ws重新连接",
-        "desc": "断开连接并重新连接"
-      }
-    ]
-  },
-  {
-    "group": "其他设置",
-    "list": [
-      {
-        "icon": 81,
-        "title": "#ws(增加/删除)(禁用/启用)群123456",
-        "desc": "精确处理黑名单白名单,不带群号为当前群"
-      },
-      {
-        "icon": 84,
-        "title": "#ws(禁用/启用)群123456",
-        "desc": "模糊匹配,比如禁用群则优先看白名单,如果有就删除,否则添加到黑名单"
-      },
-      {
-        "icon": 85,
-        "title": "#ws查看(禁用/启用)群",
-        "desc": "查看当前(禁用/启用)的群聊列表"
-      },
-    ]
-  },
-  {
-    "group": "其他说明",
-    "list": [
-      {
-        "icon": 71,
-        "title": "#ws连接说明",
-        "desc": "查看添加连接时的说明"
-      },
-      {
-        "icon": 94,
-        "title": "#ws设置",
-        "desc": "插件设置"
-      }
-    ]
-  }
-]

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

@@ -1,57 +0,0 @@
-import random
-from pathlib import Path
-from typing import List, Tuple
-
-from PIL.Image import Image as IMG
-from PIL.Image import Palette
-from pil_utils import BuildImage
-
-from meme_generator import add_meme
-from meme_generator.utils import make_jpg_or_gif
-
-img_dir = Path(__file__).parent / "images"
-
-
-def get_dominant_colors(img: IMG) -> List[Tuple[int, int, int]]:
-    img = img.convert("P", palette=Palette.ADAPTIVE, colors=20)
-    palette = img.getpalette()
-    assert palette
-    color_indexs = sorted(img.getcolors(), reverse=True)
-    colors = [tuple(palette[i * 3 : i * 3 + 3]) for _, i in color_indexs]
-    colors = list(
-        filter(lambda c: c[0] * 0.299 + c[1] * 0.578 + c[2] * 0.114 < 200, colors)
-    )
-    return colors
-
-
-def dont_touch(images: List[BuildImage], texts, args):
-    frame = BuildImage.open(img_dir / "0.png")
-    mask = BuildImage.open(img_dir / "mask.png").convert("L")
-
-    def paste_random_blocks(img: BuildImage, colors: List[Tuple[int, int, int]]):
-        x1, y1, x2, y2 = 200, 300, 400, 650
-        block_locs = []
-        for _ in range(150):
-            x = random.randint(x1, x2)
-            y = random.randint(y1, y2)
-            if mask.image.getpixel((x, y)) == 0:
-                continue
-            if any(abs(x - x_) < 13 and abs(y - y_) < 13 for x_, y_ in block_locs):
-                continue
-            block_locs.append((x, y))
-            color = random.choice(colors)
-            block = BuildImage.new("RGBA", (10, 10), color)
-            block = block.rotate(45, expand=True)
-            img.paste(block, (x, y), alpha=True)
-
-    def make(img: BuildImage) -> BuildImage:
-        img_frame = frame.copy()
-        colors = get_dominant_colors(img.image)
-        paste_random_blocks(img_frame, colors)
-        img = img.convert("RGBA").resize((250, 250), keep_ratio=True, inside=True)
-        return img_frame.paste(img, (25, 460), alpha=True)
-
-    return make_jpg_or_gif(images[0], make)
-
-
-add_meme("dont_touch", dont_touch, min_images=1, max_images=1, keywords=["别碰"])

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/altair/vegalite/v5/theme.py

@@ -1,59 +0,0 @@
-"""Tools for enabling and registering chart themes"""
-
-from ...utils.theme import ThemeRegistry
-
-VEGA_THEMES = [
-    "ggplot2",
-    "quartz",
-    "vox",
-    "fivethirtyeight",
-    "dark",
-    "latimes",
-    "urbaninstitute",
-    "excel",
-    "googlecharts",
-    "powerbi",
-]
-
-
-class VegaTheme:
-    """Implementation of a builtin vega theme."""
-
-    def __init__(self, theme):
-        self.theme = theme
-
-    def __call__(self):
-        return {
-            "usermeta": {"embedOptions": {"theme": self.theme}},
-            "config": {"view": {"continuousWidth": 300, "continuousHeight": 300}},
-        }
-
-    def __repr__(self):
-        return "VegaTheme({!r})".format(self.theme)
-
-
-# The entry point group that can be used by other packages to declare other
-# renderers that will be auto-detected. Explicit registration is also
-# allowed by the PluginRegistery API.
-ENTRY_POINT_GROUP = "altair.vegalite.v5.theme"  # type: str
-themes = ThemeRegistry(entry_point_group=ENTRY_POINT_GROUP)
-
-themes.register(
-    "default",
-    lambda: {"config": {"view": {"continuousWidth": 300, "continuousHeight": 300}}},
-)
-themes.register(
-    "opaque",
-    lambda: {
-        "config": {
-            "background": "white",
-            "view": {"continuousWidth": 300, "continuousHeight": 300},
-        }
-    },
-)
-themes.register("none", lambda: {})
-
-for theme in VEGA_THEMES:
-    themes.register(theme, VegaTheme(theme))
-
-themes.enable("default")

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/svgLib/path/shapes.py

@@ -1,183 +0,0 @@
-import re
-
-
-def _prefer_non_zero(*args):
-    for arg in args:
-        if arg != 0:
-            return arg
-    return 0.0
-
-
-def _ntos(n):
-    # %f likes to add unnecessary 0's, %g isn't consistent about # decimals
-    return ("%.3f" % n).rstrip("0").rstrip(".")
-
-
-def _strip_xml_ns(tag):
-    # ElementTree API doesn't provide a way to ignore XML namespaces in tags
-    # so we here strip them ourselves: cf. https://bugs.python.org/issue18304
-    return tag.split("}", 1)[1] if "}" in tag else tag
-
-
-def _transform(raw_value):
-    # TODO assumes a 'matrix' transform.
-    # No other transform functions are supported at the moment.
-    # https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/transform
-    # start simple: if you aren't exactly matrix(...) then no love
-    match = re.match(r"matrix\((.*)\)", raw_value)
-    if not match:
-        raise NotImplementedError
-    matrix = tuple(float(p) for p in re.split(r"\s+|,", match.group(1)))
-    if len(matrix) != 6:
-        raise ValueError("wrong # of terms in %s" % raw_value)
-    return matrix
-
-
-class PathBuilder(object):
-    def __init__(self):
-        self.paths = []
-        self.transforms = []
-
-    def _start_path(self, initial_path=""):
-        self.paths.append(initial_path)
-        self.transforms.append(None)
-
-    def _end_path(self):
-        self._add("z")
-
-    def _add(self, path_snippet):
-        path = self.paths[-1]
-        if path:
-            path += " " + path_snippet
-        else:
-            path = path_snippet
-        self.paths[-1] = path
-
-    def _move(self, c, x, y):
-        self._add("%s%s,%s" % (c, _ntos(x), _ntos(y)))
-
-    def M(self, x, y):
-        self._move("M", x, y)
-
-    def m(self, x, y):
-        self._move("m", x, y)
-
-    def _arc(self, c, rx, ry, x, y, large_arc):
-        self._add(
-            "%s%s,%s 0 %d 1 %s,%s"
-            % (c, _ntos(rx), _ntos(ry), large_arc, _ntos(x), _ntos(y))
-        )
-
-    def A(self, rx, ry, x, y, large_arc=0):
-        self._arc("A", rx, ry, x, y, large_arc)
-
-    def a(self, rx, ry, x, y, large_arc=0):
-        self._arc("a", rx, ry, x, y, large_arc)
-
-    def _vhline(self, c, x):
-        self._add("%s%s" % (c, _ntos(x)))
-
-    def H(self, x):
-        self._vhline("H", x)
-
-    def h(self, x):
-        self._vhline("h", x)
-
-    def V(self, y):
-        self._vhline("V", y)
-
-    def v(self, y):
-        self._vhline("v", y)
-
-    def _line(self, c, x, y):
-        self._add("%s%s,%s" % (c, _ntos(x), _ntos(y)))
-
-    def L(self, x, y):
-        self._line("L", x, y)
-
-    def l(self, x, y):
-        self._line("l", x, y)
-
-    def _parse_line(self, line):
-        x1 = float(line.attrib.get("x1", 0))
-        y1 = float(line.attrib.get("y1", 0))
-        x2 = float(line.attrib.get("x2", 0))
-        y2 = float(line.attrib.get("y2", 0))
-
-        self._start_path()
-        self.M(x1, y1)
-        self.L(x2, y2)
-
-    def _parse_rect(self, rect):
-        x = float(rect.attrib.get("x", 0))
-        y = float(rect.attrib.get("y", 0))
-        w = float(rect.attrib.get("width"))
-        h = float(rect.attrib.get("height"))
-        rx = float(rect.attrib.get("rx", 0))
-        ry = float(rect.attrib.get("ry", 0))
-
-        rx = _prefer_non_zero(rx, ry)
-        ry = _prefer_non_zero(ry, rx)
-        # TODO there are more rules for adjusting rx, ry
-
-        self._start_path()
-        self.M(x + rx, y)
-        self.H(x + w - rx)
-        if rx > 0:
-            self.A(rx, ry, x + w, y + ry)
-        self.V(y + h - ry)
-        if rx > 0:
-            self.A(rx, ry, x + w - rx, y + h)
-        self.H(x + rx)
-        if rx > 0:
-            self.A(rx, ry, x, y + h - ry)
-        self.V(y + ry)
-        if rx > 0:
-            self.A(rx, ry, x + rx, y)
-        self._end_path()
-
-    def _parse_path(self, path):
-        if "d" in path.attrib:
-            self._start_path(initial_path=path.attrib["d"])
-
-    def _parse_polygon(self, poly):
-        if "points" in poly.attrib:
-            self._start_path("M" + poly.attrib["points"])
-            self._end_path()
-
-    def _parse_polyline(self, poly):
-        if "points" in poly.attrib:
-            self._start_path("M" + poly.attrib["points"])
-
-    def _parse_circle(self, circle):
-        cx = float(circle.attrib.get("cx", 0))
-        cy = float(circle.attrib.get("cy", 0))
-        r = float(circle.attrib.get("r"))
-
-        # arc doesn't seem to like being a complete shape, draw two halves
-        self._start_path()
-        self.M(cx - r, cy)
-        self.A(r, r, cx + r, cy, large_arc=1)
-        self.A(r, r, cx - r, cy, large_arc=1)
-
-    def _parse_ellipse(self, ellipse):
-        cx = float(ellipse.attrib.get("cx", 0))
-        cy = float(ellipse.attrib.get("cy", 0))
-        rx = float(ellipse.attrib.get("rx"))
-        ry = float(ellipse.attrib.get("ry"))
-
-        # arc doesn't seem to like being a complete shape, draw two halves
-        self._start_path()
-        self.M(cx - rx, cy)
-        self.A(rx, ry, cx + rx, cy, large_arc=1)
-        self.A(rx, ry, cx - rx, cy, large_arc=1)
-
-    def add_path_from_element(self, el):
-        tag = _strip_xml_ns(el.tag)
-        parse_fn = getattr(self, "_parse_%s" % tag.lower(), None)
-        if not callable(parse_fn):
-            return False
-        parse_fn(el)
-        if "transform" in el.attrib:
-            self.transforms[-1] = _transform(el.attrib["transform"])
-        return True

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

@@ -1,6 +0,0 @@
-import sys
-from fontTools.varLib import main
-
-
-if __name__ == "__main__":
-    sys.exit(main())

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/frontend/assets/index-6f7117a6.js

@@ -1,2 +0,0 @@
-import{S as G,e as I,s as J,G as Z,N as O,K as F,p as U,M as z,n as q,A as j,V as be,B as K,P as D,O as S,U as $,Q as ge,R as x,k as p,m as L,o as v,u as Q,v as d,y as V,z as h,x as y,F as C,a7 as de,h as he,j as we,t as ke,a9 as Ae,ab as pe,ac as ve,ad as ye,ak as k,at as Fe,au as Be,E as ze,ae as Ue,q as je,r as Ee}from"./index-3370be2a.js";import{B as Ne}from"./Button-89624748.js";import{B as ae}from"./BlockLabel-56db415e.js";import{E as Oe}from"./Empty-585389a4.js";import{F as W}from"./File-ae385ffc.js";import{U as Se}from"./Upload-f29b2460.js";import{M as Te}from"./ModifyUpload-d8fc50ab.js";import{n as ee,b as Me}from"./ModifyUpload.svelte_svelte_type_style_lang-d2acacf0.js";import{U as Pe}from"./UploadText-28892309.js";import"./Blocks-f0129fcd.js";import"./IconButton-abe5ede9.js";const Ce=t=>{let e=["B","KB","MB","GB","PB"],n=0;for(;t>1024;)t/=1024,n++;let l=e[n];return t.toFixed(1)+" "+l},le=t=>{var e;return e=t.orig_name||t.name,e.length>30?`${e.substr(0,30)}...`:e},te=t=>{var e=0;if(Array.isArray(t))for(var n of t)n.size!==void 0&&(e+=n.size);else e=t.size||0;return Ce(e)};function ne(t,e,n){const l=t.slice();return l[4]=e[n],l[6]=n,l}function Re(t){let e;return{c(){e=D("Uploading...")},m(n,l){U(n,e,l)},p:q,d(n){n&&j(e)}}}function qe(t){let e,n,l,s;return{c(){e=O("a"),n=D("Download"),F(e,"href",l=t[4].data),F(e,"target","_blank"),F(e,"download",s=window.__is_colab__?null:t[4].orig_name||t[4].name),F(e,"class","svelte-xrr240")},m(a,i){U(a,e,i),z(e,n)},p(a,i){i&1&&l!==(l=a[4].data)&&F(e,"href",l),i&1&&s!==(s=window.__is_colab__?null:a[4].orig_name||a[4].name)&&F(e,"download",s)},d(a){a&&j(e)}}}function se(t){let e,n,l=le(t[4])+"",s,a,i,f=te(t[4])+"",r,g,o,m,_,b;function B(c,E){return c[4].data?qe:Re}let w=B(t),A=w(t);function T(){return t[3](t[4],t[6])}return{c(){e=O("tr"),n=O("td"),s=D(l),a=S(),i=O("td"),r=D(f),g=S(),o=O("td"),A.c(),m=S(),F(n,"class","svelte-xrr240"),F(i,"class","svelte-xrr240"),F(o,"class","download svelte-xrr240"),F(e,"class","file svelte-xrr240"),$(e,"selectable",t[1])},m(c,E){U(c,e,E),z(e,n),z(n,s),z(e,a),z(e,i),z(i,r),z(e,g),z(e,o),A.m(o,null),z(e,m),_||(b=ge(e,"click",T),_=!0)},p(c,E){t=c,E&1&&l!==(l=le(t[4])+"")&&x(s,l),E&1&&f!==(f=te(t[4])+"")&&x(r,f),w===(w=B(t))&&A?A.p(t,E):(A.d(1),A=w(t),A&&(A.c(),A.m(o,null))),E&2&&$(e,"selectable",t[1])},d(c){c&&j(e),A.d(),_=!1,b()}}}function De(t){let e,n,l,s=Z(Array.isArray(t[0])?t[0]:[t[0]]),a=[];for(let i=0;i<s.length;i+=1)a[i]=se(ne(t,s,i));return{c(){e=O("div"),n=O("table"),l=O("tbody");for(let i=0;i<a.length;i+=1)a[i].c();F(n,"class","file-preview svelte-xrr240"),F(e,"class","file-preview-holder svelte-xrr240")},m(i,f){U(i,e,f),z(e,n),z(n,l);for(let r=0;r<a.length;r+=1)a[r]&&a[r].m(l,null)},p(i,[f]){if(f&7){s=Z(Array.isArray(i[0])?i[0]:[i[0]]);let r;for(r=0;r<s.length;r+=1){const g=ne(i,s,r);a[r]?a[r].p(g,f):(a[r]=se(g),a[r].c(),a[r].m(l,null))}for(;r<a.length;r+=1)a[r].d(1);a.length=s.length}},i:q,o:q,d(i){i&&j(e),be(a,i)}}}function Ge(t,e,n){const l=K();let{value:s}=e,{selectable:a=!1}=e;const i=(f,r)=>l("select",{value:f.orig_name||f.name,index:r});return t.$$set=f=>{"value"in f&&n(0,s=f.value),"selectable"in f&&n(1,a=f.selectable)},[s,a,l,i]}class ie extends G{constructor(e){super(),I(this,e,Ge,De,J,{value:0,selectable:1})}}function Ie(t){let e,n;return e=new Oe({props:{unpadded_box:!0,size:"large",$$slots:{default:[Ke]},$$scope:{ctx:t}}}),{c(){p(e.$$.fragment)},m(l,s){v(e,l,s),n=!0},p(l,s){const a={};s&32&&(a.$$scope={dirty:s,ctx:l}),e.$set(a)},i(l){n||(h(e.$$.fragment,l),n=!0)},o(l){d(e.$$.fragment,l),n=!1},d(l){y(e,l)}}}function Je(t){let e,n;return e=new ie({props:{selectable:t[3],value:t[0]}}),e.$on("select",t[4]),{c(){p(e.$$.fragment)},m(l,s){v(e,l,s),n=!0},p(l,s){const a={};s&8&&(a.selectable=l[3]),s&1&&(a.value=l[0]),e.$set(a)},i(l){n||(h(e.$$.fragment,l),n=!0)},o(l){d(e.$$.fragment,l),n=!1},d(l){y(e,l)}}}function Ke(t){let e,n;return e=new W({}),{c(){p(e.$$.fragment)},m(l,s){v(e,l,s),n=!0},i(l){n||(h(e.$$.fragment,l),n=!0)},o(l){d(e.$$.fragment,l),n=!1},d(l){y(e,l)}}}function Le(t){let e,n,l,s,a,i;e=new ae({props:{show_label:t[2],float:t[0]===null,Icon:W,label:t[1]||"File"}});const f=[Je,Ie],r=[];function g(o,m){return o[0]?0:1}return l=g(t),s=r[l]=f[l](t),{c(){p(e.$$.fragment),n=S(),s.c(),a=L()},m(o,m){v(e,o,m),U(o,n,m),r[l].m(o,m),U(o,a,m),i=!0},p(o,[m]){const _={};m&4&&(_.show_label=o[2]),m&1&&(_.float=o[0]===null),m&2&&(_.label=o[1]||"File"),e.$set(_);let b=l;l=g(o),l===b?r[l].p(o,m):(Q(),d(r[b],1,1,()=>{r[b]=null}),V(),s=r[l],s?s.p(o,m):(s=r[l]=f[l](o),s.c()),h(s,1),s.m(a.parentNode,a))},i(o){i||(h(e.$$.fragment,o),h(s),i=!0)},o(o){d(e.$$.fragment,o),d(s),i=!1},d(o){o&&(j(n),j(a)),y(e,o),r[l].d(o)}}}function Qe(t,e,n){let{value:l=null}=e,{label:s}=e,{show_label:a=!0}=e,{selectable:i=!1}=e;function f(r){C.call(this,t,r)}return t.$$set=r=>{"value"in r&&n(0,l=r.value),"label"in r&&n(1,s=r.label),"show_label"in r&&n(2,a=r.show_label),"selectable"in r&&n(3,i=r.selectable)},[l,s,a,i,f]}class Ve extends G{constructor(e){super(),I(this,e,Qe,Le,J,{value:0,label:1,show_label:2,selectable:3})}}function We(t){let e,n,l;function s(i){t[12](i)}let a={filetype:t[6],parse_to_data_url:!1,file_count:t[3],$$slots:{default:[Xe]},$$scope:{ctx:t}};return t[5]!==void 0&&(a.dragging=t[5]),e=new Se({props:a}),he.push(()=>we(e,"dragging",s)),e.$on("load",t[7]),{c(){p(e.$$.fragment)},m(i,f){v(e,i,f),l=!0},p(i,f){const r={};f&64&&(r.filetype=i[6]),f&8&&(r.file_count=i[3]),f&8192&&(r.$$scope={dirty:f,ctx:i}),!n&&f&32&&(n=!0,r.dragging=i[5],ke(()=>n=!1)),e.$set(r)},i(i){l||(h(e.$$.fragment,i),l=!0)},o(i){d(e.$$.fragment,i),l=!1},d(i){y(e,i)}}}function He(t){let e,n,l,s;return e=new Te({props:{absolute:!0}}),e.$on("clear",t[8]),l=new ie({props:{selectable:t[4],value:t[0]}}),l.$on("select",t[11]),{c(){p(e.$$.fragment),n=S(),p(l.$$.fragment)},m(a,i){v(e,a,i),U(a,n,i),v(l,a,i),s=!0},p(a,i){const f={};i&16&&(f.selectable=a[4]),i&1&&(f.value=a[0]),l.$set(f)},i(a){s||(h(e.$$.fragment,a),h(l.$$.fragment,a),s=!0)},o(a){d(e.$$.fragment,a),d(l.$$.fragment,a),s=!1},d(a){a&&j(n),y(e,a),y(l,a)}}}function Xe(t){let e;const n=t[10].default,l=Ae(n,t,t[13],null);return{c(){l&&l.c()},m(s,a){l&&l.m(s,a),e=!0},p(s,a){l&&l.p&&(!e||a&8192)&&pe(l,n,s,s[13],e?ye(n,s[13],a,null):ve(s[13]),null)},i(s){e||(h(l,s),e=!0)},o(s){d(l,s),e=!1},d(s){l&&l.d(s)}}}function Ye(t){let e,n,l,s,a,i;e=new ae({props:{show_label:t[2],Icon:W,float:t[0]===null,label:t[1]||"File"}});const f=[He,We],r=[];function g(o,m){return o[0]?0:1}return l=g(t),s=r[l]=f[l](t),{c(){p(e.$$.fragment),n=S(),s.c(),a=L()},m(o,m){v(e,o,m),U(o,n,m),r[l].m(o,m),U(o,a,m),i=!0},p(o,[m]){const _={};m&4&&(_.show_label=o[2]),m&1&&(_.float=o[0]===null),m&2&&(_.label=o[1]||"File"),e.$set(_);let b=l;l=g(o),l===b?r[l].p(o,m):(Q(),d(r[b],1,1,()=>{r[b]=null}),V(),s=r[l],s?s.p(o,m):(s=r[l]=f[l](o),s.c()),h(s,1),s.m(a.parentNode,a))},i(o){i||(h(e.$$.fragment,o),h(s),i=!0)},o(o){d(e.$$.fragment,o),d(s),i=!1},d(o){o&&(j(n),j(a)),y(e,o),r[l].d(o)}}}function Ze(t,e,n){let{$$slots:l={},$$scope:s}=e,{value:a}=e,{label:i}=e,{show_label:f=!0}=e,{file_count:r="single"}=e,{file_types:g=null}=e,{selectable:o=!1}=e;async function m({detail:c}){n(0,a=c),await de(),b("change",a),b("upload",c)}function _({detail:c}){n(0,a=null),b("change",a),b("clear")}const b=K();let B;g==null?B=null:(g=g.map(c=>c.startsWith(".")?c:c+"/*"),B=g.join(", "));let w=!1;function A(c){C.call(this,t,c)}function T(c){w=c,n(5,w)}return t.$$set=c=>{"value"in c&&n(0,a=c.value),"label"in c&&n(1,i=c.label),"show_label"in c&&n(2,f=c.show_label),"file_count"in c&&n(3,r=c.file_count),"file_types"in c&&n(9,g=c.file_types),"selectable"in c&&n(4,o=c.selectable),"$$scope"in c&&n(13,s=c.$$scope)},t.$$.update=()=>{t.$$.dirty&32&&b("drag",w)},[a,i,f,r,o,w,B,m,_,g,l,A,T,s]}class $e extends G{constructor(e){super(),I(this,e,Ze,Ye,J,{value:0,label:1,show_label:2,file_count:3,file_types:9,selectable:4})}}function xe(t){let e,n;return e=new Ve({props:{selectable:t[9],value:t[14],label:t[5],show_label:t[6]}}),e.$on("select",t[24]),{c(){p(e.$$.fragment)},m(l,s){v(e,l,s),n=!0},p(l,s){const a={};s&512&&(a.selectable=l[9]),s&16384&&(a.value=l[14]),s&32&&(a.label=l[5]),s&64&&(a.show_label=l[6]),e.$set(a)},i(l){n||(h(e.$$.fragment,l),n=!0)},o(l){d(e.$$.fragment,l),n=!1},d(l){y(e,l)}}}function el(t){let e,n;return e=new $e({props:{label:t[5],show_label:t[6],value:t[14],file_count:t[7],file_types:t[8],selectable:t[9],$$slots:{default:[ll]},$$scope:{ctx:t}}}),e.$on("change",t[20]),e.$on("drag",t[21]),e.$on("clear",t[22]),e.$on("select",t[23]),{c(){p(e.$$.fragment)},m(l,s){v(e,l,s),n=!0},p(l,s){const a={};s&32&&(a.label=l[5]),s&64&&(a.show_label=l[6]),s&16384&&(a.value=l[14]),s&128&&(a.file_count=l[7]),s&256&&(a.file_types=l[8]),s&512&&(a.selectable=l[9]),s&134217728&&(a.$$scope={dirty:s,ctx:l}),e.$set(a)},i(l){n||(h(e.$$.fragment,l),n=!0)},o(l){d(e.$$.fragment,l),n=!1},d(l){y(e,l)}}}function ll(t){let e,n;return e=new Pe({props:{type:"file"}}),{c(){p(e.$$.fragment)},m(l,s){v(e,l,s),n=!0},p:q,i(l){n||(h(e.$$.fragment,l),n=!0)},o(l){d(e.$$.fragment,l),n=!1},d(l){y(e,l)}}}function tl(t){let e,n,l,s,a,i;const f=[t[10],{status:t[16]?"generating":t[10]?.status||"complete"}];let r={};for(let _=0;_<f.length;_+=1)r=ze(r,f[_]);e=new Ue({props:r});const g=[el,xe],o=[];function m(_,b){return _[4]==="dynamic"?0:1}return l=m(t),s=o[l]=g[l](t),{c(){p(e.$$.fragment),n=S(),s.c(),a=L()},m(_,b){v(e,_,b),U(_,n,b),o[l].m(_,b),U(_,a,b),i=!0},p(_,b){const B=b&66560?je(f,[b&1024&&Ee(_[10]),{status:_[16]?"generating":_[10]?.status||"complete"}]):{};e.$set(B);let w=l;l=m(_),l===w?o[l].p(_,b):(Q(),d(o[w],1,1,()=>{o[w]=null}),V(),s=o[l],s?s.p(_,b):(s=o[l]=g[l](_),s.c()),h(s,1),s.m(a.parentNode,a))},i(_){i||(h(e.$$.fragment,_),h(s),i=!0)},o(_){d(e.$$.fragment,_),d(s),i=!1},d(_){_&&(j(n),j(a)),y(e,_),o[l].d(_)}}}function nl(t){let e,n;return e=new Ne({props:{visible:t[3],variant:t[4]==="dynamic"&&t[0]===null?"dashed":"solid",border_mode:t[15]?"focus":"base",padding:!1,elem_id:t[1],elem_classes:t[2],container:t[11],scale:t[12],min_width:t[13],$$slots:{default:[tl]},$$scope:{ctx:t}}}),{c(){p(e.$$.fragment)},m(l,s){v(e,l,s),n=!0},p(l,[s]){const a={};s&8&&(a.visible=l[3]),s&17&&(a.variant=l[4]==="dynamic"&&l[0]===null?"dashed":"solid"),s&32768&&(a.border_mode=l[15]?"focus":"base"),s&2&&(a.elem_id=l[1]),s&4&&(a.elem_classes=l[2]),s&2048&&(a.container=l[11]),s&4096&&(a.scale=l[12]),s&8192&&(a.min_width=l[13]),s&134334449&&(a.$$scope={dirty:s,ctx:l}),e.$set(a)},i(l){n||(h(e.$$.fragment,l),n=!0)},o(l){d(e.$$.fragment,l),n=!1},d(l){y(e,l)}}}function sl(t,e,n){let l,{elem_id:s=""}=e,{elem_classes:a=[]}=e,{visible:i=!0}=e,{value:f}=e,r,{mode:g}=e,{root:o}=e,{label:m}=e,{show_label:_}=e,{file_count:b}=e,{file_types:B=["file"]}=e,{root_url:w}=e,{selectable:A=!1}=e,{loading_status:T}=e,{container:c=!0}=e,{scale:E=null}=e,{min_width:H=void 0}=e;const re=Fe("upload_files")??Be;let X=!1,M=!1;const R=K(),oe=({detail:u})=>n(0,f=u),fe=({detail:u})=>n(15,X=u);function ue(u){C.call(this,t,u)}function _e(u){C.call(this,t,u)}function ce(u){C.call(this,t,u)}return t.$$set=u=>{"elem_id"in u&&n(1,s=u.elem_id),"elem_classes"in u&&n(2,a=u.elem_classes),"visible"in u&&n(3,i=u.visible),"value"in u&&n(0,f=u.value),"mode"in u&&n(4,g=u.mode),"root"in u&&n(17,o=u.root),"label"in u&&n(5,m=u.label),"show_label"in u&&n(6,_=u.show_label),"file_count"in u&&n(7,b=u.file_count),"file_types"in u&&n(8,B=u.file_types),"root_url"in u&&n(18,w=u.root_url),"selectable"in u&&n(9,A=u.selectable),"loading_status"in u&&n(10,T=u.loading_status),"container"in u&&n(11,c=u.container),"scale"in u&&n(12,E=u.scale),"min_width"in u&&n(13,H=u.min_width)},t.$$.update=()=>{if(t.$$.dirty&393217&&n(14,l=ee(f,o,w)),t.$$.dirty&933905&&JSON.stringify(l)!==JSON.stringify(r)){if(n(19,r=l),l===null)R("change"),n(16,M=!1);else if(!(Array.isArray(l)?l:[l]).every(u=>u.blob))n(16,M=!1),R("change");else if(g==="dynamic"){let u=(Array.isArray(l)?l:[l]).map(P=>P.blob),me=l;n(16,M=!0),re(o,u).then(P=>{me===l&&(n(16,M=!1),P.error?(Array.isArray(l)?l:[l]).forEach(async(N,Y)=>{N.data=await Me(N.blob),N.blob=void 0}):((Array.isArray(l)?l:[l]).forEach((N,Y)=>{P.files&&(N.orig_name=N.name,N.name=P.files[Y],N.is_file=!0,N.blob=void 0)}),n(19,r=n(14,l=ee(f,o,w)))),R("change"),R("upload"))})}}},[f,s,a,i,g,m,_,b,B,A,T,c,E,H,l,X,M,o,w,r,oe,fe,ue,_e,ce]}class al extends G{constructor(e){super(),I(this,e,sl,nl,J,{elem_id:1,elem_classes:2,visible:3,value:0,mode:4,root:17,label:5,show_label:6,file_count:7,file_types:8,root_url:18,selectable:9,loading_status:10,container:11,scale:12,min_width:13})}get elem_id(){return this.$$.ctx[1]}set elem_id(e){this.$$set({elem_id:e}),k()}get elem_classes(){return this.$$.ctx[2]}set elem_classes(e){this.$$set({elem_classes:e}),k()}get visible(){return this.$$.ctx[3]}set visible(e){this.$$set({visible:e}),k()}get value(){return this.$$.ctx[0]}set value(e){this.$$set({value:e}),k()}get mode(){return this.$$.ctx[4]}set mode(e){this.$$set({mode:e}),k()}get root(){return this.$$.ctx[17]}set root(e){this.$$set({root:e}),k()}get label(){return this.$$.ctx[5]}set label(e){this.$$set({label:e}),k()}get show_label(){return this.$$.ctx[6]}set show_label(e){this.$$set({show_label:e}),k()}get file_count(){return this.$$.ctx[7]}set file_count(e){this.$$set({file_count:e}),k()}get file_types(){return this.$$.ctx[8]}set file_types(e){this.$$set({file_types:e}),k()}get root_url(){return this.$$.ctx[18]}set root_url(e){this.$$set({root_url:e}),k()}get selectable(){return this.$$.ctx[9]}set selectable(e){this.$$set({selectable:e}),k()}get loading_status(){return this.$$.ctx[10]}set loading_status(e){this.$$set({loading_status:e}),k()}get container(){return this.$$.ctx[11]}set container(e){this.$$set({container:e}),k()}get scale(){return this.$$.ctx[12]}set scale(e){this.$$set({scale:e}),k()}get min_width(){return this.$$.ctx[13]}set min_width(e){this.$$set({min_width:e}),k()}}const hl=al,wl=["static","dynamic"],kl=t=>({type:{input_payload:"{ name: string; data: string }",response_object:"{ orig_name: string; name: string, size: number, data: string, is_file: boolean}"},description:{input_payload:"object with file name and base64 data",response_object:"object that includes path to file. The URL: {ROOT}file={name} contains the data"},example_data:{name:"zip.zip",data:"data:@file/octet-stream;base64,UEsFBgAAAAAAAAAAAAAAAAAAAAAAAA=="}});export{hl as Component,kl as document,wl as modes};
-//# sourceMappingURL=index-6f7117a6.js.map

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/frontend/assets/index-be790e2e.css

@@ -1 +0,0 @@
-.rangeSlider{--pip:var(--range-pip, lightslategray);--pip-text:var(--range-pip-text, var(--pip));--pip-active:var(--range-pip-active, darkslategrey);--pip-active-text:var(--range-pip-active-text, var(--pip-active));--pip-hover:var(--range-pip-hover, darkslategrey);--pip-hover-text:var(--range-pip-hover-text, var(--pip-hover));--pip-in-range:var(--range-pip-in-range, var(--pip-active));--pip-in-range-text:var(--range-pip-in-range-text, var(--pip-active-text))}.rangePips{position:absolute;height:1em;left:0;right:0;bottom:-1em}.rangePips.vertical{height:auto;width:1em;inset:0 auto 0 100%}.rangePips .pip{height:.4em;position:absolute;top:.25em;width:1px;white-space:nowrap}.rangePips.vertical .pip{height:1px;width:.4em;left:.25em;top:auto;bottom:auto}.rangePips .pipVal{position:absolute;top:.4em;transform:translate(-50%,25%)}.rangePips.vertical .pipVal{position:absolute;top:0;left:.4em;transform:translate(25%,-50%)}.rangePips .pip{transition:all .15s ease}.rangePips .pipVal{transition:all .15s ease,font-weight 0s linear}.rangePips .pip{color:#789;color:var(--pip-text);background-color:#789;background-color:var(--pip)}.rangePips .pip.selected{color:#2f4f4f;color:var(--pip-active-text);background-color:#2f4f4f;background-color:var(--pip-active)}.rangePips.hoverable:not(.disabled) .pip:hover{color:#2f4f4f;color:var(--pip-hover-text);background-color:#2f4f4f;background-color:var(--pip-hover)}.rangePips .pip.in-range{color:#2f4f4f;color:var(--pip-in-range-text);background-color:#2f4f4f;background-color:var(--pip-in-range)}.rangePips .pip.selected{height:.75em}.rangePips.vertical .pip.selected{height:1px;width:.75em}.rangePips .pip.selected .pipVal{font-weight:700;top:.75em}.rangePips.vertical .pip.selected .pipVal{top:0;left:.75em}.rangePips.hoverable:not(.disabled) .pip:not(.selected):hover{transition:none}.rangePips.hoverable:not(.disabled) .pip:not(.selected):hover .pipVal{transition:none;font-weight:700}.rangeSlider{--slider:var(--range-slider, #d7dada);--handle-inactive:var(--range-handle-inactive, #99a2a2);--handle:var(--range-handle, #838de7);--handle-focus:var(--range-handle-focus, #4a40d4);--handle-border:var(--range-handle-border, var(--handle));--range-inactive:var(--range-range-inactive, var(--handle-inactive));--range:var(--range-range, var(--handle-focus));--float-inactive:var(--range-float-inactive, var(--handle-inactive));--float:var(--range-float, var(--handle-focus));--float-text:var(--range-float-text, white)}.rangeSlider{position:relative;border-radius:100px;height:.5em;margin:1em;transition:opacity .2s ease;user-select:none}.rangeSlider *{user-select:none}.rangeSlider.pips{margin-bottom:1.8em}.rangeSlider.pip-labels{margin-bottom:2.8em}.rangeSlider.vertical{display:inline-block;border-radius:100px;width:.5em;min-height:200px}.rangeSlider.vertical.pips{margin-right:1.8em;margin-bottom:1em}.rangeSlider.vertical.pip-labels{margin-right:2.8em;margin-bottom:1em}.rangeSlider .rangeHandle{position:absolute;display:block;height:1.4em;width:1.4em;top:.25em;bottom:auto;transform:translateY(-50%) translate(-50%);z-index:2}.rangeSlider.reversed .rangeHandle{transform:translateY(-50%) translate(50%)}.rangeSlider.vertical .rangeHandle{left:.25em;top:auto;transform:translateY(50%) translate(-50%)}.rangeSlider.vertical.reversed .rangeHandle{transform:translateY(-50%) translate(-50%)}.rangeSlider .rangeNub,.rangeSlider .rangeHandle:before{position:absolute;left:0;top:0;display:block;border-radius:10em;height:100%;width:100%;transition:box-shadow .2s ease}.rangeSlider .rangeHandle:before{content:"";inset:1px;height:auto;width:auto;box-shadow:0 0 0 0 var(--handle-border);opacity:0}.rangeSlider.hoverable:not(.disabled) .rangeHandle:hover:before{box-shadow:0 0 0 8px var(--handle-border);opacity:.2}.rangeSlider.hoverable:not(.disabled) .rangeHandle.press:before,.rangeSlider.hoverable:not(.disabled) .rangeHandle.press:hover:before{box-shadow:0 0 0 12px var(--handle-border);opacity:.4}.rangeSlider.range:not(.min):not(.max) .rangeNub{border-radius:10em 10em 10em 1.6em}.rangeSlider.range .rangeHandle:nth-of-type(1) .rangeNub{transform:rotate(-135deg)}.rangeSlider.range .rangeHandle:nth-of-type(2) .rangeNub{transform:rotate(45deg)}.rangeSlider.range.reversed .rangeHandle:nth-of-type(1) .rangeNub{transform:rotate(45deg)}.rangeSlider.range.reversed .rangeHandle:nth-of-type(2) .rangeNub{transform:rotate(-135deg)}.rangeSlider.range.vertical .rangeHandle:nth-of-type(1) .rangeNub{transform:rotate(135deg)}.rangeSlider.range.vertical .rangeHandle:nth-of-type(2) .rangeNub{transform:rotate(-45deg)}.rangeSlider.range.vertical.reversed .rangeHandle:nth-of-type(1) .rangeNub{transform:rotate(-45deg)}.rangeSlider.range.vertical.reversed .rangeHandle:nth-of-type(2) .rangeNub{transform:rotate(135deg)}.rangeSlider .rangeFloat{display:block;position:absolute;left:50%;top:-.5em;transform:translate(-50%,-100%);font-size:1em;text-align:center;opacity:0;pointer-events:none;white-space:nowrap;transition:all .2s ease;font-size:.9em;padding:.2em .4em;border-radius:.2em}.rangeSlider .rangeHandle.active .rangeFloat,.rangeSlider.hoverable .rangeHandle:hover .rangeFloat{opacity:1;top:-.2em;transform:translate(-50%,-100%)}.rangeSlider .rangeBar{position:absolute;display:block;transition:background .2s ease;border-radius:1em;height:.5em;top:0;user-select:none;z-index:1}.rangeSlider.vertical .rangeBar{width:.5em;height:auto}.rangeSlider{background-color:#d7dada;background-color:var(--slider)}.rangeSlider .rangeBar{background-color:#99a2a2;background-color:var(--range-inactive)}.rangeSlider.focus .rangeBar{background-color:#838de7;background-color:var(--range)}.rangeSlider .rangeNub{background-color:#99a2a2;background-color:var(--handle-inactive)}.rangeSlider.focus .rangeNub{background-color:#838de7;background-color:var(--handle)}.rangeSlider .rangeHandle.active .rangeNub{background-color:#4a40d4;background-color:var(--handle-focus)}.rangeSlider .rangeFloat{color:#fff;color:var(--float-text);background-color:#99a2a2;background-color:var(--float-inactive)}.rangeSlider.focus .rangeFloat{background-color:#4a40d4;background-color:var(--float)}.rangeSlider.disabled{opacity:.5}.rangeSlider.disabled .rangeNub{background-color:#d7dada;background-color:var(--slider)}.mic-wrap.svelte-1thnwz{padding:var(--size-2)}.record-icon.svelte-1thnwz{display:flex;position:relative;margin-right:var(--size-2);width:6px;height:6px}.dot.svelte-1thnwz{display:inline-flex;position:relative;border-radius:var(--radius-full);background:var(--color-red-500);width:6px;height:6px}.pinger.svelte-1thnwz{display:inline-flex;position:absolute;opacity:.9;animation:svelte-1thnwz-ping 1s cubic-bezier(0,0,.2,1) infinite;border-radius:var(--radius-full);background:var(--color-red-500);width:var(--size-full);height:var(--size-full)}@keyframes svelte-1thnwz-ping{75%,to{transform:scale(2);opacity:0}}audio.svelte-1thnwz{padding:var(--size-2);width:var(--size-full);height:var(--size-14)}audio.svelte-1yfus5a{padding:var(--size-2);width:var(--size-full);height:var(--size-14)}.icon-button.svelte-1yfus5a{position:absolute;top:6px;right:6px}

spaces/DaleChen/AutoGPT/autogpt/processing/html.py

@@ -1,33 +0,0 @@
-"""HTML processing functions"""
-from __future__ import annotations
-
-from bs4 import BeautifulSoup
-from requests.compat import urljoin
-
-
-def extract_hyperlinks(soup: BeautifulSoup, base_url: str) -> list[tuple[str, str]]:
-    """Extract hyperlinks from a BeautifulSoup object
-
-    Args:
-        soup (BeautifulSoup): The BeautifulSoup object
-        base_url (str): The base URL
-
-    Returns:
-        List[Tuple[str, str]]: The extracted hyperlinks
-    """
-    return [
-        (link.text, urljoin(base_url, link["href"]))
-        for link in soup.find_all("a", href=True)
-    ]
-
-
-def format_hyperlinks(hyperlinks: list[tuple[str, str]]) -> list[str]:
-    """Format hyperlinks to be displayed to the user
-
-    Args:
-        hyperlinks (List[Tuple[str, str]]): The hyperlinks to format
-
-    Returns:
-        List[str]: The formatted hyperlinks
-    """
-    return [f"{link_text} ({link_url})" for link_text, link_url in hyperlinks]

spaces/Dantra1/CeliaSensei/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/Datasculptor/DescriptionGPT/tools/download_cc.py

@@ -1,47 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import os
-import json
-import argparse
-from PIL import Image
-import numpy as np
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--ann', default='datasets/cc3m/Train_GCC-training.tsv')
-    parser.add_argument('--save_image_path', default='datasets/cc3m/training/')
-    parser.add_argument('--cat_info', default='datasets/lvis/lvis_v1_val.json')
-    parser.add_argument('--out_path', default='datasets/cc3m/train_image_info.json')
-    parser.add_argument('--not_download_image', action='store_true')
-    args = parser.parse_args()
-    categories = json.load(open(args.cat_info, 'r'))['categories']
-    images = []
-    if not os.path.exists(args.save_image_path):
-        os.makedirs(args.save_image_path)
-    f = open(args.ann)
-    for i, line in enumerate(f):
-        cap, path = line[:-1].split('\t')
-        print(i, cap, path)
-        if not args.not_download_image:
-            os.system(
-                'wget {} -O {}/{}.jpg'.format(
-                    path, args.save_image_path, i + 1))
-        try:
-            img = Image.open(
-                open('{}/{}.jpg'.format(args.save_image_path, i + 1), "rb"))
-            img = np.asarray(img.convert("RGB"))
-            h, w = img.shape[:2]
-        except:
-            continue
-        image_info = {
-            'id': i + 1,
-            'file_name': '{}.jpg'.format(i + 1),
-            'height': h,
-            'width': w,
-            'captions': [cap],
-        }
-        images.append(image_info)
-    data = {'categories': categories, 'images': images, 'annotations': []}
-    for k, v in data.items():
-        print(k, len(v))
-    print('Saving to', args.out_path)
-    json.dump(data, open(args.out_path, 'w'))

spaces/Datasculptor/MusicGen/tests/utils/__init__.py

@@ -1,5 +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.

spaces/Datasculptor/StyleGAN-NADA/e4e/models/psp.py

@@ -1,99 +0,0 @@
-import matplotlib
-
-matplotlib.use('Agg')
-import torch
-from torch import nn
-from e4e.models.encoders import psp_encoders
-from e4e.models.stylegan2.model import Generator
-from e4e.configs.paths_config import model_paths
-
-
-def get_keys(d, name):
-    if 'state_dict' in d:
-        d = d['state_dict']
-    d_filt = {k[len(name) + 1:]: v for k, v in d.items() if k[:len(name)] == name}
-    return d_filt
-
-
-class pSp(nn.Module):
-
-    def __init__(self, opts, device):
-        super(pSp, self).__init__()
-        self.opts = opts
-        self.device = device
-        # Define architecture
-        self.encoder = self.set_encoder()
-        self.decoder = Generator(opts.stylegan_size, 512, 8, channel_multiplier=2)
-        self.face_pool = torch.nn.AdaptiveAvgPool2d((256, 256))
-        # Load weights if needed
-        self.load_weights()
-
-    def set_encoder(self):
-        if self.opts.encoder_type == 'GradualStyleEncoder':
-            encoder = psp_encoders.GradualStyleEncoder(50, 'ir_se', self.opts)
-        elif self.opts.encoder_type == 'Encoder4Editing':
-            encoder = psp_encoders.Encoder4Editing(50, 'ir_se', self.opts)
-        else:
-            raise Exception('{} is not a valid encoders'.format(self.opts.encoder_type))
-        return encoder
-
-    def load_weights(self):
-        if self.opts.checkpoint_path is not None:
-            print('Loading e4e over the pSp framework from checkpoint: {}'.format(self.opts.checkpoint_path))
-            ckpt = torch.load(self.opts.checkpoint_path, map_location='cpu')
-            self.encoder.load_state_dict(get_keys(ckpt, 'encoder'), strict=True)
-            self.decoder.load_state_dict(get_keys(ckpt, 'decoder'), strict=True)
-            self.__load_latent_avg(ckpt)
-        else:
-            print('Loading encoders weights from irse50!')
-            encoder_ckpt = torch.load(model_paths['ir_se50'])
-            self.encoder.load_state_dict(encoder_ckpt, strict=False)
-            print('Loading decoder weights from pretrained!')
-            ckpt = torch.load(self.opts.stylegan_weights)
-            self.decoder.load_state_dict(ckpt['g_ema'], strict=False)
-            self.__load_latent_avg(ckpt, repeat=self.encoder.style_count)
-
-    def forward(self, x, resize=True, latent_mask=None, input_code=False, randomize_noise=True,
-                inject_latent=None, return_latents=False, alpha=None):
-        if input_code:
-            codes = x
-        else:
-            codes = self.encoder(x)
-            # normalize with respect to the center of an average face
-            if self.opts.start_from_latent_avg:
-                if codes.ndim == 2:
-                    codes = codes + self.latent_avg.repeat(codes.shape[0], 1, 1)[:, 0, :]
-                else:
-                    codes = codes + self.latent_avg.repeat(codes.shape[0], 1, 1)
-
-        if latent_mask is not None:
-            for i in latent_mask:
-                if inject_latent is not None:
-                    if alpha is not None:
-                        codes[:, i] = alpha * inject_latent[:, i] + (1 - alpha) * codes[:, i]
-                    else:
-                        codes[:, i] = inject_latent[:, i]
-                else:
-                    codes[:, i] = 0
-
-        input_is_latent = not input_code
-        images, result_latent = self.decoder([codes],
-                                             input_is_latent=input_is_latent,
-                                             randomize_noise=randomize_noise,
-                                             return_latents=return_latents)
-
-        if resize:
-            images = self.face_pool(images)
-
-        if return_latents:
-            return images, result_latent
-        else:
-            return images
-
-    def __load_latent_avg(self, ckpt, repeat=None):
-        if 'latent_avg' in ckpt:
-            self.latent_avg = ckpt['latent_avg'].to(self.device)
-            if repeat is not None:
-                self.latent_avg = self.latent_avg.repeat(repeat, 1)
-        else:
-            self.latent_avg = None

spaces/DeepDrivePL/PaddleSeg-Matting/matting/model/hrnet.py

@@ -1,835 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import math
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-from paddleseg.cvlibs import manager, param_init
-from paddleseg.models import layers
-from paddleseg.utils import utils
-
-__all__ = [
-    "HRNet_W18_Small_V1", "HRNet_W18_Small_V2", "HRNet_W18", "HRNet_W30",
-    "HRNet_W32", "HRNet_W40", "HRNet_W44", "HRNet_W48", "HRNet_W60", "HRNet_W64"
-]
-
-
-class HRNet(nn.Layer):
-    """
-    The HRNet implementation based on PaddlePaddle.
-
-    The original article refers to
-    Jingdong Wang, et, al. "HRNet：Deep High-Resolution Representation Learning for Visual Recognition"
-    (https://arxiv.org/pdf/1908.07919.pdf).
-
-    Args:
-        pretrained (str, optional): The path of pretrained model.
-        stage1_num_modules (int, optional): Number of modules for stage1. Default 1.
-        stage1_num_blocks (list, optional): Number of blocks per module for stage1. Default (4).
-        stage1_num_channels (list, optional): Number of channels per branch for stage1. Default (64).
-        stage2_num_modules (int, optional): Number of modules for stage2. Default 1.
-        stage2_num_blocks (list, optional): Number of blocks per module for stage2. Default (4, 4).
-        stage2_num_channels (list, optional): Number of channels per branch for stage2. Default (18, 36).
-        stage3_num_modules (int, optional): Number of modules for stage3. Default 4.
-        stage3_num_blocks (list, optional): Number of blocks per module for stage3. Default (4, 4, 4).
-        stage3_num_channels (list, optional): Number of channels per branch for stage3. Default [18, 36, 72).
-        stage4_num_modules (int, optional): Number of modules for stage4. Default 3.
-        stage4_num_blocks (list, optional): Number of blocks per module for stage4. Default (4, 4, 4, 4).
-        stage4_num_channels (list, optional): Number of channels per branch for stage4. Default (18, 36, 72. 144).
-        has_se (bool, optional): Whether to use Squeeze-and-Excitation module. Default False.
-        align_corners (bool, optional): An argument of F.interpolate. It should be set to False when the feature size is even,
-            e.g. 1024x512, otherwise it is True, e.g. 769x769. Default: False.
-    """
-
-    def __init__(self,
-                 input_channels=3,
-                 pretrained=None,
-                 stage1_num_modules=1,
-                 stage1_num_blocks=(4, ),
-                 stage1_num_channels=(64, ),
-                 stage2_num_modules=1,
-                 stage2_num_blocks=(4, 4),
-                 stage2_num_channels=(18, 36),
-                 stage3_num_modules=4,
-                 stage3_num_blocks=(4, 4, 4),
-                 stage3_num_channels=(18, 36, 72),
-                 stage4_num_modules=3,
-                 stage4_num_blocks=(4, 4, 4, 4),
-                 stage4_num_channels=(18, 36, 72, 144),
-                 has_se=False,
-                 align_corners=False,
-                 padding_same=True):
-        super(HRNet, self).__init__()
-        self.pretrained = pretrained
-        self.stage1_num_modules = stage1_num_modules
-        self.stage1_num_blocks = stage1_num_blocks
-        self.stage1_num_channels = stage1_num_channels
-        self.stage2_num_modules = stage2_num_modules
-        self.stage2_num_blocks = stage2_num_blocks
-        self.stage2_num_channels = stage2_num_channels
-        self.stage3_num_modules = stage3_num_modules
-        self.stage3_num_blocks = stage3_num_blocks
-        self.stage3_num_channels = stage3_num_channels
-        self.stage4_num_modules = stage4_num_modules
-        self.stage4_num_blocks = stage4_num_blocks
-        self.stage4_num_channels = stage4_num_channels
-        self.has_se = has_se
-        self.align_corners = align_corners
-
-        self.feat_channels = [i for i in stage4_num_channels]
-        self.feat_channels = [64] + self.feat_channels
-
-        self.conv_layer1_1 = layers.ConvBNReLU(
-            in_channels=input_channels,
-            out_channels=64,
-            kernel_size=3,
-            stride=2,
-            padding=1 if not padding_same else 'same',
-            bias_attr=False)
-
-        self.conv_layer1_2 = layers.ConvBNReLU(
-            in_channels=64,
-            out_channels=64,
-            kernel_size=3,
-            stride=2,
-            padding=1 if not padding_same else 'same',
-            bias_attr=False)
-
-        self.la1 = Layer1(
-            num_channels=64,
-            num_blocks=self.stage1_num_blocks[0],
-            num_filters=self.stage1_num_channels[0],
-            has_se=has_se,
-            name="layer2",
-            padding_same=padding_same)
-
-        self.tr1 = TransitionLayer(
-            in_channels=[self.stage1_num_channels[0] * 4],
-            out_channels=self.stage2_num_channels,
-            name="tr1",
-            padding_same=padding_same)
-
-        self.st2 = Stage(
-            num_channels=self.stage2_num_channels,
-            num_modules=self.stage2_num_modules,
-            num_blocks=self.stage2_num_blocks,
-            num_filters=self.stage2_num_channels,
-            has_se=self.has_se,
-            name="st2",
-            align_corners=align_corners,
-            padding_same=padding_same)
-
-        self.tr2 = TransitionLayer(
-            in_channels=self.stage2_num_channels,
-            out_channels=self.stage3_num_channels,
-            name="tr2",
-            padding_same=padding_same)
-        self.st3 = Stage(
-            num_channels=self.stage3_num_channels,
-            num_modules=self.stage3_num_modules,
-            num_blocks=self.stage3_num_blocks,
-            num_filters=self.stage3_num_channels,
-            has_se=self.has_se,
-            name="st3",
-            align_corners=align_corners,
-            padding_same=padding_same)
-
-        self.tr3 = TransitionLayer(
-            in_channels=self.stage3_num_channels,
-            out_channels=self.stage4_num_channels,
-            name="tr3",
-            padding_same=padding_same)
-        self.st4 = Stage(
-            num_channels=self.stage4_num_channels,
-            num_modules=self.stage4_num_modules,
-            num_blocks=self.stage4_num_blocks,
-            num_filters=self.stage4_num_channels,
-            has_se=self.has_se,
-            name="st4",
-            align_corners=align_corners,
-            padding_same=padding_same)
-
-        self.init_weight()
-
-    def forward(self, x):
-        feat_list = []
-        conv1 = self.conv_layer1_1(x)
-        feat_list.append(conv1)
-        conv2 = self.conv_layer1_2(conv1)
-
-        la1 = self.la1(conv2)
-
-        tr1 = self.tr1([la1])
-        st2 = self.st2(tr1)
-
-        tr2 = self.tr2(st2)
-        st3 = self.st3(tr2)
-
-        tr3 = self.tr3(st3)
-        st4 = self.st4(tr3)
-
-        feat_list = feat_list + st4
-
-        return feat_list
-
-    def init_weight(self):
-        for layer in self.sublayers():
-            if isinstance(layer, nn.Conv2D):
-                param_init.normal_init(layer.weight, std=0.001)
-            elif isinstance(layer, (nn.BatchNorm, nn.SyncBatchNorm)):
-                param_init.constant_init(layer.weight, value=1.0)
-                param_init.constant_init(layer.bias, value=0.0)
-        if self.pretrained is not None:
-            utils.load_pretrained_model(self, self.pretrained)
-
-
-class Layer1(nn.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 num_blocks,
-                 has_se=False,
-                 name=None,
-                 padding_same=True):
-        super(Layer1, self).__init__()
-
-        self.bottleneck_block_list = []
-
-        for i in range(num_blocks):
-            bottleneck_block = self.add_sublayer(
-                "bb_{}_{}".format(name, i + 1),
-                BottleneckBlock(
-                    num_channels=num_channels if i == 0 else num_filters * 4,
-                    num_filters=num_filters,
-                    has_se=has_se,
-                    stride=1,
-                    downsample=True if i == 0 else False,
-                    name=name + '_' + str(i + 1),
-                    padding_same=padding_same))
-            self.bottleneck_block_list.append(bottleneck_block)
-
-    def forward(self, x):
-        conv = x
-        for block_func in self.bottleneck_block_list:
-            conv = block_func(conv)
-        return conv
-
-
-class TransitionLayer(nn.Layer):
-    def __init__(self, in_channels, out_channels, name=None, padding_same=True):
-        super(TransitionLayer, self).__init__()
-
-        num_in = len(in_channels)
-        num_out = len(out_channels)
-        self.conv_bn_func_list = []
-        for i in range(num_out):
-            residual = None
-            if i < num_in:
-                if in_channels[i] != out_channels[i]:
-                    residual = self.add_sublayer(
-                        "transition_{}_layer_{}".format(name, i + 1),
-                        layers.ConvBNReLU(
-                            in_channels=in_channels[i],
-                            out_channels=out_channels[i],
-                            kernel_size=3,
-                            padding=1 if not padding_same else 'same',
-                            bias_attr=False))
-            else:
-                residual = self.add_sublayer(
-                    "transition_{}_layer_{}".format(name, i + 1),
-                    layers.ConvBNReLU(
-                        in_channels=in_channels[-1],
-                        out_channels=out_channels[i],
-                        kernel_size=3,
-                        stride=2,
-                        padding=1 if not padding_same else 'same',
-                        bias_attr=False))
-            self.conv_bn_func_list.append(residual)
-
-    def forward(self, x):
-        outs = []
-        for idx, conv_bn_func in enumerate(self.conv_bn_func_list):
-            if conv_bn_func is None:
-                outs.append(x[idx])
-            else:
-                if idx < len(x):
-                    outs.append(conv_bn_func(x[idx]))
-                else:
-                    outs.append(conv_bn_func(x[-1]))
-        return outs
-
-
-class Branches(nn.Layer):
-    def __init__(self,
-                 num_blocks,
-                 in_channels,
-                 out_channels,
-                 has_se=False,
-                 name=None,
-                 padding_same=True):
-        super(Branches, self).__init__()
-
-        self.basic_block_list = []
-
-        for i in range(len(out_channels)):
-            self.basic_block_list.append([])
-            for j in range(num_blocks[i]):
-                in_ch = in_channels[i] if j == 0 else out_channels[i]
-                basic_block_func = self.add_sublayer(
-                    "bb_{}_branch_layer_{}_{}".format(name, i + 1, j + 1),
-                    BasicBlock(
-                        num_channels=in_ch,
-                        num_filters=out_channels[i],
-                        has_se=has_se,
-                        name=name + '_branch_layer_' + str(i + 1) + '_' +
-                        str(j + 1),
-                        padding_same=padding_same))
-                self.basic_block_list[i].append(basic_block_func)
-
-    def forward(self, x):
-        outs = []
-        for idx, input in enumerate(x):
-            conv = input
-            for basic_block_func in self.basic_block_list[idx]:
-                conv = basic_block_func(conv)
-            outs.append(conv)
-        return outs
-
-
-class BottleneckBlock(nn.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 has_se,
-                 stride=1,
-                 downsample=False,
-                 name=None,
-                 padding_same=True):
-        super(BottleneckBlock, self).__init__()
-
-        self.has_se = has_se
-        self.downsample = downsample
-
-        self.conv1 = layers.ConvBNReLU(
-            in_channels=num_channels,
-            out_channels=num_filters,
-            kernel_size=1,
-            bias_attr=False)
-
-        self.conv2 = layers.ConvBNReLU(
-            in_channels=num_filters,
-            out_channels=num_filters,
-            kernel_size=3,
-            stride=stride,
-            padding=1 if not padding_same else 'same',
-            bias_attr=False)
-
-        self.conv3 = layers.ConvBN(
-            in_channels=num_filters,
-            out_channels=num_filters * 4,
-            kernel_size=1,
-            bias_attr=False)
-
-        if self.downsample:
-            self.conv_down = layers.ConvBN(
-                in_channels=num_channels,
-                out_channels=num_filters * 4,
-                kernel_size=1,
-                bias_attr=False)
-
-        if self.has_se:
-            self.se = SELayer(
-                num_channels=num_filters * 4,
-                num_filters=num_filters * 4,
-                reduction_ratio=16,
-                name=name + '_fc')
-
-        self.add = layers.Add()
-        self.relu = layers.Activation("relu")
-
-    def forward(self, x):
-        residual = x
-        conv1 = self.conv1(x)
-        conv2 = self.conv2(conv1)
-        conv3 = self.conv3(conv2)
-
-        if self.downsample:
-            residual = self.conv_down(x)
-
-        if self.has_se:
-            conv3 = self.se(conv3)
-
-        y = self.add(conv3, residual)
-        y = self.relu(y)
-        return y
-
-
-class BasicBlock(nn.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_filters,
-                 stride=1,
-                 has_se=False,
-                 downsample=False,
-                 name=None,
-                 padding_same=True):
-        super(BasicBlock, self).__init__()
-
-        self.has_se = has_se
-        self.downsample = downsample
-
-        self.conv1 = layers.ConvBNReLU(
-            in_channels=num_channels,
-            out_channels=num_filters,
-            kernel_size=3,
-            stride=stride,
-            padding=1 if not padding_same else 'same',
-            bias_attr=False)
-        self.conv2 = layers.ConvBN(
-            in_channels=num_filters,
-            out_channels=num_filters,
-            kernel_size=3,
-            padding=1 if not padding_same else 'same',
-            bias_attr=False)
-
-        if self.downsample:
-            self.conv_down = layers.ConvBNReLU(
-                in_channels=num_channels,
-                out_channels=num_filters,
-                kernel_size=1,
-                bias_attr=False)
-
-        if self.has_se:
-            self.se = SELayer(
-                num_channels=num_filters,
-                num_filters=num_filters,
-                reduction_ratio=16,
-                name=name + '_fc')
-
-        self.add = layers.Add()
-        self.relu = layers.Activation("relu")
-
-    def forward(self, x):
-        residual = x
-        conv1 = self.conv1(x)
-        conv2 = self.conv2(conv1)
-
-        if self.downsample:
-            residual = self.conv_down(x)
-
-        if self.has_se:
-            conv2 = self.se(conv2)
-
-        y = self.add(conv2, residual)
-        y = self.relu(y)
-        return y
-
-
-class SELayer(nn.Layer):
-    def __init__(self, num_channels, num_filters, reduction_ratio, name=None):
-        super(SELayer, self).__init__()
-
-        self.pool2d_gap = nn.AdaptiveAvgPool2D(1)
-
-        self._num_channels = num_channels
-
-        med_ch = int(num_channels / reduction_ratio)
-        stdv = 1.0 / math.sqrt(num_channels * 1.0)
-        self.squeeze = nn.Linear(
-            num_channels,
-            med_ch,
-            weight_attr=paddle.ParamAttr(
-                initializer=nn.initializer.Uniform(-stdv, stdv)))
-
-        stdv = 1.0 / math.sqrt(med_ch * 1.0)
-        self.excitation = nn.Linear(
-            med_ch,
-            num_filters,
-            weight_attr=paddle.ParamAttr(
-                initializer=nn.initializer.Uniform(-stdv, stdv)))
-
-    def forward(self, x):
-        pool = self.pool2d_gap(x)
-        pool = paddle.reshape(pool, shape=[-1, self._num_channels])
-        squeeze = self.squeeze(pool)
-        squeeze = F.relu(squeeze)
-        excitation = self.excitation(squeeze)
-        excitation = F.sigmoid(excitation)
-        excitation = paddle.reshape(
-            excitation, shape=[-1, self._num_channels, 1, 1])
-        out = x * excitation
-        return out
-
-
-class Stage(nn.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_modules,
-                 num_blocks,
-                 num_filters,
-                 has_se=False,
-                 multi_scale_output=True,
-                 name=None,
-                 align_corners=False,
-                 padding_same=True):
-        super(Stage, self).__init__()
-
-        self._num_modules = num_modules
-
-        self.stage_func_list = []
-        for i in range(num_modules):
-            if i == num_modules - 1 and not multi_scale_output:
-                stage_func = self.add_sublayer(
-                    "stage_{}_{}".format(name, i + 1),
-                    HighResolutionModule(
-                        num_channels=num_channels,
-                        num_blocks=num_blocks,
-                        num_filters=num_filters,
-                        has_se=has_se,
-                        multi_scale_output=False,
-                        name=name + '_' + str(i + 1),
-                        align_corners=align_corners,
-                        padding_same=padding_same))
-            else:
-                stage_func = self.add_sublayer(
-                    "stage_{}_{}".format(name, i + 1),
-                    HighResolutionModule(
-                        num_channels=num_channels,
-                        num_blocks=num_blocks,
-                        num_filters=num_filters,
-                        has_se=has_se,
-                        name=name + '_' + str(i + 1),
-                        align_corners=align_corners,
-                        padding_same=padding_same))
-
-            self.stage_func_list.append(stage_func)
-
-    def forward(self, x):
-        out = x
-        for idx in range(self._num_modules):
-            out = self.stage_func_list[idx](out)
-        return out
-
-
-class HighResolutionModule(nn.Layer):
-    def __init__(self,
-                 num_channels,
-                 num_blocks,
-                 num_filters,
-                 has_se=False,
-                 multi_scale_output=True,
-                 name=None,
-                 align_corners=False,
-                 padding_same=True):
-        super(HighResolutionModule, self).__init__()
-
-        self.branches_func = Branches(
-            num_blocks=num_blocks,
-            in_channels=num_channels,
-            out_channels=num_filters,
-            has_se=has_se,
-            name=name,
-            padding_same=padding_same)
-
-        self.fuse_func = FuseLayers(
-            in_channels=num_filters,
-            out_channels=num_filters,
-            multi_scale_output=multi_scale_output,
-            name=name,
-            align_corners=align_corners,
-            padding_same=padding_same)
-
-    def forward(self, x):
-        out = self.branches_func(x)
-        out = self.fuse_func(out)
-        return out
-
-
-class FuseLayers(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 multi_scale_output=True,
-                 name=None,
-                 align_corners=False,
-                 padding_same=True):
-        super(FuseLayers, self).__init__()
-
-        self._actual_ch = len(in_channels) if multi_scale_output else 1
-        self._in_channels = in_channels
-        self.align_corners = align_corners
-
-        self.residual_func_list = []
-        for i in range(self._actual_ch):
-            for j in range(len(in_channels)):
-                if j > i:
-                    residual_func = self.add_sublayer(
-                        "residual_{}_layer_{}_{}".format(name, i + 1, j + 1),
-                        layers.ConvBN(
-                            in_channels=in_channels[j],
-                            out_channels=out_channels[i],
-                            kernel_size=1,
-                            bias_attr=False))
-                    self.residual_func_list.append(residual_func)
-                elif j < i:
-                    pre_num_filters = in_channels[j]
-                    for k in range(i - j):
-                        if k == i - j - 1:
-                            residual_func = self.add_sublayer(
-                                "residual_{}_layer_{}_{}_{}".format(
-                                    name, i + 1, j + 1, k + 1),
-                                layers.ConvBN(
-                                    in_channels=pre_num_filters,
-                                    out_channels=out_channels[i],
-                                    kernel_size=3,
-                                    stride=2,
-                                    padding=1 if not padding_same else 'same',
-                                    bias_attr=False))
-                            pre_num_filters = out_channels[i]
-                        else:
-                            residual_func = self.add_sublayer(
-                                "residual_{}_layer_{}_{}_{}".format(
-                                    name, i + 1, j + 1, k + 1),
-                                layers.ConvBNReLU(
-                                    in_channels=pre_num_filters,
-                                    out_channels=out_channels[j],
-                                    kernel_size=3,
-                                    stride=2,
-                                    padding=1 if not padding_same else 'same',
-                                    bias_attr=False))
-                            pre_num_filters = out_channels[j]
-                        self.residual_func_list.append(residual_func)
-
-    def forward(self, x):
-        outs = []
-        residual_func_idx = 0
-        for i in range(self._actual_ch):
-            residual = x[i]
-            residual_shape = paddle.shape(residual)[-2:]
-            for j in range(len(self._in_channels)):
-                if j > i:
-                    y = self.residual_func_list[residual_func_idx](x[j])
-                    residual_func_idx += 1
-
-                    y = F.interpolate(
-                        y,
-                        residual_shape,
-                        mode='bilinear',
-                        align_corners=self.align_corners)
-                    residual = residual + y
-                elif j < i:
-                    y = x[j]
-                    for k in range(i - j):
-                        y = self.residual_func_list[residual_func_idx](y)
-                        residual_func_idx += 1
-
-                    residual = residual + y
-
-            residual = F.relu(residual)
-            outs.append(residual)
-
-        return outs
-
-
-@manager.BACKBONES.add_component
-def HRNet_W18_Small_V1(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[1],
-        stage1_num_channels=[32],
-        stage2_num_modules=1,
-        stage2_num_blocks=[2, 2],
-        stage2_num_channels=[16, 32],
-        stage3_num_modules=1,
-        stage3_num_blocks=[2, 2, 2],
-        stage3_num_channels=[16, 32, 64],
-        stage4_num_modules=1,
-        stage4_num_blocks=[2, 2, 2, 2],
-        stage4_num_channels=[16, 32, 64, 128],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W18_Small_V2(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[2],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[2, 2],
-        stage2_num_channels=[18, 36],
-        stage3_num_modules=3,
-        stage3_num_blocks=[2, 2, 2],
-        stage3_num_channels=[18, 36, 72],
-        stage4_num_modules=2,
-        stage4_num_blocks=[2, 2, 2, 2],
-        stage4_num_channels=[18, 36, 72, 144],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W18(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[4],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[4, 4],
-        stage2_num_channels=[18, 36],
-        stage3_num_modules=4,
-        stage3_num_blocks=[4, 4, 4],
-        stage3_num_channels=[18, 36, 72],
-        stage4_num_modules=3,
-        stage4_num_blocks=[4, 4, 4, 4],
-        stage4_num_channels=[18, 36, 72, 144],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W30(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[4],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[4, 4],
-        stage2_num_channels=[30, 60],
-        stage3_num_modules=4,
-        stage3_num_blocks=[4, 4, 4],
-        stage3_num_channels=[30, 60, 120],
-        stage4_num_modules=3,
-        stage4_num_blocks=[4, 4, 4, 4],
-        stage4_num_channels=[30, 60, 120, 240],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W32(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[4],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[4, 4],
-        stage2_num_channels=[32, 64],
-        stage3_num_modules=4,
-        stage3_num_blocks=[4, 4, 4],
-        stage3_num_channels=[32, 64, 128],
-        stage4_num_modules=3,
-        stage4_num_blocks=[4, 4, 4, 4],
-        stage4_num_channels=[32, 64, 128, 256],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W40(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[4],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[4, 4],
-        stage2_num_channels=[40, 80],
-        stage3_num_modules=4,
-        stage3_num_blocks=[4, 4, 4],
-        stage3_num_channels=[40, 80, 160],
-        stage4_num_modules=3,
-        stage4_num_blocks=[4, 4, 4, 4],
-        stage4_num_channels=[40, 80, 160, 320],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W44(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[4],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[4, 4],
-        stage2_num_channels=[44, 88],
-        stage3_num_modules=4,
-        stage3_num_blocks=[4, 4, 4],
-        stage3_num_channels=[44, 88, 176],
-        stage4_num_modules=3,
-        stage4_num_blocks=[4, 4, 4, 4],
-        stage4_num_channels=[44, 88, 176, 352],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W48(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[4],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[4, 4],
-        stage2_num_channels=[48, 96],
-        stage3_num_modules=4,
-        stage3_num_blocks=[4, 4, 4],
-        stage3_num_channels=[48, 96, 192],
-        stage4_num_modules=3,
-        stage4_num_blocks=[4, 4, 4, 4],
-        stage4_num_channels=[48, 96, 192, 384],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W60(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[4],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[4, 4],
-        stage2_num_channels=[60, 120],
-        stage3_num_modules=4,
-        stage3_num_blocks=[4, 4, 4],
-        stage3_num_channels=[60, 120, 240],
-        stage4_num_modules=3,
-        stage4_num_blocks=[4, 4, 4, 4],
-        stage4_num_channels=[60, 120, 240, 480],
-        **kwargs)
-    return model
-
-
-@manager.BACKBONES.add_component
-def HRNet_W64(**kwargs):
-    model = HRNet(
-        stage1_num_modules=1,
-        stage1_num_blocks=[4],
-        stage1_num_channels=[64],
-        stage2_num_modules=1,
-        stage2_num_blocks=[4, 4],
-        stage2_num_channels=[64, 128],
-        stage3_num_modules=4,
-        stage3_num_blocks=[4, 4, 4],
-        stage3_num_channels=[64, 128, 256],
-        stage4_num_modules=3,
-        stage4_num_blocks=[4, 4, 4, 4],
-        stage4_num_channels=[64, 128, 256, 512],
-        **kwargs)
-    return model

spaces/Detomo/ai-comic-generation/src/lib/useImageDimension.ts

@@ -1,20 +0,0 @@
-import { useEffect, useState } from "react"
-
-import { ImageDimension, getImageDimension } from "./getImageDimension"
-
-export function useImageDimension(src: string) {
-  const [dimension, setDimension] = useState<ImageDimension>({
-    width: 0,
-    height: 0,
-  })
-
-  useEffect(() => {
-    const compute = async () => {
-      const newDimension = await getImageDimension(src)
-      setDimension(newDimension)
-    }
-    compute()
-  }, [src])
-
-  return dimension
-}

spaces/Dineshdc/MygenAIChatbot/README.md

@@ -1,12 +0,0 @@
----
-title: MygenAIChatbot
-emoji: 📊
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.39.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/DragGan/DragGan/stylegan_human/pti/pti_models/e4e/stylegan2/model.py

@@ -1,680 +0,0 @@
-import math
-import random
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from .op.fused_act import FusedLeakyReLU, fused_leaky_relu
-from .op.upfirdn2d import upfirdn2d
-
-
-class PixelNorm(nn.Module):
-    def __init__(self):
-        super().__init__()
-
-    def forward(self, input):
-        return input * torch.rsqrt(torch.mean(input ** 2, dim=1, keepdim=True) + 1e-8)
-
-
-def make_kernel(k):
-    k = torch.tensor(k, dtype=torch.float32)
-
-    if k.ndim == 1:
-        k = k[None, :] * k[:, None]
-
-    k /= k.sum()
-
-    return k
-
-
-class Upsample(nn.Module):
-    def __init__(self, kernel, factor=2):
-        super().__init__()
-
-        self.factor = factor
-        kernel = make_kernel(kernel) * (factor ** 2)
-        self.register_buffer('kernel', kernel)
-
-        p = kernel.shape[0] - factor
-
-        pad0 = (p + 1) // 2 + factor - 1
-        pad1 = p // 2
-
-        self.pad = (pad0, pad1)
-
-    def forward(self, input):
-        out = upfirdn2d(input, self.kernel, up=self.factor, down=1, pad=self.pad)
-
-        return out
-
-
-class Downsample(nn.Module):
-    def __init__(self, kernel, factor=2):
-        super().__init__()
-
-        self.factor = factor
-        kernel = make_kernel(kernel)
-        self.register_buffer('kernel', kernel)
-
-        p = kernel.shape[0] - factor
-
-        pad0 = (p + 1) // 2
-        pad1 = p // 2
-
-        self.pad = (pad0, pad1)
-
-    def forward(self, input):
-        out = upfirdn2d(input, self.kernel, up=1, down=self.factor, pad=self.pad)
-
-        return out
-
-
-class Blur(nn.Module):
-    def __init__(self, kernel, pad, upsample_factor=1):
-        super().__init__()
-
-        kernel = make_kernel(kernel)
-
-        if upsample_factor > 1:
-            kernel = kernel * (upsample_factor ** 2)
-
-        self.register_buffer('kernel', kernel)
-
-        self.pad = pad
-
-    def forward(self, input):
-        out = upfirdn2d(input, self.kernel, pad=self.pad)
-
-        return out
-
-
-class EqualConv2d(nn.Module):
-    def __init__(
-            self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=True
-    ):
-        super().__init__()
-
-        self.weight = nn.Parameter(
-            torch.randn(out_channel, in_channel, kernel_size, kernel_size)
-        )
-        self.scale = 1 / math.sqrt(in_channel * kernel_size ** 2)
-
-        self.stride = stride
-        self.padding = padding
-
-        if bias:
-            self.bias = nn.Parameter(torch.zeros(out_channel))
-
-        else:
-            self.bias = None
-
-    def forward(self, input):
-        out = F.conv2d(
-            input,
-            self.weight * self.scale,
-            bias=self.bias,
-            stride=self.stride,
-            padding=self.padding,
-        )
-
-        return out
-
-    def __repr__(self):
-        return (
-            f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]},'
-            f' {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})'
-        )
-
-
-class EqualLinear(nn.Module):
-    def __init__(
-            self, in_dim, out_dim, bias=True, bias_init=0, lr_mul=1, activation=None
-    ):
-        super().__init__()
-
-        self.weight = nn.Parameter(torch.randn(out_dim, in_dim).div_(lr_mul))
-
-        if bias:
-            self.bias = nn.Parameter(torch.zeros(out_dim).fill_(bias_init))
-
-        else:
-            self.bias = None
-
-        self.activation = activation
-
-        self.scale = (1 / math.sqrt(in_dim)) * lr_mul
-        self.lr_mul = lr_mul
-
-    def forward(self, input):
-        if self.activation:
-            out = F.linear(input, self.weight * self.scale)
-            out = fused_leaky_relu(out, self.bias * self.lr_mul)
-
-        else:
-            out = F.linear(
-                input, self.weight * self.scale, bias=self.bias * self.lr_mul
-            )
-
-        return out
-
-    def __repr__(self):
-        return (
-            f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]})'
-        )
-
-
-class ScaledLeakyReLU(nn.Module):
-    def __init__(self, negative_slope=0.2):
-        super().__init__()
-
-        self.negative_slope = negative_slope
-
-    def forward(self, input):
-        out = F.leaky_relu(input, negative_slope=self.negative_slope)
-
-        return out * math.sqrt(2)
-
-
-class ModulatedConv2d(nn.Module):
-    def __init__(
-            self,
-            in_channel,
-            out_channel,
-            kernel_size,
-            style_dim,
-            demodulate=True,
-            upsample=False,
-            downsample=False,
-            blur_kernel=[1, 3, 3, 1],
-    ):
-        super().__init__()
-
-        self.eps = 1e-8
-        self.kernel_size = kernel_size
-        self.in_channel = in_channel
-        self.out_channel = out_channel
-        self.upsample = upsample
-        self.downsample = downsample
-
-        if upsample:
-            factor = 2
-            p = (len(blur_kernel) - factor) - (kernel_size - 1)
-            pad0 = (p + 1) // 2 + factor - 1
-            pad1 = p // 2 + 1
-
-            self.blur = Blur(blur_kernel, pad=(pad0, pad1), upsample_factor=factor)
-
-        if downsample:
-            factor = 2
-            p = (len(blur_kernel) - factor) + (kernel_size - 1)
-            pad0 = (p + 1) // 2
-            pad1 = p // 2
-
-            self.blur = Blur(blur_kernel, pad=(pad0, pad1))
-
-        fan_in = in_channel * kernel_size ** 2
-        self.scale = 1 / math.sqrt(fan_in)
-        self.padding = kernel_size // 2
-
-        self.weight = nn.Parameter(
-            torch.randn(1, out_channel, in_channel, kernel_size, kernel_size)
-        )
-
-        self.modulation = EqualLinear(style_dim, in_channel, bias_init=1)
-
-        self.demodulate = demodulate
-
-    def __repr__(self):
-        return (
-            f'{self.__class__.__name__}({self.in_channel}, {self.out_channel}, {self.kernel_size}, '
-            f'upsample={self.upsample}, downsample={self.downsample})'
-        )
-
-    def forward(self, input, style):
-        batch, in_channel, height, width = input.shape
-
-        style = self.modulation(style).view(batch, 1, in_channel, 1, 1)
-        weight = self.scale * self.weight * style
-
-        if self.demodulate:
-            demod = torch.rsqrt(weight.pow(2).sum([2, 3, 4]) + 1e-8)
-            weight = weight * demod.view(batch, self.out_channel, 1, 1, 1)
-
-        weight = weight.view(
-            batch * self.out_channel, in_channel, self.kernel_size, self.kernel_size
-        )
-
-        if self.upsample:
-            input = input.view(1, batch * in_channel, height, width)
-            weight = weight.view(
-                batch, self.out_channel, in_channel, self.kernel_size, self.kernel_size
-            )
-            weight = weight.transpose(1, 2).reshape(
-                batch * in_channel, self.out_channel, self.kernel_size, self.kernel_size
-            )
-            out = F.conv_transpose2d(input, weight, padding=0, stride=2, groups=batch)
-            _, _, height, width = out.shape
-            out = out.view(batch, self.out_channel, height, width)
-            out = self.blur(out)
-
-        elif self.downsample:
-            input = self.blur(input)
-            _, _, height, width = input.shape
-            input = input.view(1, batch * in_channel, height, width)
-            out = F.conv2d(input, weight, padding=0, stride=2, groups=batch)
-            _, _, height, width = out.shape
-            out = out.view(batch, self.out_channel, height, width)
-
-        else:
-            input = input.view(1, batch * in_channel, height, width)
-            out = F.conv2d(input, weight, padding=self.padding, groups=batch)
-            _, _, height, width = out.shape
-            out = out.view(batch, self.out_channel, height, width)
-
-        return out
-
-
-class NoiseInjection(nn.Module):
-    def __init__(self):
-        super().__init__()
-
-        self.weight = nn.Parameter(torch.zeros(1))
-
-    def forward(self, image, noise=None):
-        if noise is None:
-            batch, _, height, width = image.shape
-            noise = image.new_empty(batch, 1, height, width).normal_()
-
-        return image + self.weight * noise
-
-
-class ConstantInput(nn.Module):
-    def __init__(self, channel, size=4):
-        super().__init__()
-
-        self.input = nn.Parameter(torch.randn(1, channel, size, size // 2))
-
-    def forward(self, input):
-        batch = input.shape[0]
-        out = self.input.repeat(batch, 1, 1, 1)
-
-        return out
-
-
-class StyledConv(nn.Module):
-    def __init__(
-            self,
-            in_channel,
-            out_channel,
-            kernel_size,
-            style_dim,
-            upsample=False,
-            blur_kernel=[1, 3, 3, 1],
-            demodulate=True,
-    ):
-        super().__init__()
-
-        self.conv = ModulatedConv2d(
-            in_channel,
-            out_channel,
-            kernel_size,
-            style_dim,
-            upsample=upsample,
-            blur_kernel=blur_kernel,
-            demodulate=demodulate,
-        )
-
-        self.noise = NoiseInjection()
-        # self.bias = nn.Parameter(torch.zeros(1, out_channel, 1, 1))
-        # self.activate = ScaledLeakyReLU(0.2)
-        self.activate = FusedLeakyReLU(out_channel)
-
-    def forward(self, input, style, noise=None):
-        out = self.conv(input, style)
-        out = self.noise(out, noise=noise)
-        # out = out + self.bias
-        out = self.activate(out)
-
-        return out
-
-
-class ToRGB(nn.Module):
-    def __init__(self, in_channel, style_dim, upsample=True, blur_kernel=[1, 3, 3, 1]):
-        super().__init__()
-
-        if upsample:
-            self.upsample = Upsample(blur_kernel)
-
-        self.conv = ModulatedConv2d(in_channel, 3, 1, style_dim, demodulate=False)
-        self.bias = nn.Parameter(torch.zeros(1, 3, 1, 1))
-
-    def forward(self, input, style, skip=None):
-        out = self.conv(input, style)
-        out = out + self.bias
-
-        if skip is not None:
-            skip = self.upsample(skip)
-
-            out = out + skip
-
-        return out
-
-
-class Generator(nn.Module):
-    def __init__(
-            self,
-            size,
-            style_dim,
-            n_mlp,
-            channel_multiplier=2,
-            blur_kernel=[1, 3, 3, 1],
-            lr_mlp=0.01,
-    ):
-        super().__init__()
-
-        self.size = size
-
-        self.style_dim = style_dim
-
-        layers = [PixelNorm()]
-
-        for i in range(n_mlp):
-            layers.append(
-                EqualLinear(
-                    style_dim, style_dim, lr_mul=lr_mlp, activation='fused_lrelu'
-                )
-            )
-
-        self.style = nn.Sequential(*layers)
-
-        self.channels = {
-            4: 512,
-            8: 512,
-            16: 512,
-            32: 512,
-            64: 256 * channel_multiplier,
-            128: 128 * channel_multiplier,
-            256: 64 * channel_multiplier,
-            512: 32 * channel_multiplier,
-            1024: 16 * channel_multiplier,
-        }
-
-        self.input = ConstantInput(self.channels[4])
-        self.conv1 = StyledConv(
-            self.channels[4], self.channels[4], 3, style_dim, blur_kernel=blur_kernel
-        )
-        self.to_rgb1 = ToRGB(self.channels[4], style_dim, upsample=False)
-
-        self.log_size = int(math.log(size, 2))
-        self.num_layers = (self.log_size - 2) * 2 + 1
-
-        self.convs = nn.ModuleList()
-        self.upsamples = nn.ModuleList()
-        self.to_rgbs = nn.ModuleList()
-        self.noises = nn.Module()
-
-        in_channel = self.channels[4]
-
-        for layer_idx in range(self.num_layers):
-            res = (layer_idx + 5) // 2
-            shape = [1, 1, 2 ** res, 2 ** res // 2]
-            self.noises.register_buffer(
-                "noise_{}".format(layer_idx), torch.randn(*shape)
-            )
-
-        for i in range(3, self.log_size + 1):
-            out_channel = self.channels[2 ** i]
-
-            self.convs.append(
-                StyledConv(
-                    in_channel,
-                    out_channel,
-                    3,
-                    style_dim,
-                    upsample=True,
-                    blur_kernel=blur_kernel,
-                )
-            )
-
-            self.convs.append(
-                StyledConv(
-                    out_channel, out_channel, 3, style_dim, blur_kernel=blur_kernel
-                )
-            )
-
-            self.to_rgbs.append(ToRGB(out_channel, style_dim))
-
-            in_channel = out_channel
-
-        self.n_latent = self.log_size * 2 - 2
-
-    def make_noise(self):
-        device = self.input.input.device
-
-        noises = [torch.randn(1, 1, 2 ** 2, 2 ** 2 // 2, device=device)]
-
-        for i in range(3, self.log_size + 1):
-            for _ in range(2):
-                noises.append(torch.randn(1, 1, 2 ** i, 2 ** i // 2, device=device))
-
-        return noises
-
-    def mean_latent(self, n_latent):
-        latent_in = torch.randn(
-            n_latent, self.style_dim, device=self.input.input.device
-        )
-        latent = self.style(latent_in).mean(0, keepdim=True)
-
-        return latent
-
-    def get_latent(self, input):
-        return self.style(input)
-
-    def forward(
-            self,
-            styles,
-            return_latents=False,
-            return_features=False,
-            inject_index=None,
-            truncation=1,
-            truncation_latent=None,
-            input_is_latent=False,
-            noise=None,
-            randomize_noise=True,
-    ):
-        if not input_is_latent:
-            styles = [self.style(s) for s in styles]
-
-        if noise is None:
-            if randomize_noise:
-                noise = [None] * self.num_layers
-            else:
-                noise = [
-                    getattr(self.noises, f'noise_{i}') for i in range(self.num_layers)
-                ]
-
-        if truncation < 1:
-            style_t = []
-
-            for style in styles:
-                style_t.append(
-                    truncation_latent + truncation * (style - truncation_latent)
-                )
-
-            styles = style_t
-
-        if len(styles) < 2:
-            inject_index = self.n_latent
-            if styles[0].ndim < 3:
-                latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1)
-            else:
-                latent = styles[0]
-
-        else:
-            if inject_index is None:
-                inject_index = random.randint(1, self.n_latent - 1)
-
-            # latent = styles[0].unsqueeze(0)
-            # if latent.shape[1] == 1:
-            #     latent = latent.repeat(1, inject_index, 1)
-            # else:
-            #     latent = latent[:, :inject_index, :]
-            latent = styles[0].unsqueeze(1).repeat(1, inject_index, 1)
-            latent2 = styles[1].unsqueeze(1).repeat(1, self.n_latent - inject_index, 1)
-            # latent = styles[0][:, :inject_index, :]
-            # latent2 = styles[1][:, inject_index:, :]
-            latent = torch.cat([latent, latent2], 1)
-        out = self.input(latent)
-        out = self.conv1(out, latent[:, 0], noise=noise[0])
-
-        skip = self.to_rgb1(out, latent[:, 1])
-
-        i = 1
-        for conv1, conv2, noise1, noise2, to_rgb in zip(
-                self.convs[::2], self.convs[1::2], noise[1::2], noise[2::2], self.to_rgbs
-        ):
-            out = conv1(out, latent[:, i], noise=noise1)
-            out = conv2(out, latent[:, i + 1], noise=noise2)
-            skip = to_rgb(out, latent[:, i + 2], skip)
-
-            i += 2
-
-        image = skip
-
-        if return_latents:
-            return image, latent
-        elif return_features:
-            return image, out
-        else:
-            return image, None
-
-
-class ConvLayer(nn.Sequential):
-    def __init__(
-            self,
-            in_channel,
-            out_channel,
-            kernel_size,
-            downsample=False,
-            blur_kernel=[1, 3, 3, 1],
-            bias=True,
-            activate=True,
-    ):
-        layers = []
-
-        if downsample:
-            factor = 2
-            p = (len(blur_kernel) - factor) + (kernel_size - 1)
-            pad0 = (p + 1) // 2
-            pad1 = p // 2
-
-            layers.append(Blur(blur_kernel, pad=(pad0, pad1)))
-
-            stride = 2
-            self.padding = 0
-
-        else:
-            stride = 1
-            self.padding = kernel_size // 2
-
-        layers.append(
-            EqualConv2d(
-                in_channel,
-                out_channel,
-                kernel_size,
-                padding=self.padding,
-                stride=stride,
-                bias=bias and not activate,
-            )
-        )
-
-        if activate:
-            if bias:
-                layers.append(FusedLeakyReLU(out_channel))
-
-            else:
-                layers.append(ScaledLeakyReLU(0.2))
-
-        super().__init__(*layers)
-
-
-class ResBlock(nn.Module):
-    def __init__(self, in_channel, out_channel, blur_kernel=[1, 3, 3, 1]):
-        super().__init__()
-
-        self.conv1 = ConvLayer(in_channel, in_channel, 3)
-        self.conv2 = ConvLayer(in_channel, out_channel, 3, downsample=True)
-
-        self.skip = ConvLayer(
-            in_channel, out_channel, 1, downsample=True, activate=False, bias=False
-        )
-
-    def forward(self, input):
-        out = self.conv1(input)
-        out = self.conv2(out)
-
-        skip = self.skip(input)
-        out = (out + skip) / math.sqrt(2)
-
-        return out
-
-
-class Discriminator(nn.Module):
-    def __init__(self, size, channel_multiplier=2, blur_kernel=[1, 3, 3, 1]):
-        super().__init__()
-
-        channels = {
-            4: 512,
-            8: 512,
-            16: 512,
-            32: 512,
-            64: 256 * channel_multiplier,
-            128: 128 * channel_multiplier,
-            256: 64 * channel_multiplier,
-            512: 32 * channel_multiplier,
-            1024: 16 * channel_multiplier,
-        }
-
-        convs = [ConvLayer(3, channels[size], 1)]
-
-        log_size = int(math.log(size, 2))
-
-        in_channel = channels[size]
-
-        for i in range(log_size, 2, -1):
-            out_channel = channels[2 ** (i - 1)]
-
-            convs.append(ResBlock(in_channel, out_channel, blur_kernel))
-
-            in_channel = out_channel
-
-        self.convs = nn.Sequential(*convs)
-
-        self.stddev_group = 4
-        self.stddev_feat = 1
-
-        self.final_conv = ConvLayer(in_channel + 1, channels[4], 3)
-        self.final_linear = nn.Sequential(
-            EqualLinear(channels[4] * 4 * 4 // 2, channels[4], activation='fused_lrelu'),
-            EqualLinear(channels[4], 1),
-        )
-
-    def forward(self, input):
-        out = self.convs(input)
-
-        batch, channel, height, width = out.shape
-        group = min(batch, self.stddev_group)
-        stddev = out.view(
-            group, -1, self.stddev_feat, channel // self.stddev_feat, height, width
-        )
-        stddev = torch.sqrt(stddev.var(0, unbiased=False) + 1e-8)
-        stddev = stddev.mean([2, 3, 4], keepdims=True).squeeze(2)
-        stddev = stddev.repeat(group, 1, height, width)
-        out = torch.cat([out, stddev], 1)
-
-        out = self.final_conv(out)
-
-        out = out.view(batch, -1)
-        out = self.final_linear(out)
-
-        return out