Update parquet files (step 10 of 476)

spaces/17TheWord/RealESRGAN/FAQ.md

@@ -1,9 +0,0 @@
-# FAQ
-
-1. **What is the difference of `--netscale` and `outscale`?**
-
-A: TODO.
-
-1. **How to select models?**
-
-A: TODO.

spaces/17TheWord/RealESRGAN/inference_realesrgan.py

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

spaces/1acneusushi/gradio-2dmoleculeeditor/data/FIFA 22 on Mac Two Ways to Experience the Game of Football.md

@@ -1,50 +0,0 @@
-
-<h1>How to Play FIFA 22 on Mac: A Guide for Football Fans</h1>
-<p>FIFA 22 is the latest installment of the popular football simulation game series developed by EA Sports. It features new gameplay innovations, improved graphics, and more realistic animations powered by HyperMotion technology. However, if you are a Mac user, you might be wondering how to play FIFA 22 on your device, since the game is not officially supported by macOS. In this article, we will show you two ways to play FIFA 22 on Mac: using cloud gaming services or installing Windows 10 on your Mac.</p>
-<h2>What is cloud gaming?</h2>
-<p>Cloud gaming is a technology that allows you to stream games from remote servers to your device via the internet. You don't need to download or install the games on your device, and you don't need to worry about compatibility or hardware requirements. All you need is a stable internet connection and a compatible device, such as a laptop, tablet, smartphone, or smart TV.</p>
-<h2>fifa 22 mac</h2><br /><p><b><b>DOWNLOAD</b> &#9658;&#9658;&#9658;&#9658;&#9658; <a href="https://byltly.com/2uKzLJ">https://byltly.com/2uKzLJ</a></b></p><br /><br />
-<h2>How to play FIFA 22 on Mac using cloud gaming services?</h2>
-<p>There are several cloud gaming services that offer FIFA 22 as part of their library. Two of the most popular ones are Boosteroid and Google Stadia. Here are the steps to play FIFA 22 on Mac using these services:</p>
-<ul>
-<li><strong>Boosteroid</strong>: Boosteroid is a cloud gaming platform that allows you to play PC games on any device with a browser. It supports Windows, Mac OS X, Linux, Android, iOS, and smart TVs. To play FIFA 22 on Mac using Boosteroid, you need to follow these steps:
-<ol>
-<li>Create an account on Boosteroid.com and choose a subscription plan.</li>
-<li>Log in to your account and browse the game library.</li>
-<li>Select FIFA 22 and click on the Play button.</li>
-<li>Enjoy playing FIFA 22 on your Mac with high graphics and low latency.</li>
-</ol>
-</li>
-<li><strong>Google Stadia</strong>: Google Stadia is a cloud gaming service that allows you to play games on various devices using Google Chrome or the Stadia app. It supports Windows, Mac OS X, Linux, Android, iOS, and Chromecast. To play FIFA 22 on Mac using Google Stadia, you need to follow these steps:
-<ol>
-<li>Create an account on Stadia.com and choose a subscription plan.</li>
-<li>Log in to your account and browse the game store.</li>
-<li>Purchase FIFA 22 and click on the Play button.</li>
-<li>Enjoy playing FIFA 22 on your Mac with high graphics and low latency.</li>
-</ol>
-</li>
-</ul>
-<h2>What are the advantages and disadvantages of cloud gaming?</h2>
-<p>Cloud gaming has some advantages and disadvantages that you should consider before choosing this option. Here are some of them:</p>
-<ul>
-<li><strong>Advantages</strong>:
-<ul>
-<li>You don't need to download or install anything on your device.</li>
-<li>You don't need to worry about compatibility or hardware requirements.</li>
-<li>You can play games on any device with a browser or an app.</li>
-<li>You can access a large library of games with different genres and categories.</li>
-<li>You can enjoy high graphics and low latency with a stable internet connection.</li>
-</ul>
-</li>
-<li><strong>Disadvantages</strong>:
-<ul>
-<li>You need a stable and fast internet connection to play games smoothly.</li>
-<li>You may experience lag or buffering if your internet connection is slow or unstable.</li>
-<li>You may not be able to play games offline or without an internet connection.</li>
-<li>You may not be able to mod or customize your games as much as you want.</li>
-<li>You may need to pay a monthly fee or purchase games separately to access them.</li>
-</ul>
-</li>
-</ul></p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Cadence Allegro Extracta Exe Downloa.md

@@ -1,6 +0,0 @@
-<h2>cadence allegro extracta exe downloa</h2><br /><p><b><b>Download</b> &middot;&middot;&middot; <a href="https://imgfil.com/2uy1iG">https://imgfil.com/2uy1iG</a></b></p><br /><br />
-
-There are 2 possibilities for extracting data from Cadence Allegro (and also latest ... for ODB++ which means that you have to download a utility script from Valor. ... All they need to do is to run the executable CDC2FAB in this file structure. 4d29de3e1b<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/FaceRig Pro V1.312 (Inclu ALL DLC) Cheats Tool Download Free.md

@@ -1,6 +0,0 @@
-<h2>FaceRig Pro v1.312 (Inclu ALL DLC) cheats tool download</h2><br /><p><b><b>Download</b> &#128279; <a href="https://imgfil.com/2uxXK0">https://imgfil.com/2uxXK0</a></b></p><br /><br />
-<br />
-Multimedia tools downloads - PluralEyes for Edius by Singular ... As for functionality, If all MS did was update the map data annually, I'd ... Acura Navigation Hack or Torrent DVD Downloads As an ... to dig FaceRig Pro v1.312 (Inclu Live2D Module & DLCs) TORRENT Cracked Free Download in magnet. 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1line/AutoGPT/tests/test_config.py

@@ -1,84 +0,0 @@
-from unittest import TestCase
-
-from autogpt.config import Config
-
-
-class TestConfig(TestCase):
-    """
-    Test cases for the Config class, which handles the configuration settings
-    for the AI and ensures it behaves as a singleton.
-    """
-
-    def setUp(self):
-        """
-        Set up the test environment by creating an instance of the Config class.
-        """
-        self.config = Config()
-
-    def test_singleton(self):
-        """
-        Test if the Config class behaves as a singleton by ensuring that two instances are the same.
-        """
-        config2 = Config()
-        self.assertIs(self.config, config2)
-
-    def test_initial_values(self):
-        """
-        Test if the initial values of the Config class attributes are set correctly.
-        """
-        self.assertFalse(self.config.debug_mode)
-        self.assertFalse(self.config.continuous_mode)
-        self.assertFalse(self.config.speak_mode)
-        self.assertEqual(self.config.fast_llm_model, "gpt-3.5-turbo")
-        self.assertEqual(self.config.smart_llm_model, "gpt-4")
-        self.assertEqual(self.config.fast_token_limit, 4000)
-        self.assertEqual(self.config.smart_token_limit, 8000)
-
-    def test_set_continuous_mode(self):
-        """
-        Test if the set_continuous_mode() method updates the continuous_mode attribute.
-        """
-        self.config.set_continuous_mode(True)
-        self.assertTrue(self.config.continuous_mode)
-
-    def test_set_speak_mode(self):
-        """
-        Test if the set_speak_mode() method updates the speak_mode attribute.
-        """
-        self.config.set_speak_mode(True)
-        self.assertTrue(self.config.speak_mode)
-
-    def test_set_fast_llm_model(self):
-        """
-        Test if the set_fast_llm_model() method updates the fast_llm_model attribute.
-        """
-        self.config.set_fast_llm_model("gpt-3.5-turbo-test")
-        self.assertEqual(self.config.fast_llm_model, "gpt-3.5-turbo-test")
-
-    def test_set_smart_llm_model(self):
-        """
-        Test if the set_smart_llm_model() method updates the smart_llm_model attribute.
-        """
-        self.config.set_smart_llm_model("gpt-4-test")
-        self.assertEqual(self.config.smart_llm_model, "gpt-4-test")
-
-    def test_set_fast_token_limit(self):
-        """
-        Test if the set_fast_token_limit() method updates the fast_token_limit attribute.
-        """
-        self.config.set_fast_token_limit(5000)
-        self.assertEqual(self.config.fast_token_limit, 5000)
-
-    def test_set_smart_token_limit(self):
-        """
-        Test if the set_smart_token_limit() method updates the smart_token_limit attribute.
-        """
-        self.config.set_smart_token_limit(9000)
-        self.assertEqual(self.config.smart_token_limit, 9000)
-
-    def test_set_debug_mode(self):
-        """
-        Test if the set_debug_mode() method updates the debug_mode attribute.
-        """
-        self.config.set_debug_mode(True)
-        self.assertTrue(self.config.debug_mode)

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download Arena of Valor Global and Enjoy Fast and Fun Matches in 15 Minutes or Less.md

@@ -1,155 +0,0 @@
-
-<h1>How to Download Arena of Valor Global: A Guide for MOBA Fans</h1>
-<p>If you are a fan of multiplayer online battle arena (MOBA) games, you might have heard of <strong>Arena of Valor</strong>, an epic 5v5 MOBA game developed by TiMi Studio Group and brought to you by Level Infinite. In this game, you can choose from over 100 unique heroes, team up with your friends, and compete in various modes and maps. Whether you prefer classic 5v5 combat, fast-paced 3v3 action, or solo adventure, there is something for everyone in Arena of Valor.</p>
-<p>But did you know that there is a global version of this game that is available in more than 140 countries and regions? That's right, <strong>Arena of Valor Global</strong> is the ultimate version of this game that lets you play with players from all over the world, enjoy exclusive content and events, and experience the best performance and graphics. If you want to join the millions of players who are already enjoying this game, you might be wondering how to download it. Don't worry, we've got you covered. In this article, we will show you how to download Arena of Valor Global for your Android, iOS, or PC device. We will also share some tips and tricks for playing this game like a pro. So, without further ado, let's get started!</p>
-<h2>download arena of valor global</h2><br /><p><b><b>Download Zip</b> &#9889; <a href="https://urlin.us/2uSRVn">https://urlin.us/2uSRVn</a></b></p><br /><br />
- <h2>What is Arena of Valor Global?</h2>
-<p>Arena of Valor Global is a real-time 5v5 MOBA game that offers a variety of features, modes, and heroes for you to enjoy. Here are some of the highlights of this game:</p>
-<ul>
-<li><strong>Fast & Fun Matches:</strong> You can select a game mode, find opponents, and compete in intense battles that can be completed in 15 minutes or less.</li>
-<li><strong>Fight With Your Friends:</strong> You can team up with your friends, create a guild, and master over 100 unique heroes from internationally acclaimed franchises.</li>
-<li><strong>Battle For Top Ranking:</strong> You can master your heroes, unleash their powers, and defeat your enemies in ranked matches and climb the leaderboards.</li>
-<li><strong>Enjoy Exclusive Content & Events:</strong> You can access exclusive heroes, skins, game modes, and events that are only available in Arena of Valor Global.</li>
-<li><strong>Experience High-Quality Performance & Graphics:</strong> You can play the game with smooth controls, stunning visuals, and immersive sound effects that will make you feel like you are in the middle of the action.</li>
-</ul>
-<p>As you can see, Arena of Valor Global is a game that has something for everyone. Whether you are a casual player or a hardcore gamer, you will find yourself hooked to this game in no time. But before you can start playing, you need to download the game first. Let's see how you can do that for your device.</p>
- <h2>How to Download Arena of Valor Global for Android Devices</h2>
-<p>If you have an Android device, such as a smartphone or a tablet, you can download Arena of Valor Global from the Google Play Store. Here are the steps you need to follow:</p>
-<ol>
-<li>Open the Google Play Store app on your device.</li>
-<li>Search for "Arena of Valor Global" in the search bar.</li>
-<li>Tap on the game icon that appears in the results.</li>
-<li>Tap on the "Install" button and wait for the game to download and install on your device.</li>
-<li>Once the installation is complete, tap on the "Open" button to launch the game and start playing.</li>
-</ol>
-<p>That's it! You have successfully downloaded Arena of Valor Global for your Android device. You can now enjoy the game and join millions of players from around the world. But what if you don't have access to the Google Play Store or you want to download the game from another source? Don't worry, there is another way to download the game using an APK file.</p>
- <h3>How to Download Arena of Valor Global APK File</h3>
-<p>An APK file is a file format that contains all the data and code needed to install an Android app on your device. You can download an APK file from various websites that offer them, such as APKPure, APKMirror, or Uptodown. However, you need to be careful when downloading APK files from unknown sources, as they may contain malware or viruses that can harm your device. To avoid this, you should always scan the APK file with an antivirus app before installing it. Here are the steps you need to follow to download Arena of Valor Global APK file:</p>
-<ol>
-<li>Go to a website that offers Arena of Valor Global APK file, such as <a href="">APKPure</a>.</li>
-<li>Search for "Arena of Valor Global" in the search bar.</li>
-<li>Select the game icon that appears in the results.</li>
-<li>Tap on the "Download APK" button and wait for the file to download on your device.</li>
-<li>Once the download is complete, locate the file in your device's storage and tap on it to install it.</li>
-<li>If you see a warning message that says "For your security, your phone is not allowed to install unknown apps from this source", tap on "Settings" and enable the option that says "Allow from this source".</li>
-<li>Go back to the installation screen and tap on "Install" to proceed with the installation.</li>
-<li>Once the installation is complete, tap on "Open" to launch the game and start playing.</li>
-</ol>
-<p>Congratulations! You have successfully downloaded Arena of Valor Global APK file and installed it on your device. You can now enjoy the game and join millions of players from around the world. But what if you have an iOS device instead of an Android device? Don't worry, we have a solution for that too. Let's see how you can download Arena of Valor Global for your iOS device.</p>
- <h2>How to Download Arena of Valor Global for iOS Devices</h2>
-<p>If you have an iOS device, such as an iPhone or an iPad, you can download Arena of Valor Global from the App Store. Here are the steps you need to follow:</p>
-<p>How to download arena of valor global on android<br />
-Arena of valor global apk download latest version<br />
-Download arena of valor global for pc windows 10<br />
-Arena of valor global tier list 2023<br />
-Best heroes in arena of valor global<br />
-Arena of valor global update patch notes<br />
-Arena of valor global vs mobile legends<br />
-Arena of valor global server status<br />
-Arena of valor global discord server<br />
-Arena of valor global reddit community<br />
-Arena of valor global gameplay tips and tricks<br />
-Arena of valor global review and rating<br />
-Arena of valor global download size and requirements<br />
-Arena of valor global support and customer service<br />
-Arena of valor global free redeem codes 2023<br />
-Arena of valor global events and rewards<br />
-Arena of valor global skins and costumes<br />
-Arena of valor global characters and abilities<br />
-Arena of valor global guides and tutorials<br />
-Arena of valor global news and updates<br />
-Arena of valor global esports and tournaments<br />
-Arena of valor global live stream and videos<br />
-Arena of valor global memes and jokes<br />
-Arena of valor global fan art and wallpapers<br />
-Arena of valor global merchandise and products<br />
-How to download arena of valor global on ios<br />
-Arena of valor global ios app store link<br />
-Download arena of valor global for mac os x<br />
-Arena of valor global crossplay and cross platform<br />
-How to play arena of valor global with friends<br />
-How to join a guild in arena of valor global<br />
-How to rank up in arena of valor global<br />
-How to get more gold and gems in arena of valor global<br />
-How to unlock more heroes in arena of valor global<br />
-How to master a hero in arena of valor global<br />
-How to counter a hero in arena of valor global<br />
-How to build a hero in arena of valor global<br />
-How to report a player in arena of valor global<br />
-How to change your name in arena of valor global<br />
-How to change your region in arena of valor global<br />
-How to contact level infinite in arena of valor global<br />
-How to delete your account in arena of valor global<br />
-How to reinstall arena of valor global without losing data<br />
-How to fix lag and connection issues in arena of valor global<br />
-How to enable voice chat in arena of valor global<br />
-How to mute a player in arena of valor global<br />
-How to customize your controls in arena of valor global<br />
-How to switch between modes in arena of valor global<br />
-How to watch replays in arena of valor global</p>
-<ol>
-<li>Open the App Store app on your device.</li>
-<li>Search for "Arena of Valor Global" in the search bar.</li>
-<li>Tap on the game icon that appears in the results.</li>
-<li>Tap on the "Get" button and wait for the game to download and install on your device.</li>
-<li>Once the installation is complete, tap on the game icon on your home screen to launch the game and start playing.</li>
-</ol>
-<p>That's it! You have successfully downloaded Arena of Valor Global for your iOS device. You can now enjoy the game and join millions of players from around the world. But what if you don't have access to the App Store or you want to download the game from another source? Don't worry, there is another way to download the game using an IPA file.</p>
- <h3>How to Download Arena of Valor Global IPA File</h3>
-<p>An IPA file is a file format that contains all the data and code needed to install an iOS app on your device. You can download an IPA file from various websites that offer them, such as Panda Helper, AppValley, or TweakBox. However, you need to be careful when downloading IPA files from unknown sources, as they may contain malware or viruses that can harm your device. To avoid this, you should always scan the IPA file with an antivirus app before installing it. Here are the steps you need to follow to download Arena of Valor Global IPA file:</p>
-<ol>
-<li>Go to a website that offers Arena of Valor Global IPA file, such as <a href="">Panda Helper</a>.</li>
-<li>Search for "Arena of Valor Global" in the search bar.</li>
-<li>Select the game icon that appears in the results.</li>
-<li>Tap on the "Download" button and wait for the file to download on your device.</li>
-<li>Once the download is complete, locate the file in your device's storage and tap on it to install it.</li>
-<li>If you see a warning message that says "Untrusted Enterprise Developer", tap on "Cancel" and go to your device's settings.</li>
-<li>Go to General > Profiles & Device Management and find the profile that belongs to the app you just installed.</li>
-<li>Tap on the profile and then tap on "Trust" to allow the app to run on your device.</li>
-<li>Go back to your home screen and tap on the game icon to launch the game and start playing.</li>
-</ol>
-<p>Congratulations! You have successfully downloaded Arena of Valor Global IPA file and installed it on your device. You can now enjoy the game and join millions of players from around the world. But what if you want to play the game on a bigger screen and with better controls? Don't worry, we have a solution for that too. Let's see how you can download Arena of Valor Global for your PC.</p>
- <h2>How to Download Arena of Valor Global for PC</h2>
-<p>If you want to play Arena of Valor Global on your PC, you will need an emulator. An emulator is a software that allows you to run mobile apps on your computer. There are many emulators available for playing mobile games on PC, but one of the best ones is BlueStacks. BlueStacks is a free and powerful emulator that offers high-quality performance and graphics, easy controls, and a wide range of features. Here are the steps you need to follow to download Arena of Valor Global for PC using BlueStacks emulator:</p>
- <h3>How to Download and Install BlueStacks Emulator</h3>
-<ol>
-<li>Go to <a href="">BlueStacks official website</a> and click on the "Download BlueStacks" button.</li>
-<li>Wait for the file to download on your PC and then double-click on it to run it.</li>
-<li>Follow the instructions on the screen to install BlueStacks emulator on your PC.</li>
-<li>Once the installation is complete, launch BlueStacks emulator from your desktop or start menu.</li>
-</ol>
- <h3>How to Download and Install Arena of Valor Global on BlueStacks Emulator</h3>
-<ol>
-<li>In BlueStacks emulator, go to Google Play Store and sign in with your Google account.</li>
-<li>Search for "Arena of Valor Global" in the search bar.</li>
-<li>Select the game icon that appears in the results.</li>
-<li>Click on the "Install" button and wait for the game to download and install on BlueStacks emulator.</li>
-<li>Once the installation is complete, click on the game icon on the home screen of BlueStacks emulator to launch the game and start playing.</li>
-</ol>
-<p>Congratulations! You have successfully downloaded Arena of Valor Global for PC using BlueStacks emulator. You can now enjoy the game on a bigger screen and with better controls. You can also customize your keyboard and mouse settings, record your gameplay, and stream your matches to your friends and fans. But before you jump into the game, you might want to learn some tips and tricks for playing Arena of Valor Global like a pro. Let's see what they are.</p>
- <h2>Tips and Tricks for Playing Arena of Valor Global</h2>
-<p>Arena of Valor Global is a game that requires skill, strategy, and teamwork. If you want to improve your gameplay and win more matches, you need to master some tips and tricks that will give you an edge over your opponents. Here are some of them:</p>
- <h3>Choose Your Role and Hero Wisely</h3>
-<p>In Arena of Valor Global, there are five main roles that you can choose from: Tank, Warrior, Assassin, Mage, and Support. Each role has its own strengths, weaknesses, and responsibilities in the game. You should choose a role that suits your playstyle and preference, and then select a hero that fits that role. For example, if you like to initiate fights and protect your teammates, you should choose a Tank role and a hero like Maloch or Thane. If you like to deal massive damage and eliminate enemies quickly, you should choose an Assassin role and a hero like Quillen or Butterfly. You should also consider your team composition and the enemy team composition when choosing your role and hero. You should try to balance your team with different roles and heroes that can complement each other and counter the enemy team.</p>
- <h3>Communicate and Coordinate with Your Teammates</h3>
-<p>Arena of Valor Global is a team-based game that requires communication and coordination with your teammates. You should use the chat and ping system to communicate with your teammates effectively. You can use the chat to type messages or use voice chat to talk to your teammates. You can also use the ping system to send signals to your teammates, such as "Attack", "Retreat", "Gather", or "Enemy Missing". You should communicate with your teammates about your strategy, objectives, enemy movements, item builds, cooldowns, and other important information. You should also listen to your teammates' suggestions and feedback, and cooperate with them in fights and objectives. By communicating and coordinating with your teammates, you can increase your chances of winning the game.</p>
- <h3>Learn from the Pros and Watch Live Streams</h3>
-<p>Arena of Valor Global is a game that has a competitive scene with professional players and teams from around the world. If you want to learn from the pros and watch live streams of their matches, you can do so in the game itself. You can go to the "Watch" tab in the game menu and select from various live streams of professional players and teams. You can also watch replays of previous matches or highlights of epic moments. By watching live streams of pros, you can learn from their strategies, techniques, item builds, hero choices, map awareness, positioning, teamwork, and more. You can also interact with them through chat or send them gifts to show your support. By learning from the pros and watching live streams, you can improve your gameplay and skills in Arena of Valor Global.</p>
- <h2>Conclusion</h2>
-<p>Arena of Valor Global is an epic 5v5 MOBA game that offers a variety of features, modes, and heroes for you to enjoy. Whether you have an Android device, an iOS device, or a PC device, you can download this game easily using our guide above. You can also use our tips and tricks to play this game like a pro and win more matches. Arena of Valor Global is a game that will keep you entertained and challenged for hours. So, what are you waiting for? Download Arena of Valor Global today and join the global community of MOBA fans. You won't regret it!</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions and answers about Arena of Valor Global:</p>
-<ul>
-<li><strong>Q: How much space does Arena of Valor Global take on my device?</strong></li>
-<li>A: Arena of Valor Global takes about 1.5 GB of space on your device. However, this may vary depending on your device model and the updates you download.</li>
-<li><strong>Q: How can I update Arena of Valor Global to the latest version?</strong></li>
-<li>A: You can update Arena of Valor Global to the latest version by going to the Google Play Store or the App Store and tapping on the "Update" button. Alternatively, you can download the latest APK or IPA file from the websites we mentioned above and install it on your device.</li>
-<li><strong>Q: How can I change the language of Arena of Valor Global?</strong></li>
-<li>A: You can change the language of Arena of Valor Global by going to the game settings and tapping on the "Language" option. You can choose from various languages, such as English, Spanish, French, German, Portuguese, Russian, Turkish, Arabic, Thai, Indonesian, Vietnamese, and more.</li>
-<li><strong>Q: How can I contact the customer service of Arena of Valor Global?</strong></li>
-<li>A: You can contact the customer service of Arena of Valor Global by going to the game settings and tapping on the "Customer Service" option. You can then choose from various options, such as FAQ, Feedback, Report a Problem, or Live Chat. You can also email them at <a href="mailto:[email protected]">[email protected]</a>.</li>
-<li><strong>Q: How can I get more gold and gems in Arena of Valor Global?</strong></li>
-<li>A: You can get more gold and gems in Arena of Valor Global by playing the game regularly, completing quests and achievements, participating in events and activities, joining a guild, watching ads, or purchasing them with real money.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Chess Board Offline 2 Player - A Simple and Fun Chess App for Everyone.md

@@ -1,110 +0,0 @@
-<br />
-<h1>Chess Board Offline 2 Player APK: A Free and Fun Way to Play Chess with a Friend</h1>
- <p>Chess is one of the oldest and most popular board games in the world. It is a game of strategy, logic, and skill that can challenge your mind and entertain you for hours. But what if you want to play chess with a friend without internet connection or creating an account? What if you want to play chess on your phone or tablet without installing multiple apps? What if you want to save and share your games with other chess enthusiasts?</p>
- <p>If you are looking for a simple and convenient way to play chess with a friend on one screen and completely offline, then you should try Chess Board Offline 2 Player APK. This is a free app that lets you play chess on a virtual board with a friend or by yourself. You can also use a chess clock, create custom setups, save unlimited games, and export them in PGN format. In this article, we will tell you more about this app and how to download and install it on your device.</p>
-<h2>chess board offline 2 player apk</h2><br /><p><b><b>Download Zip</b> &#9733; <a href="https://jinyurl.com/2uNO1X">https://jinyurl.com/2uNO1X</a></b></p><br /><br />
- <h2>What is Chess Board Offline 2 Player APK?</h2>
- <h3>A virtual chess board for two players</h3>
- <p>Chess Board Offline 2 Player APK is an app that simulates a real chess board on your screen. You can play chess with a friend by taking turns on the same device. You can also play by yourself against an imaginary opponent or practice different moves and scenarios. The app has a standard 8x8 board with all the pieces and rules of chess. You can move the pieces by dragging them or tapping them.</p>
- <h3>A free and offline app</h3>
- <p>One of the best features of Chess Board Offline 2 Player APK is that it is completely free and offline. You don't need to pay anything to download or use the app. You also don't need to be online or create an account to play chess. You can play anytime and anywhere without worrying about internet connection or data usage. You can also enjoy the app without any ads or in-app purchases.</p>
- <h3>A simple and user-friendly interface</h3>
- <p>Another great feature of Chess Board Offline 2 Player APK is that it has a simple and user-friendly interface. The app has a minimalist design that focuses on the chess board and the pieces. The app also has easy-to-use controls and settings that let you customize your game. You can choose between different board colors, piece styles, sound effects, and languages. You can also enable or disable hints, undo moves, flip board, rotate screen, and more.</p>
- <h2>Why Should You Download Chess Board Offline 2 Player APK?</h2>
- <h3>To enjoy chess without internet or accounts</h3>
- <p>If you love chess but don't have access to internet or don't want to create an account on other apps, then Chess Board Offline 2 Player APK is perfect for you. You can play chess with a friend on one screen without any hassle or interruption. You can also play by yourself without any pressure or competition. You can have fun and relax with this app.</p>
- <h3>To practice chess openings and strategies</h3>
- <p>If you want to improve your chess skills or learn new chess openings and strategies, then Chess Board Offline 2 Player APK can help you. You can use the app to practice different moves and scenarios on the board. You can also create custom setups and test your skills. The app has a hint feature that can suggest the best move for you. You can also undo your moves and try different options. The app can help you learn from your mistakes and improve your chess game.</p>
- <h3>To save and export your games in PGN format</h3>
- <p>If you want to save and share your chess games with other chess enthusiasts, then Chess Board Offline 2 Player APK can help you. The app allows you to save unlimited games on your device. You can also export your games in PGN format, which is a standard format for chess games. You can use PGN files to view, analyze, or replay your games on other apps or websites. You can also share your PGN files with your friends or online communities.</p>
- <h2>How to Download and Install Chess Board Offline 2 Player APK?</h2>
- <h3>Step 1: Go to the official website or Google Play Store</h3>
- <p>The easiest way to download Chess Board Offline 2 Player APK is to go to the official website of the app or the Google Play Store. You can use the following links to access them:</p>
-<p>chess board offline 2 player apk download<br />
-chess board offline 2 player apk free<br />
-chess board offline 2 player apk mod<br />
-chess board offline 2 player apk android<br />
-chess board offline 2 player apk latest version<br />
-chess board offline 2 player apk for pc<br />
-chess board offline 2 player apk no ads<br />
-chess board offline 2 player apk full<br />
-chess board offline 2 player apk premium<br />
-chess board offline 2 player apk pro<br />
-chess board offline 2 player apk best<br />
-chess board offline 2 player apk review<br />
-chess board offline 2 player apk online<br />
-chess board offline 2 player apk multiplayer<br />
-chess board offline 2 player apk with friends<br />
-chess board offline 2 player apk without internet<br />
-chess board offline 2 player apk unlimited coins<br />
-chess board offline 2 player apk hack<br />
-chess board offline 2 player apk cheat<br />
-chess board offline 2 player apk cracked<br />
-chess board offline 2 player apk unlocked<br />
-chess board offline 2 player apk update<br />
-chess board offline 2 player apk new features<br />
-chess board offline 2 player apk bug fixes<br />
-chess board offline 2 player apk improvements<br />
-chess board offline 2 player apk tips and tricks<br />
-chess board offline 2 player apk tutorial<br />
-chess board offline 2 player apk guide<br />
-chess board offline 2 player apk how to play<br />
-chess board offline 2 player apk rules and regulations<br />
-chess board offline 2 player apk game modes<br />
-chess board offline 2 player apk difficulty levels<br />
-chess board offline 2 player apk themes and skins<br />
-chess board offline 2 player apk sound and music<br />
-chess board offline 2 player apk graphics and animation<br />
-chess board offline 2 player apk performance and optimization<br />
-chess board offline 2 player apk compatibility and requirements<br />
-chess board offline 2 player apk installation and setup<br />
-chess board offline 2 player apk feedback and support<br />
-chess board offline 2 player apk rating and reviews</p>
- <table>
-<tr>
-<th>Official website</th>
-<th>Google Play Store</th>
-</tr>
-<tr>
-<td><a href="">Chess Board Offline 2 Player APK</a></td>
-<td><a href="">Chess Board Offline 2 Player - Apps on Google Play</a></td>
-</tr>
-</table>
- <p>You can also scan the QR codes below to download the app:</p>
- <table>
-<tr>
-<th>Official website</th>
-<th>Google Play Store</th>
-</tr>
-<tr>
-<td><img src="" alt="QR code for official website"></td>
-<td><img src="" alt="QR code for Google Play Store"></td>
-</tr>
-</table>
- <h3>Step 2: Click on the download button or install button</h3>
- <p>Once you are on the official website or the Google Play Store, you will see a download button or an install button. Click on it to start downloading the app. The app is about 5 MB in size, so it should not take long to download.</p>
- <h3>Step 3: Allow unknown sources if prompted</h3>
- <p>If you are downloading the app from the official website, you may need to allow unknown sources on your device. This is because the app is not from the Google Play Store and may not be verified by Google. To allow unknown sources, follow these steps:</p>
- <ul>
-<li>Go to your device settings and look for security or privacy options.</li>
-<li>Find the option that says unknown sources or install unknown apps and enable it.</li>
-<li>You may see a warning message that says installing apps from unknown sources may harm your device. Tap on OK or Allow to proceed.</li>
-</ul>
- <p>If you are downloading the app from the Google Play Store, you don't need to do this step.</p>
- <h3>Step 4: Open the app and start playing</h3>
- <p>Once the app is downloaded and installed, you can open it and start playing chess with a friend or by yourself. You will see a welcome screen that shows you how to use the app and its features. You can also access the settings menu to customize your game. Enjoy playing chess with Chess Board Offline 2 Player APK!</p>
- <h2>Conclusion</h2>
- <p>Chess Board Offline 2 Player APK is a free and fun way to play chess with a friend on one screen and completely offline. You can also play by yourself and practice different moves and scenarios. The app has a simple and user-friendly interface that lets you customize your game. You can also save and export your games in PGN format and share them with other chess enthusiasts. If you love chess and want to play it anytime and anywhere without internet or accounts, then you should download Chess Board Offline 2 Player APK today!</p>
- <h2>FAQs</h2>
- <h4>Q: Is Chess Board Offline 2 Player APK safe?</h4>
-<p>A: Yes, Chess Board Offline 2 Player APK is safe to download and use. The app does not require any permissions or access to your device data. The app also does not contain any ads or in-app purchases that may harm your device or privacy.</p>
- <h4>Q: Can I play chess online with Chess Board Offline 2 Player APK?</h4>
-<p>A: No, Chess Board Offline 2 Player APK is an offline app that does not support online play. You can only play chess with a friend on one screen or by yourself against an imaginary opponent. If you want to play chess online with other players, you will need to use a different app that supports online play.</p>
- <h4>Q: Can I play chess with different difficulty levels with Chess Board Offline 2 Player APK?</h4>
-<p>A: No, Chess Board Offline 2 Player APK does not have different difficulty levels or artificial intelligence. The app is designed for playing chess with a friend or by yourself. You can adjust the level of challenge by choosing your opponent or creating custom setups. If you want to play chess with different difficulty levels or artificial intelligence, you will need to use a different app that has these features.</p>
- <h4>Q: Can I play chess with different variants or rules with Chess Board Offline 2 Player APK?</h4>
-<p>A: No, Chess Board Offline 2 Player APK only supports the standard chess rules and variants. The app does not have options for changing the board size, the number of pieces, the movement of pieces, or the game objectives. The app follows the official rules of chess as defined by the World Chess Federation (FIDE). If you want to play chess with different variants or rules, you will need to use a different app that has these options.</p>
- <h4>Q: Can I play chess with other apps or devices with Chess Board Offline 2 Player APK?</h4>
-<p>A: Yes, you can play chess with other apps or devices with Chess Board Offline 2 Player APK. The app allows you to export your games in PGN format, which is a standard format for chess games. You can use PGN files to view, analyze, or replay your games on other apps or devices that support PGN files. You can also share your PGN files with your friends or online communities that use PGN files.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Incredibox Now and Join the Merry Crew of Beatboxers on Your Android Device.md

@@ -1,131 +0,0 @@
-
-<h1>Incredibox Free Download Android: How to Create Your Own Music with a Merry Crew of Beatboxers</h1>
- <p>Do you love music and want to create your own songs with a simple and fun app? Do you want to explore different musical genres and mix them together to create unique sounds? Do you want to share your creations with the world and get feedback from other users? If you answered yes to any of these questions, then you should try <strong>Incredibox</strong>, a music app that lets you create your own music with the help of a merry crew of beatboxers.</p>
- <p>In this article, we will tell you everything you need to know about Incredibox, how to download it for free on your Android device, how to play it, and why you should play it. Let's get started!</p>
-<h2>incredibox free download android</h2><br /><p><b><b>DOWNLOAD</b> &#187; <a href="https://jinyurl.com/2uNLA5">https://jinyurl.com/2uNLA5</a></b></p><br /><br />
- <h2>What is Incredibox?</h2>
- <p>Incredibox is a music app that was created in 2009 by the French company So Far So Good. It is a combination of a game, a tool, and an educational resource that introduces kids and adults to notions of rhythm and melody in a fun and entertaining way.</p>
- <h3>A fun, interactive music experience</h3>
- <p>Incredibox is a music app that lets you create your own music with the help of a merry crew of beatboxers. You can choose from 9 musical styles among 8 impressive atmospheres and start to lay down, record, and share your mix. You can also find the right sound combos to unlock animated choruses that will enhance your tune. You can save your mix and get a link to share it with anybody so they can listen and vote for it. If your mix gets enough votes from other users, you may join the Top 50 chart and become a legend.</p>
- <h3>A music app with 9 musical styles and 8 characters</h3>
- <p>Incredibox features 9 musical styles that cover a wide range of genres, such as hip-hop, rock, funk, jazz, techno, electro-pop, samba, trap, and Bollywood. Each style has its own atmosphere, graphics, animation, and sound samples. You can switch between styles anytime you want and create your own combinations.</p>
- <p>Incredibox also features 8 characters that represent different types of sounds, such as beats, effects, melodies, voices, choruses, percussions, basses, and bonuses. Each character has its own personality and appearance. You can drag and drop icons onto the characters to make them sing and start to compose your own music. You can also customize the characters by changing their outfits and accessories.</p>
- <h3>A game, a tool, and an educational resource</h3>
- <p>Incredibox is not only a music app but also a game, a tool, and an educational resource. As a game, Incredibox challenges you to create the best mix possible by finding the right sound combos and unlocking animated choruses. You can also compete with other users by sharing your mix and getting votes from them. As a tool, Incredibox allows you to express your creativity and musical talent by creating your own songs with simple drag-and-drop actions. You can also download your mixes as MP3 files and listen to them anytime you want. As an educational resource, Incredibox introduces you to the basics of musical creation by teaching you about rhythm and melody in an interactive way. You can also learn about different musical genres and cultures by exploring the different styles and atmospheres.</p <h2>How to play Incredibox on Android devices?</h2>
- <p>Now that you have downloaded Incredibox on your Android device, you may wonder how to play it and have fun with it. Incredibox is a very easy and intuitive app that anyone can use, regardless of their age or musical skills. Here are some steps and tips to help you play Incredibox on your Android device.</p>
- <h3>The basic gameplay</h3>
- <p>The basic gameplay of Incredibox is very simple and straightforward. You just need to follow these steps:</p>
- <ol>
-<li>Open the app and choose a musical style from the 9 available ones. You can swipe left or right to see all the options.</li>
-<li>Tap on the play button to start the music and see the 8 characters on the screen. Each character represents a type of sound, such as beats, effects, melodies, voices, choruses, percussions, basses, and bonuses.</li>
-<li>Drag and drop icons from the bottom of the screen onto the characters to make them sing and create your own mix. You can use up to 20 icons at a time, and you can change them anytime you want.</li>
-<li>Find the right sound combos to unlock animated choruses that will enhance your mix. You can see the progress of the combos on the top of the screen.</li>
-<li>Tap on the record button to record your mix and save it on your device. You can also share it with other users by tapping on the share button.</li>
-</ol>
- <h3>The advanced features</h3>
- <p>Incredibox also has some advanced features that you can use to make your mix more interesting and unique. Here are some of them:</p>
-<p>incredibox app free download for android<br />
-incredibox apk free download latest version<br />
-incredibox mod apk free download android<br />
-incredibox v8 dystopia free download android<br />
-incredibox v9 wekiddy free download android<br />
-incredibox v7 jeevan free download android<br />
-incredibox v6 alive free download android<br />
-incredibox v5 brazil free download android<br />
-incredibox v4 the love free download android<br />
-incredibox v3 sunrise free download android<br />
-incredibox v2 little miss free download android<br />
-incredibox v1 alpha free download android<br />
-incredibox 0.5.1 apk free download android<br />
-incredibox 0.4.9 apk free download android<br />
-incredibox 0.4.8 apk free download android<br />
-incredibox 0.4.7 apk free download android<br />
-incredibox 0.4.6 apk free download android<br />
-incredibox 0.4.5 apk free download android<br />
-incredibox 0.4.4 apk free download android<br />
-incredibox 0.4.3 apk free download android<br />
-how to get incredibox for free on android<br />
-how to play incredibox offline on android<br />
-how to install incredibox on android<br />
-how to update incredibox on android<br />
-how to record incredibox on android<br />
-how to share incredibox on android<br />
-how to delete incredibox on android<br />
-how to use dark mode in incredibox on android<br />
-how to disable sharing in incredibox on android for kids<br />
-how to access all versions of incredibox on android app<br />
-best music creation app for android like incredibox<br />
-best alternatives to incredibox for android users<br />
-best tips and tricks for playing incredibox on android devices<br />
-best reviews and ratings for incredibox app on android store<br />
-best songs and mixes made with incredibox app on android phone<br />
-best features and benefits of downloading incredibox app on android tablet<br />
-best deals and discounts for buying incredibox app on android market<br />
-best ways and methods to learn music with incredibox app on android online<br />
-best resources and guides for using incredibox app on android offline<br />
-best fun and entertainment with incredibox app on android for adults and kids alike</p>
- <ul>
-<li>You can mute or solo any character by tapping on them. This will allow you to focus on a specific sound or create different variations of your mix.</li>
-<li>You can shuffle your mix by tapping on the shuffle button. This will randomly change the icons on the characters and create a new mix.</li>
-<li>You can customize your characters by tapping on the customize button. This will let you change their outfits and accessories according to your taste and style.</li>
-<li>You can access the bonus mode by tapping on the bonus button. This will let you play with special sound effects that are not available in the normal mode.</li>
-</ul>
- <h3>The tips and tricks</h3>
- <p>If you want to improve your skills and enjoy Incredibox more, here are some tips and tricks that you can follow:</p>
- <ul>
-<li>Experiment with different musical styles and sound combinations. You may discover new sounds and genres that you like or that inspire you.</li>
-<li>Listen to other users' mixes and vote for them. You may learn from their techniques and ideas, and also get feedback from them for your own mixes.</li>
-<li>Try to complete all the combos and unlock all the choruses. This will challenge your creativity and musical sense, and also reward you with amazing animations and sounds.</li>
-<li>Have fun and express yourself. Incredibox is a music app that lets you create your own music with no rules or limitations. You can be as creative and original as you want, and share your emotions and feelings through music.</li>
-</ul> <h2>Why should you play Incredibox on Android devices?</h2>
- <p>By now, you may have a clear idea of what Incredibox is and how to play it on your Android device. But you may still wonder why you should play it and what benefits it can bring you. Here are some reasons why you should play Incredibox on your Android device.</p>
- <h3>The benefits of playing Incredibox</h3>
- <p>Incredibox is not just a music app, but also a game, a tool, and an educational resource that can offer you many benefits, such as:</p>
- <ul>
-<li>It can stimulate your creativity and musical talent by letting you create your own songs with simple drag-and-drop actions.</li>
-<li>It can improve your musical knowledge and skills by introducing you to different musical genres and cultures, and teaching you about rhythm and melody.</li>
-<li>It can enhance your mood and well-being by providing you with a fun and entertaining experience that can make you laugh, smile, and relax.</li>
-<li>It can boost your confidence and self-expression by allowing you to share your creations with the world and get feedback from other users.</li>
-<li>It can foster your social interaction and communication by enabling you to connect with other users who share your passion for music and Incredibox.</li>
-</ul>
- <h3>The reviews and ratings of Incredibox</h3>
- <p>If you are still not convinced by the benefits of playing Incredibox, you may want to check out the reviews and ratings of Incredibox from other users who have tried it. Incredibox has received overwhelmingly positive feedback from its users, who have praised its originality, simplicity, quality, and fun factor. Here are some examples of what users have said about Incredibox:</p>
- <blockquote>
-<p>"This is the best app ever! I love making music with this app. It's so easy and fun. The graphics are amazing and the sounds are awesome. I recommend this app to everyone who loves music."</p>
-</blockquote>
- <blockquote>
-<p>"Incredibox is a masterpiece. It's not just a game, it's an art. It's a way to express yourself through music. It's a way to learn about different musical styles and cultures. It's a way to have fun and relax."</p>
-</blockquote>
- <blockquote>
-<p>"I'm addicted to this app. I can't stop playing it. It's so cool and creative. I love how I can mix different sounds and create my own songs. I also love how I can share my mixes with other people and listen to theirs."</p>
-</blockquote>
- <p>Incredibox has also received high ratings from its users, who have given it an average of 4.8 out of 5 stars on the Google Play Store. This shows that Incredibox is a highly rated and popular app that many users enjoy and appreciate.</p>
- <h3>The alternatives to Incredibox</h3>
- <p>If you are looking for some alternatives to Incredibox, you may want to try some other music apps that are similar or related to Incredibox. Here are some of them:</p>
- <ul>
-<li><strong>Groovepad</strong>: A music app that lets you create your own beats and music tracks with various sound effects, loops, samples, and genres.</li>
-<li><strong>Beat Snap</strong>: A music app that lets you make your own music with drums, synths, vocals, FX, and more.</li>
-<li><strong>Music Maker Jam</strong>: A music app that lets you create your own songs with thousands of studio-quality loops, beats, and samples.</li>
-<li><strong>DJ Loop Pads</strong>: A music app that lets you remix your favorite songs or create your own music with various pads, loops, FX, and more.</li>
-<li><strong>BandLab</strong>: A music app that lets you record, edit, mix, and share your own music with millions of creators and fans.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>In conclusion, Incredibox is a music app that lets you create your own music with the help of a merry crew of beatboxers. You can choose from 9 musical styles among 8 impressive atmospheres and start to lay down, record, and share your mix. You can also find the right sound combos to unlock animated choruses that will enhance your tune.</p>
- <p>In this article, we have told you everything you need to know about Incredibox, how to download it for free on your Android device, how to play it, and why you should play it. We hope that this article has been helpful and informative for you, and that you have enjoyed reading it as much as we have enjoyed writing it <p>Now that you have reached the end of the article, you may have some questions or doubts about Incredibox or anything related to it. To help you with that, we have prepared a list of 5 frequently asked questions (FAQs) that may answer some of your queries. Here they are:</p>
- <h2>FAQs</h2>
- <ol>
-<li><strong>Is Incredibox safe for kids?</strong></li>
-<p>Yes, Incredibox is safe for kids, as it does not contain any inappropriate or harmful content. It is also suitable for kids, as it is easy to use, fun to play, and educational to learn. In fact, Incredibox is often used by teachers and parents as a way to introduce kids to music and creativity.</p>
-<li><strong>Is Incredibox available for other devices?</strong></li>
-<p>Yes, Incredibox is available for other devices besides Android devices. You can also play Incredibox on iOS devices, such as iPhones and iPads, by downloading it from the App Store. You can also play Incredibox on your web browser, such as Chrome, Firefox, or Safari, by visiting the official website of Incredibox.</p>
-<li><strong>How can I contact the developer of Incredibox?</strong></li>
-<p>If you want to contact the developer of Incredibox, you can do so by visiting their website and filling out the contact form. You can also follow them on their social media accounts, such as Facebook, Twitter, Instagram, and YouTube. You can also send them an email at [email protected].</p>
-<li><strong>How can I support the developer of Incredibox?</strong></li>
-<p>If you want to support the developer of Incredibox, you can do so by buying the app from the app store, leaving a positive review and rating for the app, sharing your mixes with other users and friends, and following their social media accounts. You can also donate to them via PayPal or Patreon.</p>
-<li><strong>How can I learn more about Incredibox?</strong></li>
-<p>If you want to learn more about Incredibox, you can do so by visiting their website and reading their blog posts and news articles. You can also watch their videos and tutorials on their YouTube channel. You can also join their community and forum on their website and interact with other users and fans.</p>
-</ol>
- <p>We hope that these FAQs have been useful and informative for you. If you have any other questions or comments about Incredibox or this article, please feel free to leave them below. We would love to hear from you and help you out.</p>
- <p>Thank you for reading this article and playing Incredibox. We hope that you have enjoyed it as much as we have enjoyed writing it and creating music with it. Have a great day and keep on making music!</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Experience Nintendo GameCube and Wii Games on Xbox with Dolphin Emulator A Step-by-Step Guide.md

@@ -1,119 +0,0 @@
-<br />
-<h1>How to Download Dolphin Emulator on Xbox</h1>
-<p>If you are a fan of Nintendo GameCube and Wii games, you might be wondering if there is a way to play them on your Xbox console. The answer is yes, thanks to a powerful emulator called Dolphin. Dolphin is a software that can run GameCube and Wii games on various platforms, including Windows, Linux, Android, and even Xbox. In this article, we will show you how to download and install Dolphin Emulator on your Xbox Series X/S or Xbox One, and how to configure it for the best performance and compatibility. We will also share some tips and tricks to enhance your gaming experience with Dolphin Emulator on Xbox.</p>
- <h2>Requirements for Dolphin Emulator on Xbox</h2>
-<p>Before you start, you will need the following things:</p>
-<h2>how to download dolphin emulator on xbox</h2><br /><p><b><b>Download</b> &#8250;&#8250;&#8250;&#8250;&#8250; <a href="https://jinyurl.com/2uNOB2">https://jinyurl.com/2uNOB2</a></b></p><br /><br />
-<ul>
-<li>An Xbox Series X/S or Xbox One console with enough storage space.</li>
-<li>A USB drive formatted as NTFS with at least 4 GB of free space.</li>
-<li>A PC with internet access and a web browser.</li>
-<li>A copy of the latest version of Dolphin Emulator for UWP (Universal Windows Platform) from <a href="(^1^)">here</a>.</li>
-<li>Some GameCube or Wii game ROMs or ISOs that you legally own. You can rip them from your original discs using a compatible disc drive and software like CleanRip or RawDump.</li>
-</ul>
- <h2>How to Enable Developer Mode on Xbox</h2>
-<p>The first step is to enable developer mode on your Xbox console. This will allow you to install apps that are not available on the Microsoft Store, such as Dolphin Emulator. Developer mode is free for anyone to use, but it has some limitations and risks. For example, you will not be able to play online multiplayer games or use some features like achievements or game DVR while in developer mode. You will also need to switch back to retail mode if you want to use those features again. To enable developer mode, follow these steps:</p>
-<ol>
-<li>Go to <a href="(^2^)">https://developer.microsoft.com/en-us/xboxactivate</a> on your PC and sign in with your Microsoft account.</li>
-<li>Select Activate Console and follow the instructions to register your console as a developer device.</li>
-<li>On your console, go to Settings > System > Console info and select Reset console.</li>
-<li>Select Reset and keep my games & apps.</li>
-<li>Wait for the reset process to complete and sign in with your Microsoft account again.</li>
-<li>Go to Settings > System > Developer settings and select Enable developer mode.</li>
-<li>Wait for the console to reboot into developer mode.</li>
-</ol>
- <h2>How to Download and Install Dolphin Emulator on Xbox</h2>
-<p>Now that you have enabled developer mode, you can download and install Dolphin Emulator on your console. To do this, follow these steps:</p>
-<ol>
-<li>Copy the Dolphin Emulator app file (DolphinUWP_<version>.appx) from your PC to your USB drive.</li>
-<li>Plug the USB drive into your console.</li>
-<li>On your console, go to Settings > System > Developer settings and select Remote Access Settings.</li>
-<li>Enable Remote Access and set a username and password for authentication.</li>
-<li>Note down the IP address of your console shown under Remote Access Settings.</li>
-<li>On your PC, open a web browser and enter the IP address of your console followed by :11443 in the address bar. For example, https://192.168.1.100:11443.</li>
-<li>You will see a security warning about an untrusted certificate. Click on Advanced and proceed to the website.</li>
-<li>Enter the username and password that you set for your console and click on Log in.</li>
-<li>Click on Add and browse to the location of the Dolphin Emulator app file on your USB drive.</li>
-<li>Select the app file and click on Next.</li>
-<li>Wait for the app to be uploaded and installed on your console.</li>
-<li>Once the installation is complete, you will see Dolphin Emulator listed under Installed Apps on the web page.</li>
-<li>On your console, go to My games & apps > See all > Apps and launch Dolphin Emulator.</li>
-</ol>
- <h2>How to Configure Dolphin Emulator Settings on Xbox</h2>
-<p>Before you start playing games, you will need to configure some settings in Dolphin Emulator to optimize its performance and compatibility. To do this, follow these steps:</p>
-<ol>
-<li>On the main menu of Dolphin Emulator, select Config.</li>
-<li>Under the General tab, you can adjust some basic settings such as language, theme, and interface options.</li>
-<li>Under the Graphics tab, you can change some settings related to video output, such as resolution, aspect ratio, vsync, and enhancements. For the best performance, we recommend using the native resolution of your console (1080p for Xbox One and 4K for Xbox Series X/S) and disabling any unnecessary enhancements such as anti-aliasing or anisotropic filtering.</li>
-<li>Under the Audio tab, you can change some settings related to sound output, such as volume, backend, and latency. For the best compatibility, we recommend using the XAudio2 backend and lowering the latency to 20 ms or less.</li>
-<li>Under the GameCube tab, you can change some settings related to GameCube emulation, such as system language, memory card size, and controller type. For the best compatibility, we recommend using a standard controller for port 1 and leaving the other ports empty.</li>
-<li>Under the Wii tab, you can change some settings related to Wii emulation, such as system language, aspect ratio, sensor bar position, and speaker volume. For the best compatibility, we recommend using a horizontal aspect ratio and placing the sensor bar above or below your TV screen.</li>
-<li>Under the Paths tab, you can add or remove folders where Dolphin Emulator will look for game files. By default, it will scan the internal storage of your console and any USB drives connected to it. You can also add network paths if you have game files stored on a PC or a NAS device.</li>
-<li>Under the Advanced tab, you can change some settings related to advanced features such as CPU overclocking, dual core mode, cheats, and debug options. For the best stability, we recommend leaving these settings at their default values unless you know what you are doing.</li>
-</ol>
- <h2>How to Play GameCube and Wii Games on Xbox with Dolphin Emulator</h2>
-<p>Now that you have configured Dolphin Emulator settings on your console, you are ready to play some games. To do this, follow these steps:</p>
-<ol>
-<li>Make sure that you have some GameCube or Wii game files (ROMs or ISOs) stored on your console's internal storage or a USB drive. You can also use network paths if you have game files stored on a PC or a NAS device.</li>
-<li>On the main menu of Dolphin Emulator, select Browse.</li>
-<li>Navigate to the folder where your game files are located and select one of them.</li>
-<li>The game will start loading and you will see some information about it on the screen. You can press the Menu button on your controller to access some options such as save states, screenshots, cheats, and more.</li>
-<li>You can use your controller to play the game as if it was a native Xbox game. You can also use a keyboard and mouse if you prefer. You can customize the controller mappings in Dolphin Emulator by going to Controllers > Configure Controller in the main menu.</li>
-<li>To exit the game, press the View button on your controller and select Exit from the menu that appears.</li>
-</ol>
- <h2>Tips and Tricks for Dolphin Emulator on Xbox</h2>
-<p>To make the most out of Dolphin Emulator on Xbox, here are some tips and tricks that you might find useful:</p>
-<ul>
-<li>If you encounter any issues with a game, such as graphical glitches, audio problems, or crashes, you can try changing some settings in Dolphin Emulator to fix them. You can also check <a href="">the official compatibility list</a> for more information about how well each game works with Dolphin Emulator.</li>
-<li>If you want to play games that require motion controls or pointer input, such as Wii Sports or Super Mario Galaxy, [user you can use a smartphone as a virtual controller. To do this, you will need to download the <a href="">Dolphin Controller app</a> on your smartphone and connect it to the same Wi-Fi network as your console. Then, you can scan the QR code shown on Dolphin Emulator on your console and pair your smartphone as a controller. You can also customize the layout and sensitivity of the virtual buttons and sensors on your smartphone.</li>
-<li>If you want to play games that support online multiplayer, such as Mario Kart Wii or Super Smash Bros. Brawl, you can use a service called <a href="">Dolphin Netplay</a>. This will allow you to play with other Dolphin Emulator users over the internet. To do this, you will need to create or join a Netplay session on your PC and then connect your console to it using the IP address and port number shown on Dolphin Emulator on your PC. You will also need to have the same game file and settings as the other players in the session.</li>
-<li>If you want to enhance the graphics and sound of your games, you can use some features such as shaders, texture packs, HD audio packs, and more. These are optional add-ons that can improve the quality and fidelity of your games. You can download them from various sources online and place them in the appropriate folders on your console or USB drive. You can also enable or disable them in Dolphin Emulator by going to Graphics > Enhancements or Audio > DSP in the main menu.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>Dolphin Emulator is a great way to enjoy GameCube and Wii games on your Xbox console. It is easy to download and install, and it offers a lot of customization and optimization options. You can play hundreds of games with high compatibility and performance, and even use some features that are not available on the original consoles, such as online multiplayer, motion controls, and graphical enhancements. Dolphin Emulator is a must-have for any Nintendo fan who owns an Xbox console.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about Dolphin Emulator on Xbox:</p>
-<p>How to install dolphin emulator on xbox series x/s and xbox one<br />
-How to play gamecube and wii games on xbox series x/s with dolphin<br />
-How to set up dolphin emulator for uwp on xbox consoles<br />
-How to enable developer mode on xbox for dolphin emulator<br />
-How to use hd texture packs with dolphin emulator on xbox<br />
-How to run dolphin emulator on xbox one x with retroarch<br />
-How to play mario kart double dash online with dolphin emulator on xbox<br />
-How to configure xbox controller for dolphin emulator games<br />
-How to use a usb drive for storing gamecube and wii roms for dolphin emulator on xbox<br />
-How to update dolphin emulator for uwp on xbox series x/s and xbox one<br />
-How to fix performance issues with dolphin emulator on xbox one<br />
-How to play zelda twilight princess with dolphin emulator on xbox series x/s<br />
-How to use broadband adapter with dolphin emulator on xbox consoles<br />
-How to install gamecube and wii mods with dolphin emulator on xbox series x/s<br />
-How to play metroid prime trilogy with dolphin emulator on xbox series s/x<br />
-How to use cheats and codes with dolphin emulator on xbox consoles<br />
-How to play super smash bros melee with dolphin emulator on xbox series x/s<br />
-How to use save states and memory cards with dolphin emulator on xbox consoles<br />
-How to play resident evil 4 with dolphin emulator on xbox series x/s<br />
-How to use shaders and filters with dolphin emulator on xbox consoles<br />
-How to play animal crossing with dolphin emulator on xbox series x/s<br />
-How to use motion controls and wiimote with dolphin emulator on xbox consoles<br />
-How to play pikmin 2 with dolphin emulator on xbox series x/s<br />
-How to use netplay and multiplayer with dolphin emulator on xbox consoles<br />
-How to play luigi's mansion with dolphin emulator on xbox series x/s<br />
-How to use custom resolutions and aspect ratios with dolphin emulator on xbox consoles<br />
-How to play fire emblem path of radiance with dolphin emulator on xbox series x/s<br />
-How to use gamepad and keyboard mapping with dolphin emulator on xbox consoles<br />
-How to play paper mario the thousand year door with dolphin emulator on xbox series x/s<br />
-How to use screenshots and video recording with dolphin emulator on xbox consoles<br />
-How to play sonic adventure 2 battle with dolphin emulator on xbox series x/s<br />
-How to use turbo mode and speed hacks with dolphin emulator on xbox consoles<br />
-How to play star wars rogue squadron ii rogue leader with dolphin emulator on xbox series x/s<br />
-How to use audio settings and enhancements with dolphin emulator on xbox consoles<br />
-How to play f-zero gx with dolphin emulator on xbox series x/s</p>
-<ol>
-<li><b>Is Dolphin Emulator legal?</b><br>Dolphin Emulator itself is legal, as it is a software that emulates the hardware and software of GameCube and Wii consoles. However, downloading or distributing game files (ROMs or ISOs) that you do not own is illegal, as it violates the copyright laws of the game developers and publishers. You should only use game files that you have legally obtained from your own discs or digital purchases.</li>
-<li><b>Is Dolphin Emulator safe?</b><br>Dolphin Emulator is safe, as long as you download it from its official website or GitHub repository. It does not contain any viruses, malware, or spyware that could harm your console or PC. However, you should be careful when downloading any add-ons or game files from other sources online, as they might contain harmful or malicious content.</li>
-<li><b>Does Dolphin Emulator work on Xbox One S or Xbox One X?</b><br>Yes, Dolphin Emulator works on any Xbox One model, including Xbox One S and Xbox One X. However, you might notice some differences in performance and compatibility depending on the model of your console. For example, Xbox One X has more power and memory than Xbox One S, which means it can run some games faster and smoother than Xbox One S.</li>
-<li><b>Can I use an external hard drive instead of a USB drive for Dolphin Emulator?</b><br>Yes, you can use an external hard drive instead of a USB drive for Dolphin Emulator, as long as it is formatted as NTFS and has enough space for your game files. However, you might experience some issues with loading times or compatibility depending on the speed and quality of your external hard drive.</li>
-<li><b>Can I use a wireless controller instead of a wired controller for Dolphin Emulator?</b><br>Yes, you can use a wireless controller instead of a wired controller for Dolphin Emulator, as long as it is compatible with your console and has enough battery life. However, you might experience some issues with input lag or responsiveness depending on the quality and signal strength of your wireless controller.</li>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/experimental/rl/value_guided_sampling.py

@@ -1,146 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import numpy as np
-import paddle
-
-from ...models.unet_1d import UNet1DModel
-from ...pipeline_utils import DiffusionPipeline
-from ...utils.dummy_paddle_objects import DDPMScheduler
-
-
-class ValueGuidedRLPipeline(DiffusionPipeline):
-    r"""
-    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.)
-    Pipeline for sampling actions from a diffusion model trained to predict sequences of states.
-    Original implementation inspired by this repository: https://github.com/jannerm/diffuser.
-
-    Parameters:
-        value_function ([`UNet1DModel`]): A specialized UNet for fine-tuning trajectories base on reward.
-        unet ([`UNet1DModel`]): U-Net architecture to denoise the encoded trajectories.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded trajectories. Default for this
-            application is [`DDPMScheduler`].
-        env: An environment following the OpenAI gym API to act in. For now only Hopper has pretrained models.
-    """
-
-    def __init__(
-        self,
-        value_function: UNet1DModel,
-        unet: UNet1DModel,
-        scheduler: DDPMScheduler,
-        env,
-    ):
-        super().__init__()
-        self.value_function = value_function
-        self.unet = unet
-        self.scheduler = scheduler
-        self.env = env
-        self.data = env.get_dataset()
-        self.means = dict()
-        for key in self.data.keys():
-            try:
-                self.means[key] = self.data[key].mean()
-            except Exception:
-                pass
-        self.stds = dict()
-        for key in self.data.keys():
-            try:
-                self.stds[key] = self.data[key].std()
-            except Exception:
-                pass
-        self.state_dim = env.observation_space.shape[0]
-        self.action_dim = env.action_space.shape[0]
-
-    def normalize(self, x_in, key):
-        return (x_in - self.means[key]) / self.stds[key]
-
-    def de_normalize(self, x_in, key):
-        return x_in * self.stds[key] + self.means[key]
-
-    def to_paddle(self, x_in):
-        if type(x_in) is dict:
-            return {k: self.to_paddle(v) for k, v in x_in.items()}
-        elif paddle.is_tensor(x_in):
-            return x_in
-        return paddle.to_tensor(x_in)
-
-    def reset_x0(self, x_in, cond, act_dim):
-        for key, val in cond.items():
-            x_in[:, key, act_dim:] = val.clone()
-        return x_in
-
-    def run_diffusion(self, x, conditions, n_guide_steps, scale):
-        batch_size = x.shape[0]
-        y = None
-        for i in self.progress_bar(self.scheduler.timesteps):
-            # create batch of timesteps to pass into model
-            timesteps = paddle.full((batch_size,), i, dtype="int64")
-            for _ in range(n_guide_steps):
-                with paddle.set_grad_enabled(True):
-                    x.stop_gradient = False
-                    # permute to match dimension for pre-trained models
-                    y = self.value_function(x.transpose([0, 2, 1]), timesteps).sample
-                    grad = paddle.autograd.grad([y.sum()], [x])[0]
-
-                    posterior_variance = self.scheduler._get_variance(i)
-                    model_std = paddle.exp(0.5 * posterior_variance)
-                    grad = model_std * grad
-
-                grad[timesteps < 2] = 0
-                x = x.detach()
-                x = x + scale * grad
-                x = self.reset_x0(x, conditions, self.action_dim)
-            prev_x = self.unet(x.transpose([0, 2, 1]), timesteps).sample.transpose([0, 2, 1])
-            # TODO: verify deprecation of this kwarg
-            x = self.scheduler.step(prev_x, i, x, predict_epsilon=False)["prev_sample"]
-
-            # apply conditions to the trajectory (set the initial state)
-            x = self.reset_x0(x, conditions, self.action_dim)
-            x = self.to_paddle(x)
-        return x, y
-
-    def __call__(self, obs, batch_size=64, planning_horizon=32, n_guide_steps=2, scale=0.1):
-        # normalize the observations and create  batch dimension
-        obs = self.normalize(obs, "observations")
-        obs = obs[None].repeat(batch_size, axis=0)
-
-        conditions = {0: self.to_paddle(obs)}
-        shape = [batch_size, planning_horizon, self.state_dim + self.action_dim]
-
-        # generate initial noise and apply our conditions (to make the trajectories start at current state)
-        x1 = paddle.randn(shape)
-        x = self.reset_x0(x1, conditions, self.action_dim)
-        x = self.to_paddle(x)
-
-        # run the diffusion process
-        x, y = self.run_diffusion(x, conditions, n_guide_steps, scale)
-
-        # sort output trajectories by value
-        sorted_idx = paddle.argsort(y, 0, descending=True).squeeze()
-        sorted_values = x[sorted_idx]
-        actions = sorted_values[:, :, : self.action_dim]
-        actions = actions.detach().numpy()
-        denorm_actions = self.de_normalize(actions, key="actions")
-
-        # select the action with the highest value
-        if y is not None:
-            selected_index = 0
-        else:
-            # if we didn't run value guiding, select a random action
-            selected_index = np.random.randint(0, batch_size)
-        denorm_actions = denorm_actions[selected_index, 0]
-        return denorm_actions

spaces/A00001/bingothoo/src/pages/api/healthz.ts

@@ -1,7 +0,0 @@
-'use server'
-
-import { NextApiRequest, NextApiResponse } from 'next'
-
-export default async function handler(req: NextApiRequest, res: NextApiResponse) {
-  res.status(200).end('ok')
-}

spaces/AI-ZTH-03-23/README/README.md

@@ -1,20 +0,0 @@
----
-title: README
-emoji: 🐠
-colorFrom: gray
-colorTo: purple
-sdk: static
-pinned: false
----
-
-# 03-23-2023 Code Examples:
-1. Classroom: https://huggingface.co/AI-ZTH-03-23
-2. Dynamic Architecture Modeling: https://huggingface.co/spaces/awacke1/Streamlit.GraphViz.Dynamic.Architecture.Diagram
-3. Aframe VR IOT Motion Sensor WASD: https://huggingface.co/spaces/awacke1/HTML5-Aframe-3dMap-Flight
-4. MediaPipe: https://huggingface.co/spaces/awacke1/RealTime-MediaPipe-AI-From-Video-On-Any-Device
-5. Wikipedia Fact Check Chat: https://huggingface.co/spaces/awacke1/StreamlitWikipediaChat
-6. Dashboard - Tweet, Wiki, Memory: https://huggingface.co/spaces/awacke1/AI.Dashboard.Wiki.Chat.Cognitive.HTML5
-7. Dashboard - Chat, Download, Image Search, OCR, StoryGen, Q, Mermaid HTML5: https://huggingface.co/spaces/awacke1/AI.Dashboard.Gradio.Streamlit.HTML5
-8. Datasets - Biomed NER:  https://huggingface.co/spaces/DataScienceEngineering/7-NER-Biomed-ClinicalTerms
-9. MN Hospitals Comparative Maps: https://huggingface.co/spaces/awacke1/MN.Map.Hospitals.Top.Five
-10. Find Mental Health Providers, Maps, Location: https://huggingface.co/spaces/awacke1/Gradio-Maps-Latitude-Longitude

spaces/AI-Zero-to-Hero/01-H5-Play-Canvas-Sim-Physics/style.css

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

spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/commons/normalizing_flow/res_flow.py

@@ -1,61 +0,0 @@
-import torch
-from torch import nn
-from text_to_speech.modules.commons.conv import ConditionalConvBlocks
-from text_to_speech.modules.commons.wavenet import WN
-
-
-class FlipLayer(nn.Module):
-    def forward(self, x, nonpadding, cond=None, reverse=False):
-        x = torch.flip(x, [1])
-        return x
-
-
-class CouplingLayer(nn.Module):
-    def __init__(self, c_in, hidden_size, kernel_size, n_layers, p_dropout=0, c_in_g=0, nn_type='wn'):
-        super().__init__()
-        self.channels = c_in
-        self.hidden_size = hidden_size
-        self.kernel_size = kernel_size
-        self.n_layers = n_layers
-        self.c_half = c_in // 2
-
-        self.pre = nn.Conv1d(self.c_half, hidden_size, 1)
-        if nn_type == 'wn':
-            self.enc = WN(hidden_size, kernel_size, 1, n_layers, p_dropout=p_dropout,
-                          c_cond=c_in_g)
-        elif nn_type == 'conv':
-            self.enc = ConditionalConvBlocks(
-                hidden_size, c_in_g, hidden_size, None, kernel_size,
-                layers_in_block=1, is_BTC=False, num_layers=n_layers)
-        self.post = nn.Conv1d(hidden_size, self.c_half, 1)
-
-    def forward(self, x, nonpadding, cond=None, reverse=False):
-        x0, x1 = x[:, :self.c_half], x[:, self.c_half:]
-        x_ = self.pre(x0) * nonpadding
-        x_ = self.enc(x_, nonpadding=nonpadding, cond=cond)
-        m = self.post(x_)
-        x1 = m + x1 if not reverse else x1 - m
-        x = torch.cat([x0, x1], 1)
-        return x * nonpadding
-
-
-class ResFlow(nn.Module):
-    def __init__(self,
-                 c_in,
-                 hidden_size,
-                 kernel_size,
-                 n_flow_layers,
-                 n_flow_steps=4,
-                 c_cond=0,
-                 nn_type='wn'):
-        super().__init__()
-        self.flows = nn.ModuleList()
-        for i in range(n_flow_steps):
-            self.flows.append(
-                CouplingLayer(c_in, hidden_size, kernel_size, n_flow_layers, c_in_g=c_cond, nn_type=nn_type))
-            self.flows.append(FlipLayer())
-
-    def forward(self, x, nonpadding, cond=None, reverse=False):
-        for flow in (self.flows if not reverse else reversed(self.flows)):
-            x = flow(x, nonpadding, cond=cond, reverse=reverse)
-        return x

spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/commons/normalizing_flow/utils.py

@@ -1,29 +0,0 @@
-import torch
-
-
-def squeeze(x, x_mask=None, n_sqz=2):
-    b, c, t = x.size()
-
-    t = (t // n_sqz) * n_sqz
-    x = x[:, :, :t]
-    x_sqz = x.view(b, c, t // n_sqz, n_sqz)
-    x_sqz = x_sqz.permute(0, 3, 1, 2).contiguous().view(b, c * n_sqz, t // n_sqz)
-
-    if x_mask is not None:
-        x_mask = x_mask[:, :, n_sqz - 1::n_sqz]
-    else:
-        x_mask = torch.ones(b, 1, t // n_sqz).to(device=x.device, dtype=x.dtype)
-    return x_sqz * x_mask, x_mask
-
-
-def unsqueeze(x, x_mask=None, n_sqz=2):
-    b, c, t = x.size()
-
-    x_unsqz = x.view(b, n_sqz, c // n_sqz, t)
-    x_unsqz = x_unsqz.permute(0, 2, 3, 1).contiguous().view(b, c // n_sqz, t * n_sqz)
-
-    if x_mask is not None:
-        x_mask = x_mask.unsqueeze(-1).repeat(1, 1, 1, n_sqz).view(b, 1, t * n_sqz)
-    else:
-        x_mask = torch.ones(b, 1, t * n_sqz).to(device=x.device, dtype=x.dtype)
-    return x_unsqz * x_mask, x_mask

spaces/AIGC-Audio/AudioGPT/text_to_speech/tasks/tts/ps_flow.py

@@ -1,135 +0,0 @@
-import torch
-from text_to_speech.modules.tts.portaspeech.portaspeech_flow import PortaSpeechFlow
-from tasks.tts.fs import FastSpeechTask
-from tasks.tts.ps import PortaSpeechTask
-from text_to_speech.utils.audio.pitch.utils import denorm_f0
-from text_to_speech.utils.commons.hparams import hparams
-
-
-class PortaSpeechFlowTask(PortaSpeechTask):
-    def __init__(self):
-        super().__init__()
-        self.training_post_glow = False
-
-    def build_tts_model(self):
-        ph_dict_size = len(self.token_encoder)
-        word_dict_size = len(self.word_encoder)
-        self.model = PortaSpeechFlow(ph_dict_size, word_dict_size, hparams)
-
-    def _training_step(self, sample, batch_idx, opt_idx):
-        self.training_post_glow = self.global_step >= hparams['post_glow_training_start'] \
-                                  and hparams['use_post_flow']
-        if hparams['two_stage'] and \
-                ((opt_idx == 0 and self.training_post_glow) or (opt_idx == 1 and not self.training_post_glow)):
-            return None
-        loss_output, _ = self.run_model(sample)
-        total_loss = sum([v for v in loss_output.values() if isinstance(v, torch.Tensor) and v.requires_grad])
-        loss_output['batch_size'] = sample['txt_tokens'].size()[0]
-        if 'postflow' in loss_output and loss_output['postflow'] is None:
-            return None
-        return total_loss, loss_output
-
-    def run_model(self, sample, infer=False, *args, **kwargs):
-        if not infer:
-            training_post_glow = self.training_post_glow
-            spk_embed = sample.get('spk_embed')
-            spk_id = sample.get('spk_ids')
-            output = self.model(sample['txt_tokens'],
-                                sample['word_tokens'],
-                                ph2word=sample['ph2word'],
-                                mel2word=sample['mel2word'],
-                                mel2ph=sample['mel2ph'],
-                                word_len=sample['word_lengths'].max(),
-                                tgt_mels=sample['mels'],
-                                pitch=sample.get('pitch'),
-                                spk_embed=spk_embed,
-                                spk_id=spk_id,
-                                infer=False,
-                                forward_post_glow=training_post_glow,
-                                two_stage=hparams['two_stage'],
-                                global_step=self.global_step,
-                                bert_feats=sample.get('bert_feats'))
-            losses = {}
-            self.add_mel_loss(output['mel_out'], sample['mels'], losses)
-            if (training_post_glow or not hparams['two_stage']) and hparams['use_post_flow']:
-                losses['postflow'] = output['postflow']
-                losses['l1'] = losses['l1'].detach()
-                losses['ssim'] = losses['ssim'].detach()
-            if not training_post_glow or not hparams['two_stage'] or not self.training:
-                losses['kl'] = output['kl']
-                if self.global_step < hparams['kl_start_steps']:
-                    losses['kl'] = losses['kl'].detach()
-                else:
-                    losses['kl'] = torch.clamp(losses['kl'], min=hparams['kl_min'])
-                losses['kl'] = losses['kl'] * hparams['lambda_kl']
-                if hparams['dur_level'] == 'word':
-                    self.add_dur_loss(
-                        output['dur'], sample['mel2word'], sample['word_lengths'], sample['txt_tokens'], losses)
-                    self.get_attn_stats(output['attn'], sample, losses)
-                else:
-                    super().add_dur_loss(output['dur'], sample['mel2ph'], sample['txt_tokens'], losses)
-            return losses, output
-        else:
-            use_gt_dur = kwargs.get('infer_use_gt_dur', hparams['use_gt_dur'])
-            forward_post_glow = self.global_step >= hparams['post_glow_training_start'] + 1000 \
-                                and hparams['use_post_flow']
-            spk_embed = sample.get('spk_embed')
-            spk_id = sample.get('spk_ids')
-            output = self.model(
-                sample['txt_tokens'],
-                sample['word_tokens'],
-                ph2word=sample['ph2word'],
-                word_len=sample['word_lengths'].max(),
-                pitch=sample.get('pitch'),
-                mel2ph=sample['mel2ph'] if use_gt_dur else None,
-                mel2word=sample['mel2word'] if hparams['profile_infer'] or hparams['use_gt_dur'] else None,
-                infer=True,
-                forward_post_glow=forward_post_glow,
-                spk_embed=spk_embed,
-                spk_id=spk_id,
-                two_stage=hparams['two_stage'],
-                bert_feats=sample.get('bert_feats'))
-            return output
-
-    def validation_step(self, sample, batch_idx):
-        self.training_post_glow = self.global_step >= hparams['post_glow_training_start'] \
-                                  and hparams['use_post_flow']
-        return super().validation_step(sample, batch_idx)
-
-    def save_valid_result(self, sample, batch_idx, model_out):
-        super(PortaSpeechFlowTask, self).save_valid_result(sample, batch_idx, model_out)
-        sr = hparams['audio_sample_rate']
-        f0_gt = None
-        if sample.get('f0') is not None:
-            f0_gt = denorm_f0(sample['f0'][0].cpu(), sample['uv'][0].cpu())
-        if self.global_step > 0:
-            # save FVAE result
-            if hparams['use_post_flow']:
-                wav_pred = self.vocoder.spec2wav(model_out['mel_out_fvae'][0].cpu(), f0=f0_gt)
-                self.logger.add_audio(f'wav_fvae_{batch_idx}', wav_pred, self.global_step, sr)
-                self.plot_mel(batch_idx, sample['mels'], model_out['mel_out_fvae'][0],
-                              f'mel_fvae_{batch_idx}', f0s=f0_gt)
-
-    def build_optimizer(self, model):
-        if hparams['two_stage'] and hparams['use_post_flow']:
-            self.optimizer = torch.optim.AdamW(
-                [p for name, p in self.model.named_parameters() if 'post_flow' not in name],
-                lr=hparams['lr'],
-                betas=(hparams['optimizer_adam_beta1'], hparams['optimizer_adam_beta2']),
-                weight_decay=hparams['weight_decay'])
-            self.post_flow_optimizer = torch.optim.AdamW(
-                self.model.post_flow.parameters(),
-                lr=hparams['post_flow_lr'],
-                betas=(hparams['optimizer_adam_beta1'], hparams['optimizer_adam_beta2']),
-                weight_decay=hparams['weight_decay'])
-            return [self.optimizer, self.post_flow_optimizer]
-        else:
-            self.optimizer = torch.optim.AdamW(
-                self.model.parameters(),
-                lr=hparams['lr'],
-                betas=(hparams['optimizer_adam_beta1'], hparams['optimizer_adam_beta2']),
-                weight_decay=hparams['weight_decay'])
-            return [self.optimizer]
-
-    def build_scheduler(self, optimizer):
-        return FastSpeechTask.build_scheduler(self, optimizer[0])

spaces/AIWaves/SOP_Generation-single/Agent/__init__.py

@@ -1 +0,0 @@
-from .Agent import Agent

spaces/AIZeroToHero/04-Image2OCR/README.md

@@ -1,13 +0,0 @@
----
-title: 04 Image2OCR
-emoji: 🚀
-colorFrom: yellow
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.1.5
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/ASJMO/freegpt/g4f/Provider/Providers/Dfehub.py

@@ -1,49 +0,0 @@
-import os
-import requests
-from ...typing import sha256, Dict, get_type_hints
-
-url = "https://chat.dfehub.com"
-model = ['gpt-3.5-turbo', 'gpt-3.5-turbo-16k', 'gpt-4']
-supports_stream = True
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
-    headers = {
-        'Authority': 'chat.dfehub.com',
-        'Content-Type': 'application/json',
-        'Method': 'POST',
-        'Path': '/api/openai/v1/chat/completions',
-        'Scheme': 'https',
-        'Accept': 'text/event-stream',
-        'Accept-Language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7,zh-CN;q=0.6,zh;q=0.5',
-        'Content-Type': 'application/json',
-        'Origin': 'https://chat.dfehub.com',
-        'Referer': 'https://chat.dfehub.com/',
-        'Sec-Ch-Ua': '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
-        'Sec-Ch-Ua-Mobile': '?0',
-        'Sec-Ch-Ua-Platform': '"Windows"',
-        'Sec-Fetch-Dest': 'empty',
-        'Sec-Fetch-Mode': 'cors',
-        'Sec-Fetch-Site': 'same-origin',
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
-        'X-Requested-With': 'XMLHttpRequest',
-    }
-
-    data = {
-        'model': model,
-        'temperature': 0.7,
-        'max_tokens': '8000',
-        'presence_penalty': 0,
-        'messages': messages,
-    }
-    
-    response = requests.post(url + '/api/openai/v1/chat/completions',
-                             headers=headers, json=data, stream=stream)
-
-    yield response.json()['choices'][0]['message']['content']
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
-    '(%s)' % ', '.join(
-        [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])

spaces/Aashir01/Live_Transcription/app.py

@@ -1,236 +0,0 @@
-import base64
-import math
-import os
-import time
-from functools import partial
-from multiprocessing import Pool
-
-import gradio as gr
-import numpy as np
-import pytube
-import requests
-from processing_whisper import WhisperPrePostProcessor
-from transformers.models.whisper.tokenization_whisper import TO_LANGUAGE_CODE
-from transformers.pipelines.audio_utils import ffmpeg_read
-
-
-title = "Whisper JAX: The Fastest Whisper API ⚡️"
-
-description = """Whisper JAX is an optimised implementation of the [Whisper model](https://huggingface.co/openai/whisper-large-v2) by OpenAI. It runs on JAX with a TPU v4-8 in the backend. Compared to PyTorch on an A100 GPU, it is over [**70x faster**](https://github.com/sanchit-gandhi/whisper-jax#benchmarks), making it the fastest Whisper API available.
-
-Note that at peak times, you may find yourself in the queue for this demo. When you submit a request, your queue position will be shown in the top right-hand side of the demo pane. Once you reach the front of the queue, your audio file will be sent to the TPU and then transcribed, with the progress displayed through a progress bar. 
-
-To skip the queue, you may wish to create your own inference endpoint, details for which can be found in the [Whisper JAX repository](https://github.com/sanchit-gandhi/whisper-jax#creating-an-endpoint).
-"""
-
-article = "Whisper large-v2 model by OpenAI. Backend running JAX on a TPU v4-8 through the generous support of the [TRC](https://sites.research.google/trc/about/) programme. Whisper JAX [code](https://github.com/sanchit-gandhi/whisper-jax) and Gradio demo by 🤗 Hugging Face."
-
-API_SEND_URL = os.getenv("API_SEND_URL")
-API_FORWARD_URL = os.getenv("API_FORWARD_URL")
-
-language_names = sorted(TO_LANGUAGE_CODE.keys())
-CHUNK_LENGTH_S = 30
-BATCH_SIZE = 16
-NUM_PROC = 16
-FILE_LIMIT_MB = 1000
-
-
-def query(url, payload):
-    response = requests.post(url, json=payload)
-    return response.json(), response.status_code
-
-
-def inference(batch_id, idx, task=None, return_timestamps=False):
-    payload = {"batch_id": batch_id, "idx": idx, "task": task, "return_timestamps": return_timestamps}
-
-    data, status_code = query(API_FORWARD_URL, payload)
-
-    if status_code == 200:
-        tokens = {"tokens": np.asarray(data["tokens"])}
-        return tokens
-    else:
-        gr.Error(data["detail"])
-
-
-def send_chunks(batch, batch_id):
-    feature_shape = batch["input_features"].shape
-    batch["input_features"] = base64.b64encode(batch["input_features"].tobytes()).decode()
-    query(API_SEND_URL, {"batch": batch, "feature_shape": feature_shape, "batch_id": batch_id})
-
-
-def forward(batch_id, idx, task=None, return_timestamps=False):
-    outputs = inference(batch_id, idx, task, return_timestamps)
-    return outputs
-
-
-# Copied from https://github.com/openai/whisper/blob/c09a7ae299c4c34c5839a76380ae407e7d785914/whisper/utils.py#L50
-def format_timestamp(seconds: float, always_include_hours: bool = False, decimal_marker: str = "."):
-    if seconds is not None:
-        milliseconds = round(seconds * 1000.0)
-
-        hours = milliseconds // 3_600_000
-        milliseconds -= hours * 3_600_000
-
-        minutes = milliseconds // 60_000
-        milliseconds -= minutes * 60_000
-
-        seconds = milliseconds // 1_000
-        milliseconds -= seconds * 1_000
-
-        hours_marker = f"{hours:02d}:" if always_include_hours or hours > 0 else ""
-        return f"{hours_marker}{minutes:02d}:{seconds:02d}{decimal_marker}{milliseconds:03d}"
-    else:
-        # we have a malformed timestamp so just return it as is
-        return seconds
-
-
-if __name__ == "__main__":
-    processor = WhisperPrePostProcessor.from_pretrained("openai/whisper-large-v2")
-    stride_length_s = CHUNK_LENGTH_S / 6
-    chunk_len = round(CHUNK_LENGTH_S * processor.feature_extractor.sampling_rate)
-    stride_left = stride_right = round(stride_length_s * processor.feature_extractor.sampling_rate)
-    step = chunk_len - stride_left - stride_right
-    pool = Pool(NUM_PROC)
-
-    def tqdm_generate(inputs: dict, task: str, return_timestamps: bool, progress: gr.Progress):
-        inputs_len = inputs["array"].shape[0]
-        all_chunk_start_batch_id = np.arange(0, inputs_len, step)
-        num_samples = len(all_chunk_start_batch_id)
-        num_batches = math.ceil(num_samples / BATCH_SIZE)
-        dummy_batches = list(range(num_batches))
-
-        dataloader = processor.preprocess_batch(inputs, chunk_length_s=CHUNK_LENGTH_S, batch_size=BATCH_SIZE)
-        progress(0, desc="Sending audio to TPU...")
-        batch_id = np.random.randint(
-            1000000
-        )  # TODO(SG): swap to an iterator - currently taking our 1 in a million chances
-        pool.map(partial(send_chunks, batch_id=batch_id), dataloader)
-
-        model_outputs = []
-        start_time = time.time()
-        # iterate over our chunked audio samples
-        for idx in progress.tqdm(dummy_batches, desc="Transcribing..."):
-            model_outputs.append(forward(batch_id, idx, task=task, return_timestamps=return_timestamps))
-        runtime = time.time() - start_time
-
-        post_processed = processor.postprocess(model_outputs, return_timestamps=return_timestamps)
-        text = post_processed["text"]
-        timestamps = post_processed.get("chunks")
-        if timestamps is not None:
-            timestamps = [
-                f"[{format_timestamp(chunk['timestamp'][0])} -> {format_timestamp(chunk['timestamp'][1])}] {chunk['text']}"
-                for chunk in timestamps
-            ]
-            text = "\n".join(str(feature) for feature in timestamps)
-        return text, runtime
-
-    def transcribe_chunked_audio(inputs, task, return_timestamps, progress=gr.Progress()):
-        progress(0, desc="Loading audio file...")
-        if inputs is None:
-            raise gr.Error("No audio file submitted! Please upload an audio file before submitting your request.")
-        file_size_mb = os.stat(inputs).st_size / (1024 * 1024)
-        if file_size_mb > FILE_LIMIT_MB:
-            raise gr.Error(
-                f"File size exceeds file size limit. Got file of size {file_size_mb:.2f}MB for a limit of {FILE_LIMIT_MB}MB."
-            )
-
-        with open(inputs, "rb") as f:
-            inputs = f.read()
-
-        inputs = ffmpeg_read(inputs, processor.feature_extractor.sampling_rate)
-        inputs = {"array": inputs, "sampling_rate": processor.feature_extractor.sampling_rate}
-        text, runtime = tqdm_generate(inputs, task=task, return_timestamps=return_timestamps, progress=progress)
-        return text, runtime
-
-    def _return_yt_html_embed(yt_url):
-        video_id = yt_url.split("?v=")[-1]
-        HTML_str = (
-            f'<center> <iframe width="500" height="320" src="https://www.youtube.com/embed/{video_id}"> </iframe>'
-            " </center>"
-        )
-        return HTML_str
-
-    def transcribe_youtube(yt_url, task, return_timestamps, progress=gr.Progress(), max_filesize=75.0):
-        progress(0, desc="Loading audio file...")
-        html_embed_str = _return_yt_html_embed(yt_url)
-        try:
-            yt = pytube.YouTube(yt_url)
-            stream = yt.streams.filter(only_audio=True)[0]
-        except:
-            raise gr.Error("An error occurred while loading the YouTube video. Please try again.")
-
-        if stream.filesize_mb > max_filesize:
-            raise gr.Error(f"Maximum YouTube file size is {max_filesize}MB, got {stream.filesize_mb:.2f}MB.")
-
-        stream.download(filename="audio.mp3")
-
-        with open("audio.mp3", "rb") as f:
-            inputs = f.read()
-
-        inputs = ffmpeg_read(inputs, processor.feature_extractor.sampling_rate)
-        inputs = {"array": inputs, "sampling_rate": processor.feature_extractor.sampling_rate}
-        text, runtime = tqdm_generate(inputs, task=task, return_timestamps=return_timestamps, progress=progress)
-        return html_embed_str, text, runtime
-
-    microphone_chunked = gr.Interface(
-        fn=transcribe_chunked_audio,
-        inputs=[
-            gr.inputs.Audio(source="microphone", optional=True, type="filepath"),
-            gr.inputs.Radio(["transcribe", "translate"], label="Task", default="transcribe"),
-            gr.inputs.Checkbox(default=False, label="Return timestamps"),
-        ],
-        outputs=[
-            gr.outputs.Textbox(label="Transcription").style(show_copy_button=True),
-            gr.outputs.Textbox(label="Transcription Time (s)"),
-        ],
-        allow_flagging="never",
-        title=title,
-        description=description,
-        article=article,
-    )
-
-    audio_chunked = gr.Interface(
-        fn=transcribe_chunked_audio,
-        inputs=[
-            gr.inputs.Audio(source="upload", optional=True, label="Audio file", type="filepath"),
-            gr.inputs.Radio(["transcribe", "translate"], label="Task", default="transcribe"),
-            gr.inputs.Checkbox(default=False, label="Return timestamps"),
-        ],
-        outputs=[
-            gr.outputs.Textbox(label="Transcription").style(show_copy_button=True),
-            gr.outputs.Textbox(label="Transcription Time (s)"),
-        ],
-        allow_flagging="never",
-        title=title,
-        description=description,
-        article=article,
-    )
-
-    youtube = gr.Interface(
-        fn=transcribe_youtube,
-        inputs=[
-            gr.inputs.Textbox(lines=1, placeholder="Paste the URL to a YouTube video here", label="YouTube URL"),
-            gr.inputs.Radio(["transcribe", "translate"], label="Task", default="transcribe"),
-            gr.inputs.Checkbox(default=False, label="Return timestamps"),
-        ],
-        outputs=[
-            gr.outputs.HTML(label="Video"),
-            gr.outputs.Textbox(label="Transcription").style(show_copy_button=True),
-            gr.outputs.Textbox(label="Transcription Time (s)"),
-        ],
-        allow_flagging="never",
-        title=title,
-        examples=[["https://www.youtube.com/watch?v=m8u-18Q0s7I", "transcribe", False]],
-        cache_examples=False,
-        description=description,
-        article=article,
-    )
-
-    demo = gr.Blocks()
-
-    with demo:
-        gr.TabbedInterface([microphone_chunked, audio_chunked, youtube], ["Microphone", "Audio File", "YouTube"])
-
-    demo.queue(max_size=10)
-    demo.launch(show_api=False, max_threads=10)
-

spaces/Abhaykoul/Wizard-AI/README.md

@@ -1,12 +0,0 @@
----
-title: Wizard AI
-emoji: 🏃
-colorFrom: gray
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.28.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/layermanager.d.ts

@@ -1,2 +0,0 @@
-import LayerManager from './gameobjects/layer/layermanager/LayerManager';
-export default LayerManager;

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

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

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/chart/UpdateChart.js

@@ -1,8 +0,0 @@
-var UpdateChart = function () {
-    if (this.chart === undefined) {
-        return this;
-    }
-    this.chart.update();
-    return this;
-}
-export default UpdateChart;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/maker/builders/CreateImage.js

@@ -1,9 +0,0 @@
-import CreateAnyImage from './utils/CreateAnyImage.js';
-
-const PhaserImage = Phaser.GameObjects.Image;
-
-var CreateImage = function (scene, data, view, styles, customBuilders) {
-    return CreateAnyImage(scene, data, view, styles, customBuilders, PhaserImage);
-}
-
-export default CreateImage;

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/using-diffusers/unconditional_image_generation.md

@@ -1,69 +0,0 @@
-<!--Copyright 2023 The HuggingFace Team. All rights reserved.
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-specific language governing permissions and limitations under the License.
--->
-
-# Unconditional image generation
-
-[[open-in-colab]]
-
-Unconditional image generation is a relatively straightforward task. The model only generates images - without any additional context like text or an image - resembling the training data it was trained on.
-
-The [`DiffusionPipeline`] is the easiest way to use a pre-trained diffusion system for inference.
-
-Start by creating an instance of [`DiffusionPipeline`] and specify which pipeline checkpoint you would like to download.
-You can use any of the 🧨 Diffusers [checkpoints](https://huggingface.co/models?library=diffusers&sort=downloads) from the Hub (the checkpoint you'll use generates images of butterflies).
-
-<Tip>
-
-💡 Want to train your own unconditional image generation model? Take a look at the training [guide](training/unconditional_training) to learn how to generate your own images.
-
-</Tip>
-
-In this guide, you'll use [`DiffusionPipeline`] for unconditional image generation with [DDPM](https://arxiv.org/abs/2006.11239):
-
-```python
->>> from diffusers import DiffusionPipeline
-
->>> generator = DiffusionPipeline.from_pretrained("anton-l/ddpm-butterflies-128")
-```
-
-The [`DiffusionPipeline`] downloads and caches all modeling, tokenization, and scheduling components. 
-Because the model consists of roughly 1.4 billion parameters, we strongly recommend running it on a GPU.
-You can move the generator object to a GPU, just like you would in PyTorch:
-
-```python
->>> generator.to("cuda")
-```
-
-Now you can use the `generator` to generate an image:
-
-```python
->>> image = generator().images[0]
-```
-
-The output is by default wrapped into a [`PIL.Image`](https://pillow.readthedocs.io/en/stable/reference/Image.html?highlight=image#the-image-class) object.
-
-You can save the image by calling:
-
-```python
->>> image.save("generated_image.png")
-```
-
-Try out the Spaces below, and feel free to play around with the inference steps parameter to see how it affects the image quality!
-
-<iframe
-	src="https://stevhliu-ddpm-butterflies-128.hf.space"
-	frameborder="0"
-	width="850"
-	height="500"
-></iframe>
-
-

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/stable_diffusion_tensorrt_inpaint.py

@@ -1,1088 +0,0 @@
-#
-# Copyright 2023 The HuggingFace Inc. team.
-# SPDX-FileCopyrightText: Copyright (c) 1993-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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 gc
-import os
-from collections import OrderedDict
-from copy import copy
-from typing import List, Optional, Union
-
-import numpy as np
-import onnx
-import onnx_graphsurgeon as gs
-import PIL
-import tensorrt as trt
-import torch
-from huggingface_hub import snapshot_download
-from onnx import shape_inference
-from polygraphy import cuda
-from polygraphy.backend.common import bytes_from_path
-from polygraphy.backend.onnx.loader import fold_constants
-from polygraphy.backend.trt import (
-    CreateConfig,
-    Profile,
-    engine_from_bytes,
-    engine_from_network,
-    network_from_onnx_path,
-    save_engine,
-)
-from polygraphy.backend.trt import util as trt_util
-from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-from diffusers.models import AutoencoderKL, UNet2DConditionModel
-from diffusers.pipelines.stable_diffusion import (
-    StableDiffusionInpaintPipeline,
-    StableDiffusionPipelineOutput,
-    StableDiffusionSafetyChecker,
-)
-from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_inpaint import prepare_mask_and_masked_image
-from diffusers.schedulers import DDIMScheduler
-from diffusers.utils import DIFFUSERS_CACHE, logging
-
-
-"""
-Installation instructions
-python3 -m pip install --upgrade transformers diffusers>=0.16.0
-python3 -m pip install --upgrade tensorrt>=8.6.1
-python3 -m pip install --upgrade polygraphy>=0.47.0 onnx-graphsurgeon --extra-index-url https://pypi.ngc.nvidia.com
-python3 -m pip install onnxruntime
-"""
-
-TRT_LOGGER = trt.Logger(trt.Logger.ERROR)
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-# Map of numpy dtype -> torch dtype
-numpy_to_torch_dtype_dict = {
-    np.uint8: torch.uint8,
-    np.int8: torch.int8,
-    np.int16: torch.int16,
-    np.int32: torch.int32,
-    np.int64: torch.int64,
-    np.float16: torch.float16,
-    np.float32: torch.float32,
-    np.float64: torch.float64,
-    np.complex64: torch.complex64,
-    np.complex128: torch.complex128,
-}
-if np.version.full_version >= "1.24.0":
-    numpy_to_torch_dtype_dict[np.bool_] = torch.bool
-else:
-    numpy_to_torch_dtype_dict[np.bool] = torch.bool
-
-# Map of torch dtype -> numpy dtype
-torch_to_numpy_dtype_dict = {value: key for (key, value) in numpy_to_torch_dtype_dict.items()}
-
-
-def device_view(t):
-    return cuda.DeviceView(ptr=t.data_ptr(), shape=t.shape, dtype=torch_to_numpy_dtype_dict[t.dtype])
-
-
-def preprocess_image(image):
-    """
-    image: torch.Tensor
-    """
-    w, h = image.size
-    w, h = (x - x % 32 for x in (w, h))  # resize to integer multiple of 32
-    image = image.resize((w, h))
-    image = np.array(image).astype(np.float32) / 255.0
-    image = image[None].transpose(0, 3, 1, 2)
-    image = torch.from_numpy(image).contiguous()
-    return 2.0 * image - 1.0
-
-
-class Engine:
-    def __init__(self, engine_path):
-        self.engine_path = engine_path
-        self.engine = None
-        self.context = None
-        self.buffers = OrderedDict()
-        self.tensors = OrderedDict()
-
-    def __del__(self):
-        [buf.free() for buf in self.buffers.values() if isinstance(buf, cuda.DeviceArray)]
-        del self.engine
-        del self.context
-        del self.buffers
-        del self.tensors
-
-    def build(
-        self,
-        onnx_path,
-        fp16,
-        input_profile=None,
-        enable_preview=False,
-        enable_all_tactics=False,
-        timing_cache=None,
-        workspace_size=0,
-    ):
-        logger.warning(f"Building TensorRT engine for {onnx_path}: {self.engine_path}")
-        p = Profile()
-        if input_profile:
-            for name, dims in input_profile.items():
-                assert len(dims) == 3
-                p.add(name, min=dims[0], opt=dims[1], max=dims[2])
-
-        config_kwargs = {}
-
-        config_kwargs["preview_features"] = [trt.PreviewFeature.DISABLE_EXTERNAL_TACTIC_SOURCES_FOR_CORE_0805]
-        if enable_preview:
-            # Faster dynamic shapes made optional since it increases engine build time.
-            config_kwargs["preview_features"].append(trt.PreviewFeature.FASTER_DYNAMIC_SHAPES_0805)
-        if workspace_size > 0:
-            config_kwargs["memory_pool_limits"] = {trt.MemoryPoolType.WORKSPACE: workspace_size}
-        if not enable_all_tactics:
-            config_kwargs["tactic_sources"] = []
-
-        engine = engine_from_network(
-            network_from_onnx_path(onnx_path, flags=[trt.OnnxParserFlag.NATIVE_INSTANCENORM]),
-            config=CreateConfig(fp16=fp16, profiles=[p], load_timing_cache=timing_cache, **config_kwargs),
-            save_timing_cache=timing_cache,
-        )
-        save_engine(engine, path=self.engine_path)
-
-    def load(self):
-        logger.warning(f"Loading TensorRT engine: {self.engine_path}")
-        self.engine = engine_from_bytes(bytes_from_path(self.engine_path))
-
-    def activate(self):
-        self.context = self.engine.create_execution_context()
-
-    def allocate_buffers(self, shape_dict=None, device="cuda"):
-        for idx in range(trt_util.get_bindings_per_profile(self.engine)):
-            binding = self.engine[idx]
-            if shape_dict and binding in shape_dict:
-                shape = shape_dict[binding]
-            else:
-                shape = self.engine.get_binding_shape(binding)
-            dtype = trt.nptype(self.engine.get_binding_dtype(binding))
-            if self.engine.binding_is_input(binding):
-                self.context.set_binding_shape(idx, shape)
-            tensor = torch.empty(tuple(shape), dtype=numpy_to_torch_dtype_dict[dtype]).to(device=device)
-            self.tensors[binding] = tensor
-            self.buffers[binding] = cuda.DeviceView(ptr=tensor.data_ptr(), shape=shape, dtype=dtype)
-
-    def infer(self, feed_dict, stream):
-        start_binding, end_binding = trt_util.get_active_profile_bindings(self.context)
-        # shallow copy of ordered dict
-        device_buffers = copy(self.buffers)
-        for name, buf in feed_dict.items():
-            assert isinstance(buf, cuda.DeviceView)
-            device_buffers[name] = buf
-        bindings = [0] * start_binding + [buf.ptr for buf in device_buffers.values()]
-        noerror = self.context.execute_async_v2(bindings=bindings, stream_handle=stream.ptr)
-        if not noerror:
-            raise ValueError("ERROR: inference failed.")
-
-        return self.tensors
-
-
-class Optimizer:
-    def __init__(self, onnx_graph):
-        self.graph = gs.import_onnx(onnx_graph)
-
-    def cleanup(self, return_onnx=False):
-        self.graph.cleanup().toposort()
-        if return_onnx:
-            return gs.export_onnx(self.graph)
-
-    def select_outputs(self, keep, names=None):
-        self.graph.outputs = [self.graph.outputs[o] for o in keep]
-        if names:
-            for i, name in enumerate(names):
-                self.graph.outputs[i].name = name
-
-    def fold_constants(self, return_onnx=False):
-        onnx_graph = fold_constants(gs.export_onnx(self.graph), allow_onnxruntime_shape_inference=True)
-        self.graph = gs.import_onnx(onnx_graph)
-        if return_onnx:
-            return onnx_graph
-
-    def infer_shapes(self, return_onnx=False):
-        onnx_graph = gs.export_onnx(self.graph)
-        if onnx_graph.ByteSize() > 2147483648:
-            raise TypeError("ERROR: model size exceeds supported 2GB limit")
-        else:
-            onnx_graph = shape_inference.infer_shapes(onnx_graph)
-
-        self.graph = gs.import_onnx(onnx_graph)
-        if return_onnx:
-            return onnx_graph
-
-
-class BaseModel:
-    def __init__(self, model, fp16=False, device="cuda", max_batch_size=16, embedding_dim=768, text_maxlen=77):
-        self.model = model
-        self.name = "SD Model"
-        self.fp16 = fp16
-        self.device = device
-
-        self.min_batch = 1
-        self.max_batch = max_batch_size
-        self.min_image_shape = 256  # min image resolution: 256x256
-        self.max_image_shape = 1024  # max image resolution: 1024x1024
-        self.min_latent_shape = self.min_image_shape // 8
-        self.max_latent_shape = self.max_image_shape // 8
-
-        self.embedding_dim = embedding_dim
-        self.text_maxlen = text_maxlen
-
-    def get_model(self):
-        return self.model
-
-    def get_input_names(self):
-        pass
-
-    def get_output_names(self):
-        pass
-
-    def get_dynamic_axes(self):
-        return None
-
-    def get_sample_input(self, batch_size, image_height, image_width):
-        pass
-
-    def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
-        return None
-
-    def get_shape_dict(self, batch_size, image_height, image_width):
-        return None
-
-    def optimize(self, onnx_graph):
-        opt = Optimizer(onnx_graph)
-        opt.cleanup()
-        opt.fold_constants()
-        opt.infer_shapes()
-        onnx_opt_graph = opt.cleanup(return_onnx=True)
-        return onnx_opt_graph
-
-    def check_dims(self, batch_size, image_height, image_width):
-        assert batch_size >= self.min_batch and batch_size <= self.max_batch
-        assert image_height % 8 == 0 or image_width % 8 == 0
-        latent_height = image_height // 8
-        latent_width = image_width // 8
-        assert latent_height >= self.min_latent_shape and latent_height <= self.max_latent_shape
-        assert latent_width >= self.min_latent_shape and latent_width <= self.max_latent_shape
-        return (latent_height, latent_width)
-
-    def get_minmax_dims(self, batch_size, image_height, image_width, static_batch, static_shape):
-        min_batch = batch_size if static_batch else self.min_batch
-        max_batch = batch_size if static_batch else self.max_batch
-        latent_height = image_height // 8
-        latent_width = image_width // 8
-        min_image_height = image_height if static_shape else self.min_image_shape
-        max_image_height = image_height if static_shape else self.max_image_shape
-        min_image_width = image_width if static_shape else self.min_image_shape
-        max_image_width = image_width if static_shape else self.max_image_shape
-        min_latent_height = latent_height if static_shape else self.min_latent_shape
-        max_latent_height = latent_height if static_shape else self.max_latent_shape
-        min_latent_width = latent_width if static_shape else self.min_latent_shape
-        max_latent_width = latent_width if static_shape else self.max_latent_shape
-        return (
-            min_batch,
-            max_batch,
-            min_image_height,
-            max_image_height,
-            min_image_width,
-            max_image_width,
-            min_latent_height,
-            max_latent_height,
-            min_latent_width,
-            max_latent_width,
-        )
-
-
-def getOnnxPath(model_name, onnx_dir, opt=True):
-    return os.path.join(onnx_dir, model_name + (".opt" if opt else "") + ".onnx")
-
-
-def getEnginePath(model_name, engine_dir):
-    return os.path.join(engine_dir, model_name + ".plan")
-
-
-def build_engines(
-    models: dict,
-    engine_dir,
-    onnx_dir,
-    onnx_opset,
-    opt_image_height,
-    opt_image_width,
-    opt_batch_size=1,
-    force_engine_rebuild=False,
-    static_batch=False,
-    static_shape=True,
-    enable_preview=False,
-    enable_all_tactics=False,
-    timing_cache=None,
-    max_workspace_size=0,
-):
-    built_engines = {}
-    if not os.path.isdir(onnx_dir):
-        os.makedirs(onnx_dir)
-    if not os.path.isdir(engine_dir):
-        os.makedirs(engine_dir)
-
-    # Export models to ONNX
-    for model_name, model_obj in models.items():
-        engine_path = getEnginePath(model_name, engine_dir)
-        if force_engine_rebuild or not os.path.exists(engine_path):
-            logger.warning("Building Engines...")
-            logger.warning("Engine build can take a while to complete")
-            onnx_path = getOnnxPath(model_name, onnx_dir, opt=False)
-            onnx_opt_path = getOnnxPath(model_name, onnx_dir)
-            if force_engine_rebuild or not os.path.exists(onnx_opt_path):
-                if force_engine_rebuild or not os.path.exists(onnx_path):
-                    logger.warning(f"Exporting model: {onnx_path}")
-                    model = model_obj.get_model()
-                    with torch.inference_mode(), torch.autocast("cuda"):
-                        inputs = model_obj.get_sample_input(opt_batch_size, opt_image_height, opt_image_width)
-                        torch.onnx.export(
-                            model,
-                            inputs,
-                            onnx_path,
-                            export_params=True,
-                            opset_version=onnx_opset,
-                            do_constant_folding=True,
-                            input_names=model_obj.get_input_names(),
-                            output_names=model_obj.get_output_names(),
-                            dynamic_axes=model_obj.get_dynamic_axes(),
-                        )
-                    del model
-                    torch.cuda.empty_cache()
-                    gc.collect()
-                else:
-                    logger.warning(f"Found cached model: {onnx_path}")
-
-                # Optimize onnx
-                if force_engine_rebuild or not os.path.exists(onnx_opt_path):
-                    logger.warning(f"Generating optimizing model: {onnx_opt_path}")
-                    onnx_opt_graph = model_obj.optimize(onnx.load(onnx_path))
-                    onnx.save(onnx_opt_graph, onnx_opt_path)
-                else:
-                    logger.warning(f"Found cached optimized model: {onnx_opt_path} ")
-
-    # Build TensorRT engines
-    for model_name, model_obj in models.items():
-        engine_path = getEnginePath(model_name, engine_dir)
-        engine = Engine(engine_path)
-        onnx_path = getOnnxPath(model_name, onnx_dir, opt=False)
-        onnx_opt_path = getOnnxPath(model_name, onnx_dir)
-
-        if force_engine_rebuild or not os.path.exists(engine.engine_path):
-            engine.build(
-                onnx_opt_path,
-                fp16=True,
-                input_profile=model_obj.get_input_profile(
-                    opt_batch_size,
-                    opt_image_height,
-                    opt_image_width,
-                    static_batch=static_batch,
-                    static_shape=static_shape,
-                ),
-                enable_preview=enable_preview,
-                timing_cache=timing_cache,
-                workspace_size=max_workspace_size,
-            )
-        built_engines[model_name] = engine
-
-    # Load and activate TensorRT engines
-    for model_name, model_obj in models.items():
-        engine = built_engines[model_name]
-        engine.load()
-        engine.activate()
-
-    return built_engines
-
-
-def runEngine(engine, feed_dict, stream):
-    return engine.infer(feed_dict, stream)
-
-
-class CLIP(BaseModel):
-    def __init__(self, model, device, max_batch_size, embedding_dim):
-        super(CLIP, self).__init__(
-            model=model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim
-        )
-        self.name = "CLIP"
-
-    def get_input_names(self):
-        return ["input_ids"]
-
-    def get_output_names(self):
-        return ["text_embeddings", "pooler_output"]
-
-    def get_dynamic_axes(self):
-        return {"input_ids": {0: "B"}, "text_embeddings": {0: "B"}}
-
-    def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
-        self.check_dims(batch_size, image_height, image_width)
-        min_batch, max_batch, _, _, _, _, _, _, _, _ = self.get_minmax_dims(
-            batch_size, image_height, image_width, static_batch, static_shape
-        )
-        return {
-            "input_ids": [(min_batch, self.text_maxlen), (batch_size, self.text_maxlen), (max_batch, self.text_maxlen)]
-        }
-
-    def get_shape_dict(self, batch_size, image_height, image_width):
-        self.check_dims(batch_size, image_height, image_width)
-        return {
-            "input_ids": (batch_size, self.text_maxlen),
-            "text_embeddings": (batch_size, self.text_maxlen, self.embedding_dim),
-        }
-
-    def get_sample_input(self, batch_size, image_height, image_width):
-        self.check_dims(batch_size, image_height, image_width)
-        return torch.zeros(batch_size, self.text_maxlen, dtype=torch.int32, device=self.device)
-
-    def optimize(self, onnx_graph):
-        opt = Optimizer(onnx_graph)
-        opt.select_outputs([0])  # delete graph output#1
-        opt.cleanup()
-        opt.fold_constants()
-        opt.infer_shapes()
-        opt.select_outputs([0], names=["text_embeddings"])  # rename network output
-        opt_onnx_graph = opt.cleanup(return_onnx=True)
-        return opt_onnx_graph
-
-
-def make_CLIP(model, device, max_batch_size, embedding_dim, inpaint=False):
-    return CLIP(model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim)
-
-
-class UNet(BaseModel):
-    def __init__(
-        self, model, fp16=False, device="cuda", max_batch_size=16, embedding_dim=768, text_maxlen=77, unet_dim=4
-    ):
-        super(UNet, self).__init__(
-            model=model,
-            fp16=fp16,
-            device=device,
-            max_batch_size=max_batch_size,
-            embedding_dim=embedding_dim,
-            text_maxlen=text_maxlen,
-        )
-        self.unet_dim = unet_dim
-        self.name = "UNet"
-
-    def get_input_names(self):
-        return ["sample", "timestep", "encoder_hidden_states"]
-
-    def get_output_names(self):
-        return ["latent"]
-
-    def get_dynamic_axes(self):
-        return {
-            "sample": {0: "2B", 2: "H", 3: "W"},
-            "encoder_hidden_states": {0: "2B"},
-            "latent": {0: "2B", 2: "H", 3: "W"},
-        }
-
-    def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
-        latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
-        (
-            min_batch,
-            max_batch,
-            _,
-            _,
-            _,
-            _,
-            min_latent_height,
-            max_latent_height,
-            min_latent_width,
-            max_latent_width,
-        ) = self.get_minmax_dims(batch_size, image_height, image_width, static_batch, static_shape)
-        return {
-            "sample": [
-                (2 * min_batch, self.unet_dim, min_latent_height, min_latent_width),
-                (2 * batch_size, self.unet_dim, latent_height, latent_width),
-                (2 * max_batch, self.unet_dim, max_latent_height, max_latent_width),
-            ],
-            "encoder_hidden_states": [
-                (2 * min_batch, self.text_maxlen, self.embedding_dim),
-                (2 * batch_size, self.text_maxlen, self.embedding_dim),
-                (2 * max_batch, self.text_maxlen, self.embedding_dim),
-            ],
-        }
-
-    def get_shape_dict(self, batch_size, image_height, image_width):
-        latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
-        return {
-            "sample": (2 * batch_size, self.unet_dim, latent_height, latent_width),
-            "encoder_hidden_states": (2 * batch_size, self.text_maxlen, self.embedding_dim),
-            "latent": (2 * batch_size, 4, latent_height, latent_width),
-        }
-
-    def get_sample_input(self, batch_size, image_height, image_width):
-        latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
-        dtype = torch.float16 if self.fp16 else torch.float32
-        return (
-            torch.randn(
-                2 * batch_size, self.unet_dim, latent_height, latent_width, dtype=torch.float32, device=self.device
-            ),
-            torch.tensor([1.0], dtype=torch.float32, device=self.device),
-            torch.randn(2 * batch_size, self.text_maxlen, self.embedding_dim, dtype=dtype, device=self.device),
-        )
-
-
-def make_UNet(model, device, max_batch_size, embedding_dim, inpaint=False, unet_dim=4):
-    return UNet(
-        model,
-        fp16=True,
-        device=device,
-        max_batch_size=max_batch_size,
-        embedding_dim=embedding_dim,
-        unet_dim=unet_dim,
-    )
-
-
-class VAE(BaseModel):
-    def __init__(self, model, device, max_batch_size, embedding_dim):
-        super(VAE, self).__init__(
-            model=model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim
-        )
-        self.name = "VAE decoder"
-
-    def get_input_names(self):
-        return ["latent"]
-
-    def get_output_names(self):
-        return ["images"]
-
-    def get_dynamic_axes(self):
-        return {"latent": {0: "B", 2: "H", 3: "W"}, "images": {0: "B", 2: "8H", 3: "8W"}}
-
-    def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
-        latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
-        (
-            min_batch,
-            max_batch,
-            _,
-            _,
-            _,
-            _,
-            min_latent_height,
-            max_latent_height,
-            min_latent_width,
-            max_latent_width,
-        ) = self.get_minmax_dims(batch_size, image_height, image_width, static_batch, static_shape)
-        return {
-            "latent": [
-                (min_batch, 4, min_latent_height, min_latent_width),
-                (batch_size, 4, latent_height, latent_width),
-                (max_batch, 4, max_latent_height, max_latent_width),
-            ]
-        }
-
-    def get_shape_dict(self, batch_size, image_height, image_width):
-        latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
-        return {
-            "latent": (batch_size, 4, latent_height, latent_width),
-            "images": (batch_size, 3, image_height, image_width),
-        }
-
-    def get_sample_input(self, batch_size, image_height, image_width):
-        latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
-        return torch.randn(batch_size, 4, latent_height, latent_width, dtype=torch.float32, device=self.device)
-
-
-def make_VAE(model, device, max_batch_size, embedding_dim, inpaint=False):
-    return VAE(model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim)
-
-
-class TorchVAEEncoder(torch.nn.Module):
-    def __init__(self, model):
-        super().__init__()
-        self.vae_encoder = model
-
-    def forward(self, x):
-        return self.vae_encoder.encode(x).latent_dist.sample()
-
-
-class VAEEncoder(BaseModel):
-    def __init__(self, model, device, max_batch_size, embedding_dim):
-        super(VAEEncoder, self).__init__(
-            model=model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim
-        )
-        self.name = "VAE encoder"
-
-    def get_model(self):
-        vae_encoder = TorchVAEEncoder(self.model)
-        return vae_encoder
-
-    def get_input_names(self):
-        return ["images"]
-
-    def get_output_names(self):
-        return ["latent"]
-
-    def get_dynamic_axes(self):
-        return {"images": {0: "B", 2: "8H", 3: "8W"}, "latent": {0: "B", 2: "H", 3: "W"}}
-
-    def get_input_profile(self, batch_size, image_height, image_width, static_batch, static_shape):
-        assert batch_size >= self.min_batch and batch_size <= self.max_batch
-        min_batch = batch_size if static_batch else self.min_batch
-        max_batch = batch_size if static_batch else self.max_batch
-        self.check_dims(batch_size, image_height, image_width)
-        (
-            min_batch,
-            max_batch,
-            min_image_height,
-            max_image_height,
-            min_image_width,
-            max_image_width,
-            _,
-            _,
-            _,
-            _,
-        ) = self.get_minmax_dims(batch_size, image_height, image_width, static_batch, static_shape)
-
-        return {
-            "images": [
-                (min_batch, 3, min_image_height, min_image_width),
-                (batch_size, 3, image_height, image_width),
-                (max_batch, 3, max_image_height, max_image_width),
-            ]
-        }
-
-    def get_shape_dict(self, batch_size, image_height, image_width):
-        latent_height, latent_width = self.check_dims(batch_size, image_height, image_width)
-        return {
-            "images": (batch_size, 3, image_height, image_width),
-            "latent": (batch_size, 4, latent_height, latent_width),
-        }
-
-    def get_sample_input(self, batch_size, image_height, image_width):
-        self.check_dims(batch_size, image_height, image_width)
-        return torch.randn(batch_size, 3, image_height, image_width, dtype=torch.float32, device=self.device)
-
-
-def make_VAEEncoder(model, device, max_batch_size, embedding_dim, inpaint=False):
-    return VAEEncoder(model, device=device, max_batch_size=max_batch_size, embedding_dim=embedding_dim)
-
-
-class TensorRTStableDiffusionInpaintPipeline(StableDiffusionInpaintPipeline):
-    r"""
-    Pipeline for inpainting using TensorRT accelerated Stable Diffusion.
-
-    This model inherits from [`StableDiffusionInpaintPipeline`]. 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`.
-    """
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: DDIMScheduler,
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPFeatureExtractor,
-        requires_safety_checker: bool = True,
-        stages=["clip", "unet", "vae", "vae_encoder"],
-        image_height: int = 512,
-        image_width: int = 512,
-        max_batch_size: int = 16,
-        # ONNX export parameters
-        onnx_opset: int = 17,
-        onnx_dir: str = "onnx",
-        # TensorRT engine build parameters
-        engine_dir: str = "engine",
-        build_preview_features: bool = True,
-        force_engine_rebuild: bool = False,
-        timing_cache: str = "timing_cache",
-    ):
-        super().__init__(
-            vae, text_encoder, tokenizer, unet, scheduler, safety_checker, feature_extractor, requires_safety_checker
-        )
-
-        self.vae.forward = self.vae.decode
-
-        self.stages = stages
-        self.image_height, self.image_width = image_height, image_width
-        self.inpaint = True
-        self.onnx_opset = onnx_opset
-        self.onnx_dir = onnx_dir
-        self.engine_dir = engine_dir
-        self.force_engine_rebuild = force_engine_rebuild
-        self.timing_cache = timing_cache
-        self.build_static_batch = False
-        self.build_dynamic_shape = False
-        self.build_preview_features = build_preview_features
-
-        self.max_batch_size = max_batch_size
-        # TODO: Restrict batch size to 4 for larger image dimensions as a WAR for TensorRT limitation.
-        if self.build_dynamic_shape or self.image_height > 512 or self.image_width > 512:
-            self.max_batch_size = 4
-
-        self.stream = None  # loaded in loadResources()
-        self.models = {}  # loaded in __loadModels()
-        self.engine = {}  # loaded in build_engines()
-
-    def __loadModels(self):
-        # Load pipeline models
-        self.embedding_dim = self.text_encoder.config.hidden_size
-        models_args = {
-            "device": self.torch_device,
-            "max_batch_size": self.max_batch_size,
-            "embedding_dim": self.embedding_dim,
-            "inpaint": self.inpaint,
-        }
-        if "clip" in self.stages:
-            self.models["clip"] = make_CLIP(self.text_encoder, **models_args)
-        if "unet" in self.stages:
-            self.models["unet"] = make_UNet(self.unet, **models_args, unet_dim=self.unet.config.in_channels)
-        if "vae" in self.stages:
-            self.models["vae"] = make_VAE(self.vae, **models_args)
-        if "vae_encoder" in self.stages:
-            self.models["vae_encoder"] = make_VAEEncoder(self.vae, **models_args)
-
-    @classmethod
-    def set_cached_folder(cls, pretrained_model_name_or_path: Optional[Union[str, os.PathLike]], **kwargs):
-        cache_dir = kwargs.pop("cache_dir", DIFFUSERS_CACHE)
-        resume_download = kwargs.pop("resume_download", False)
-        proxies = kwargs.pop("proxies", None)
-        local_files_only = kwargs.pop("local_files_only", False)
-        use_auth_token = kwargs.pop("use_auth_token", None)
-        revision = kwargs.pop("revision", None)
-
-        cls.cached_folder = (
-            pretrained_model_name_or_path
-            if os.path.isdir(pretrained_model_name_or_path)
-            else snapshot_download(
-                pretrained_model_name_or_path,
-                cache_dir=cache_dir,
-                resume_download=resume_download,
-                proxies=proxies,
-                local_files_only=local_files_only,
-                use_auth_token=use_auth_token,
-                revision=revision,
-            )
-        )
-
-    def to(self, torch_device: Optional[Union[str, torch.device]] = None, silence_dtype_warnings: bool = False):
-        super().to(torch_device, silence_dtype_warnings=silence_dtype_warnings)
-
-        self.onnx_dir = os.path.join(self.cached_folder, self.onnx_dir)
-        self.engine_dir = os.path.join(self.cached_folder, self.engine_dir)
-        self.timing_cache = os.path.join(self.cached_folder, self.timing_cache)
-
-        # set device
-        self.torch_device = self._execution_device
-        logger.warning(f"Running inference on device: {self.torch_device}")
-
-        # load models
-        self.__loadModels()
-
-        # build engines
-        self.engine = build_engines(
-            self.models,
-            self.engine_dir,
-            self.onnx_dir,
-            self.onnx_opset,
-            opt_image_height=self.image_height,
-            opt_image_width=self.image_width,
-            force_engine_rebuild=self.force_engine_rebuild,
-            static_batch=self.build_static_batch,
-            static_shape=not self.build_dynamic_shape,
-            enable_preview=self.build_preview_features,
-            timing_cache=self.timing_cache,
-        )
-
-        return self
-
-    def __initialize_timesteps(self, timesteps, strength):
-        self.scheduler.set_timesteps(timesteps)
-        offset = self.scheduler.steps_offset if hasattr(self.scheduler, "steps_offset") else 0
-        init_timestep = int(timesteps * strength) + offset
-        init_timestep = min(init_timestep, timesteps)
-        t_start = max(timesteps - init_timestep + offset, 0)
-        timesteps = self.scheduler.timesteps[t_start:].to(self.torch_device)
-        return timesteps, t_start
-
-    def __preprocess_images(self, batch_size, images=()):
-        init_images = []
-        for image in images:
-            image = image.to(self.torch_device).float()
-            image = image.repeat(batch_size, 1, 1, 1)
-            init_images.append(image)
-        return tuple(init_images)
-
-    def __encode_image(self, init_image):
-        init_latents = runEngine(self.engine["vae_encoder"], {"images": device_view(init_image)}, self.stream)[
-            "latent"
-        ]
-        init_latents = 0.18215 * init_latents
-        return init_latents
-
-    def __encode_prompt(self, prompt, negative_prompt):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-             prompt (`str` or `List[str]`, *optional*):
-                prompt to be encoded
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. If not defined, one has to pass
-                `negative_prompt_embeds`. instead. If not defined, one has to pass `negative_prompt_embeds`. instead.
-                Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`).
-        """
-        # Tokenize prompt
-        text_input_ids = (
-            self.tokenizer(
-                prompt,
-                padding="max_length",
-                max_length=self.tokenizer.model_max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-            .input_ids.type(torch.int32)
-            .to(self.torch_device)
-        )
-
-        text_input_ids_inp = device_view(text_input_ids)
-        # NOTE: output tensor for CLIP must be cloned because it will be overwritten when called again for negative prompt
-        text_embeddings = runEngine(self.engine["clip"], {"input_ids": text_input_ids_inp}, self.stream)[
-            "text_embeddings"
-        ].clone()
-
-        # Tokenize negative prompt
-        uncond_input_ids = (
-            self.tokenizer(
-                negative_prompt,
-                padding="max_length",
-                max_length=self.tokenizer.model_max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-            .input_ids.type(torch.int32)
-            .to(self.torch_device)
-        )
-        uncond_input_ids_inp = device_view(uncond_input_ids)
-        uncond_embeddings = runEngine(self.engine["clip"], {"input_ids": uncond_input_ids_inp}, self.stream)[
-            "text_embeddings"
-        ]
-
-        # Concatenate the unconditional and text embeddings into a single batch to avoid doing two forward passes for classifier free guidance
-        text_embeddings = torch.cat([uncond_embeddings, text_embeddings]).to(dtype=torch.float16)
-
-        return text_embeddings
-
-    def __denoise_latent(
-        self, latents, text_embeddings, timesteps=None, step_offset=0, mask=None, masked_image_latents=None
-    ):
-        if not isinstance(timesteps, torch.Tensor):
-            timesteps = self.scheduler.timesteps
-        for step_index, timestep in enumerate(timesteps):
-            # Expand the latents if we are doing classifier free guidance
-            latent_model_input = torch.cat([latents] * 2)
-            latent_model_input = self.scheduler.scale_model_input(latent_model_input, timestep)
-            if isinstance(mask, torch.Tensor):
-                latent_model_input = torch.cat([latent_model_input, mask, masked_image_latents], dim=1)
-
-            # Predict the noise residual
-            timestep_float = timestep.float() if timestep.dtype != torch.float32 else timestep
-
-            sample_inp = device_view(latent_model_input)
-            timestep_inp = device_view(timestep_float)
-            embeddings_inp = device_view(text_embeddings)
-            noise_pred = runEngine(
-                self.engine["unet"],
-                {"sample": sample_inp, "timestep": timestep_inp, "encoder_hidden_states": embeddings_inp},
-                self.stream,
-            )["latent"]
-
-            # Perform guidance
-            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-            noise_pred = noise_pred_uncond + self.guidance_scale * (noise_pred_text - noise_pred_uncond)
-
-            latents = self.scheduler.step(noise_pred, timestep, latents).prev_sample
-
-        latents = 1.0 / 0.18215 * latents
-        return latents
-
-    def __decode_latent(self, latents):
-        images = runEngine(self.engine["vae"], {"latent": device_view(latents)}, self.stream)["images"]
-        images = (images / 2 + 0.5).clamp(0, 1)
-        return images.cpu().permute(0, 2, 3, 1).float().numpy()
-
-    def __loadResources(self, image_height, image_width, batch_size):
-        self.stream = cuda.Stream()
-
-        # Allocate buffers for TensorRT engine bindings
-        for model_name, obj in self.models.items():
-            self.engine[model_name].allocate_buffers(
-                shape_dict=obj.get_shape_dict(batch_size, image_height, image_width), device=self.torch_device
-            )
-
-    @torch.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]] = None,
-        image: Union[torch.FloatTensor, PIL.Image.Image] = None,
-        mask_image: Union[torch.FloatTensor, PIL.Image.Image] = None,
-        strength: float = 0.75,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`.
-                instead.
-            image (`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 (`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)`.
-            strength (`float`, *optional*, defaults to 0.8):
-                Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1. `image`
-                will be used as a starting point, adding more noise to it the larger the `strength`. The number of
-                denoising steps depends on the amount of noise initially added. When `strength` is 1, added noise will
-                be maximum and the denoising process will run for the full number of iterations specified in
-                `num_inference_steps`. A value of 1, therefore, essentially ignores `image`.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. If not defined, one has to pass
-                `negative_prompt_embeds`. instead. If not defined, one has to pass `negative_prompt_embeds`. instead.
-                Ignored when not using guidance (i.e., ignored if `guidance_scale` is less than `1`).
-            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
-                One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
-                to make generation deterministic.
-
-        """
-        self.generator = generator
-        self.denoising_steps = num_inference_steps
-        self.guidance_scale = guidance_scale
-
-        # Pre-compute latent input scales and linear multistep coefficients
-        self.scheduler.set_timesteps(self.denoising_steps, device=self.torch_device)
-
-        # Define call parameters
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-            prompt = [prompt]
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            raise ValueError(f"Expected prompt to be of type list or str but got {type(prompt)}")
-
-        if negative_prompt is None:
-            negative_prompt = [""] * batch_size
-
-        if negative_prompt is not None and isinstance(negative_prompt, str):
-            negative_prompt = [negative_prompt]
-
-        assert len(prompt) == len(negative_prompt)
-
-        if batch_size > self.max_batch_size:
-            raise ValueError(
-                f"Batch size {len(prompt)} is larger than allowed {self.max_batch_size}. If dynamic shape is used, then maximum batch size is 4"
-            )
-
-        # Validate image dimensions
-        mask_width, mask_height = mask_image.size
-        if mask_height != self.image_height or mask_width != self.image_width:
-            raise ValueError(
-                f"Input image height and width {self.image_height} and {self.image_width} are not equal to "
-                f"the respective dimensions of the mask image {mask_height} and {mask_width}"
-            )
-
-        # load resources
-        self.__loadResources(self.image_height, self.image_width, batch_size)
-
-        with torch.inference_mode(), torch.autocast("cuda"), trt.Runtime(TRT_LOGGER):
-            # Spatial dimensions of latent tensor
-            latent_height = self.image_height // 8
-            latent_width = self.image_width // 8
-
-            # Pre-initialize latents
-            num_channels_latents = self.vae.config.latent_channels
-            latents = self.prepare_latents(
-                batch_size,
-                num_channels_latents,
-                self.image_height,
-                self.image_width,
-                torch.float32,
-                self.torch_device,
-                generator,
-            )
-
-            # Pre-process input images
-            mask, masked_image = self.__preprocess_images(batch_size, prepare_mask_and_masked_image(image, mask_image))
-            # print(mask)
-            mask = torch.nn.functional.interpolate(mask, size=(latent_height, latent_width))
-            mask = torch.cat([mask] * 2)
-
-            # Initialize timesteps
-            timesteps, t_start = self.__initialize_timesteps(self.denoising_steps, strength)
-
-            # VAE encode masked image
-            masked_latents = self.__encode_image(masked_image)
-            masked_latents = torch.cat([masked_latents] * 2)
-
-            # CLIP text encoder
-            text_embeddings = self.__encode_prompt(prompt, negative_prompt)
-
-            # UNet denoiser
-            latents = self.__denoise_latent(
-                latents,
-                text_embeddings,
-                timesteps=timesteps,
-                step_offset=t_start,
-                mask=mask,
-                masked_image_latents=masked_latents,
-            )
-
-            # VAE decode latent
-            images = self.__decode_latent(latents)
-
-        images = self.numpy_to_pil(images)
-        return StableDiffusionPipelineOutput(images=images, nsfw_content_detected=None)

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/dummy_torch_and_transformers_and_k_diffusion_objects.py

@@ -1,17 +0,0 @@
-# This file is autogenerated by the command `make fix-copies`, do not edit.
-from ..utils import DummyObject, requires_backends
-
-
-class StableDiffusionKDiffusionPipeline(metaclass=DummyObject):
-    _backends = ["torch", "transformers", "k_diffusion"]
-
-    def __init__(self, *args, **kwargs):
-        requires_backends(self, ["torch", "transformers", "k_diffusion"])
-
-    @classmethod
-    def from_config(cls, *args, **kwargs):
-        requires_backends(cls, ["torch", "transformers", "k_diffusion"])
-
-    @classmethod
-    def from_pretrained(cls, *args, **kwargs):
-        requires_backends(cls, ["torch", "transformers", "k_diffusion"])

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/stable_diffusion_2/test_stable_diffusion_upscale.py

@@ -1,424 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import gc
-import random
-import unittest
-
-import numpy as np
-import torch
-from PIL import Image
-from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
-
-from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNet2DConditionModel
-from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
-from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
-
-
-enable_full_determinism()
-
-
-class StableDiffusionUpscalePipelineFastTests(unittest.TestCase):
-    def tearDown(self):
-        # clean up the VRAM after each test
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-
-    @property
-    def dummy_image(self):
-        batch_size = 1
-        num_channels = 3
-        sizes = (32, 32)
-
-        image = floats_tensor((batch_size, num_channels) + sizes, rng=random.Random(0)).to(torch_device)
-        return image
-
-    @property
-    def dummy_cond_unet_upscale(self):
-        torch.manual_seed(0)
-        model = UNet2DConditionModel(
-            block_out_channels=(32, 32, 64),
-            layers_per_block=2,
-            sample_size=32,
-            in_channels=7,
-            out_channels=4,
-            down_block_types=("DownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D"),
-            up_block_types=("CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "UpBlock2D"),
-            cross_attention_dim=32,
-            # SD2-specific config below
-            attention_head_dim=8,
-            use_linear_projection=True,
-            only_cross_attention=(True, True, False),
-            num_class_embeds=100,
-        )
-        return model
-
-    @property
-    def dummy_vae(self):
-        torch.manual_seed(0)
-        model = AutoencoderKL(
-            block_out_channels=[32, 32, 64],
-            in_channels=3,
-            out_channels=3,
-            down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D", "DownEncoderBlock2D"],
-            up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
-            latent_channels=4,
-        )
-        return model
-
-    @property
-    def dummy_text_encoder(self):
-        torch.manual_seed(0)
-        config = CLIPTextConfig(
-            bos_token_id=0,
-            eos_token_id=2,
-            hidden_size=32,
-            intermediate_size=37,
-            layer_norm_eps=1e-05,
-            num_attention_heads=4,
-            num_hidden_layers=5,
-            pad_token_id=1,
-            vocab_size=1000,
-            # SD2-specific config below
-            hidden_act="gelu",
-            projection_dim=512,
-        )
-        return CLIPTextModel(config)
-
-    def test_stable_diffusion_upscale(self):
-        device = "cpu"  # ensure determinism for the device-dependent torch.Generator
-        unet = self.dummy_cond_unet_upscale
-        low_res_scheduler = DDPMScheduler()
-        scheduler = DDIMScheduler(prediction_type="v_prediction")
-        vae = self.dummy_vae
-        text_encoder = self.dummy_text_encoder
-        tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
-        image = self.dummy_image.cpu().permute(0, 2, 3, 1)[0]
-        low_res_image = Image.fromarray(np.uint8(image)).convert("RGB").resize((64, 64))
-
-        # make sure here that pndm scheduler skips prk
-        sd_pipe = StableDiffusionUpscalePipeline(
-            unet=unet,
-            low_res_scheduler=low_res_scheduler,
-            scheduler=scheduler,
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            max_noise_level=350,
-        )
-        sd_pipe = sd_pipe.to(device)
-        sd_pipe.set_progress_bar_config(disable=None)
-
-        prompt = "A painting of a squirrel eating a burger"
-        generator = torch.Generator(device=device).manual_seed(0)
-        output = sd_pipe(
-            [prompt],
-            image=low_res_image,
-            generator=generator,
-            guidance_scale=6.0,
-            noise_level=20,
-            num_inference_steps=2,
-            output_type="np",
-        )
-
-        image = output.images
-
-        generator = torch.Generator(device=device).manual_seed(0)
-        image_from_tuple = sd_pipe(
-            [prompt],
-            image=low_res_image,
-            generator=generator,
-            guidance_scale=6.0,
-            noise_level=20,
-            num_inference_steps=2,
-            output_type="np",
-            return_dict=False,
-        )[0]
-
-        image_slice = image[0, -3:, -3:, -1]
-        image_from_tuple_slice = image_from_tuple[0, -3:, -3:, -1]
-
-        expected_height_width = low_res_image.size[0] * 4
-        assert image.shape == (1, expected_height_width, expected_height_width, 3)
-        expected_slice = np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-        assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_stable_diffusion_upscale_batch(self):
-        device = "cpu"  # ensure determinism for the device-dependent torch.Generator
-        unet = self.dummy_cond_unet_upscale
-        low_res_scheduler = DDPMScheduler()
-        scheduler = DDIMScheduler(prediction_type="v_prediction")
-        vae = self.dummy_vae
-        text_encoder = self.dummy_text_encoder
-        tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
-        image = self.dummy_image.cpu().permute(0, 2, 3, 1)[0]
-        low_res_image = Image.fromarray(np.uint8(image)).convert("RGB").resize((64, 64))
-
-        # make sure here that pndm scheduler skips prk
-        sd_pipe = StableDiffusionUpscalePipeline(
-            unet=unet,
-            low_res_scheduler=low_res_scheduler,
-            scheduler=scheduler,
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            max_noise_level=350,
-        )
-        sd_pipe = sd_pipe.to(device)
-        sd_pipe.set_progress_bar_config(disable=None)
-
-        prompt = "A painting of a squirrel eating a burger"
-        output = sd_pipe(
-            2 * [prompt],
-            image=2 * [low_res_image],
-            guidance_scale=6.0,
-            noise_level=20,
-            num_inference_steps=2,
-            output_type="np",
-        )
-        image = output.images
-        assert image.shape[0] == 2
-
-        generator = torch.Generator(device=device).manual_seed(0)
-        output = sd_pipe(
-            [prompt],
-            image=low_res_image,
-            generator=generator,
-            num_images_per_prompt=2,
-            guidance_scale=6.0,
-            noise_level=20,
-            num_inference_steps=2,
-            output_type="np",
-        )
-        image = output.images
-        assert image.shape[0] == 2
-
-    def test_stable_diffusion_upscale_prompt_embeds(self):
-        device = "cpu"  # ensure determinism for the device-dependent torch.Generator
-        unet = self.dummy_cond_unet_upscale
-        low_res_scheduler = DDPMScheduler()
-        scheduler = DDIMScheduler(prediction_type="v_prediction")
-        vae = self.dummy_vae
-        text_encoder = self.dummy_text_encoder
-        tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
-        image = self.dummy_image.cpu().permute(0, 2, 3, 1)[0]
-        low_res_image = Image.fromarray(np.uint8(image)).convert("RGB").resize((64, 64))
-
-        # make sure here that pndm scheduler skips prk
-        sd_pipe = StableDiffusionUpscalePipeline(
-            unet=unet,
-            low_res_scheduler=low_res_scheduler,
-            scheduler=scheduler,
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            max_noise_level=350,
-        )
-        sd_pipe = sd_pipe.to(device)
-        sd_pipe.set_progress_bar_config(disable=None)
-
-        prompt = "A painting of a squirrel eating a burger"
-        generator = torch.Generator(device=device).manual_seed(0)
-        output = sd_pipe(
-            [prompt],
-            image=low_res_image,
-            generator=generator,
-            guidance_scale=6.0,
-            noise_level=20,
-            num_inference_steps=2,
-            output_type="np",
-        )
-
-        image = output.images
-
-        generator = torch.Generator(device=device).manual_seed(0)
-        prompt_embeds = sd_pipe._encode_prompt(prompt, device, 1, False)
-        image_from_prompt_embeds = sd_pipe(
-            prompt_embeds=prompt_embeds,
-            image=[low_res_image],
-            generator=generator,
-            guidance_scale=6.0,
-            noise_level=20,
-            num_inference_steps=2,
-            output_type="np",
-            return_dict=False,
-        )[0]
-
-        image_slice = image[0, -3:, -3:, -1]
-        image_from_prompt_embeds_slice = image_from_prompt_embeds[0, -3:, -3:, -1]
-
-        expected_height_width = low_res_image.size[0] * 4
-        assert image.shape == (1, expected_height_width, expected_height_width, 3)
-        expected_slice = np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-        assert np.abs(image_from_prompt_embeds_slice.flatten() - expected_slice).max() < 1e-2
-
-    @unittest.skipIf(torch_device != "cuda", "This test requires a GPU")
-    def test_stable_diffusion_upscale_fp16(self):
-        """Test that stable diffusion upscale works with fp16"""
-        unet = self.dummy_cond_unet_upscale
-        low_res_scheduler = DDPMScheduler()
-        scheduler = DDIMScheduler(prediction_type="v_prediction")
-        vae = self.dummy_vae
-        text_encoder = self.dummy_text_encoder
-        tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
-        image = self.dummy_image.cpu().permute(0, 2, 3, 1)[0]
-        low_res_image = Image.fromarray(np.uint8(image)).convert("RGB").resize((64, 64))
-
-        # put models in fp16, except vae as it overflows in fp16
-        unet = unet.half()
-        text_encoder = text_encoder.half()
-
-        # make sure here that pndm scheduler skips prk
-        sd_pipe = StableDiffusionUpscalePipeline(
-            unet=unet,
-            low_res_scheduler=low_res_scheduler,
-            scheduler=scheduler,
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            max_noise_level=350,
-        )
-        sd_pipe = sd_pipe.to(torch_device)
-        sd_pipe.set_progress_bar_config(disable=None)
-
-        prompt = "A painting of a squirrel eating a burger"
-        generator = torch.manual_seed(0)
-        image = sd_pipe(
-            [prompt],
-            image=low_res_image,
-            generator=generator,
-            num_inference_steps=2,
-            output_type="np",
-        ).images
-
-        expected_height_width = low_res_image.size[0] * 4
-        assert image.shape == (1, expected_height_width, expected_height_width, 3)
-
-
-@slow
-@require_torch_gpu
-class StableDiffusionUpscalePipelineIntegrationTests(unittest.TestCase):
-    def tearDown(self):
-        # clean up the VRAM after each test
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-
-    def test_stable_diffusion_upscale_pipeline(self):
-        image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-            "/sd2-upscale/low_res_cat.png"
-        )
-        expected_image = load_numpy(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
-            "/upsampled_cat.npy"
-        )
-
-        model_id = "stabilityai/stable-diffusion-x4-upscaler"
-        pipe = StableDiffusionUpscalePipeline.from_pretrained(model_id)
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-        pipe.enable_attention_slicing()
-
-        prompt = "a cat sitting on a park bench"
-
-        generator = torch.manual_seed(0)
-        output = pipe(
-            prompt=prompt,
-            image=image,
-            generator=generator,
-            output_type="np",
-        )
-        image = output.images[0]
-
-        assert image.shape == (512, 512, 3)
-        assert np.abs(expected_image - image).max() < 1e-3
-
-    def test_stable_diffusion_upscale_pipeline_fp16(self):
-        image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-            "/sd2-upscale/low_res_cat.png"
-        )
-        expected_image = load_numpy(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale"
-            "/upsampled_cat_fp16.npy"
-        )
-
-        model_id = "stabilityai/stable-diffusion-x4-upscaler"
-        pipe = StableDiffusionUpscalePipeline.from_pretrained(
-            model_id,
-            torch_dtype=torch.float16,
-        )
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-        pipe.enable_attention_slicing()
-
-        prompt = "a cat sitting on a park bench"
-
-        generator = torch.manual_seed(0)
-        output = pipe(
-            prompt=prompt,
-            image=image,
-            generator=generator,
-            output_type="np",
-        )
-        image = output.images[0]
-
-        assert image.shape == (512, 512, 3)
-        assert np.abs(expected_image - image).max() < 5e-1
-
-    def test_stable_diffusion_pipeline_with_sequential_cpu_offloading(self):
-        torch.cuda.empty_cache()
-        torch.cuda.reset_max_memory_allocated()
-        torch.cuda.reset_peak_memory_stats()
-
-        image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-            "/sd2-upscale/low_res_cat.png"
-        )
-
-        model_id = "stabilityai/stable-diffusion-x4-upscaler"
-        pipe = StableDiffusionUpscalePipeline.from_pretrained(
-            model_id,
-            torch_dtype=torch.float16,
-        )
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-        pipe.enable_attention_slicing(1)
-        pipe.enable_sequential_cpu_offload()
-
-        prompt = "a cat sitting on a park bench"
-
-        generator = torch.manual_seed(0)
-        _ = pipe(
-            prompt=prompt,
-            image=image,
-            generator=generator,
-            num_inference_steps=5,
-            output_type="np",
-        )
-
-        mem_bytes = torch.cuda.max_memory_allocated()
-        # make sure that less than 2.9 GB is allocated
-        assert mem_bytes < 2.9 * 10**9

spaces/Andy1621/uniformer_image_detection/configs/faster_rcnn/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco.py

@@ -1,42 +0,0 @@
-_base_ = './faster_rcnn_r50_fpn_1x_coco.py'
-model = dict(
-    pretrained='open-mmlab://detectron2/resnet50_caffe',
-    backbone=dict(
-        norm_cfg=dict(requires_grad=False), norm_eval=True, style='caffe'))
-# use caffe img_norm
-img_norm_cfg = dict(
-    mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False)
-train_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(type='LoadAnnotations', with_bbox=True),
-    dict(
-        type='Resize',
-        img_scale=[(1333, 640), (1333, 672), (1333, 704), (1333, 736),
-                   (1333, 768), (1333, 800)],
-        multiscale_mode='value',
-        keep_ratio=True),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size_divisor=32),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
-]
-test_pipeline = [
-    dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1333, 800),
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='Pad', size_divisor=32),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
-]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))

spaces/Andy1621/uniformer_image_detection/mmdet/core/bbox/assigners/atss_assigner.py

@@ -1,178 +0,0 @@
-import torch
-
-from ..builder import BBOX_ASSIGNERS
-from ..iou_calculators import build_iou_calculator
-from .assign_result import AssignResult
-from .base_assigner import BaseAssigner
-
-
-@BBOX_ASSIGNERS.register_module()
-class ATSSAssigner(BaseAssigner):
-    """Assign a corresponding gt bbox or background to each bbox.
-
-    Each proposals will be assigned with `0` or a positive integer
-    indicating the ground truth index.
-
-    - 0: negative sample, no assigned gt
-    - positive integer: positive sample, index (1-based) of assigned gt
-
-    Args:
-        topk (float): number of bbox selected in each level
-    """
-
-    def __init__(self,
-                 topk,
-                 iou_calculator=dict(type='BboxOverlaps2D'),
-                 ignore_iof_thr=-1):
-        self.topk = topk
-        self.iou_calculator = build_iou_calculator(iou_calculator)
-        self.ignore_iof_thr = ignore_iof_thr
-
-    # https://github.com/sfzhang15/ATSS/blob/master/atss_core/modeling/rpn/atss/loss.py
-
-    def assign(self,
-               bboxes,
-               num_level_bboxes,
-               gt_bboxes,
-               gt_bboxes_ignore=None,
-               gt_labels=None):
-        """Assign gt to bboxes.
-
-        The assignment is done in following steps
-
-        1. compute iou between all bbox (bbox of all pyramid levels) and gt
-        2. compute center distance between all bbox and gt
-        3. on each pyramid level, for each gt, select k bbox whose center
-           are closest to the gt center, so we total select k*l bbox as
-           candidates for each gt
-        4. get corresponding iou for the these candidates, and compute the
-           mean and std, set mean + std as the iou threshold
-        5. select these candidates whose iou are greater than or equal to
-           the threshold as positive
-        6. limit the positive sample's center in gt
-
-
-        Args:
-            bboxes (Tensor): Bounding boxes to be assigned, shape(n, 4).
-            num_level_bboxes (List): num of bboxes in each level
-            gt_bboxes (Tensor): Groundtruth boxes, shape (k, 4).
-            gt_bboxes_ignore (Tensor, optional): Ground truth bboxes that are
-                labelled as `ignored`, e.g., crowd boxes in COCO.
-            gt_labels (Tensor, optional): Label of gt_bboxes, shape (k, ).
-
-        Returns:
-            :obj:`AssignResult`: The assign result.
-        """
-        INF = 100000000
-        bboxes = bboxes[:, :4]
-        num_gt, num_bboxes = gt_bboxes.size(0), bboxes.size(0)
-
-        # compute iou between all bbox and gt
-        overlaps = self.iou_calculator(bboxes, gt_bboxes)
-
-        # assign 0 by default
-        assigned_gt_inds = overlaps.new_full((num_bboxes, ),
-                                             0,
-                                             dtype=torch.long)
-
-        if num_gt == 0 or num_bboxes == 0:
-            # No ground truth or boxes, return empty assignment
-            max_overlaps = overlaps.new_zeros((num_bboxes, ))
-            if num_gt == 0:
-                # No truth, assign everything to background
-                assigned_gt_inds[:] = 0
-            if gt_labels is None:
-                assigned_labels = None
-            else:
-                assigned_labels = overlaps.new_full((num_bboxes, ),
-                                                    -1,
-                                                    dtype=torch.long)
-            return AssignResult(
-                num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
-
-        # compute center distance between all bbox and gt
-        gt_cx = (gt_bboxes[:, 0] + gt_bboxes[:, 2]) / 2.0
-        gt_cy = (gt_bboxes[:, 1] + gt_bboxes[:, 3]) / 2.0
-        gt_points = torch.stack((gt_cx, gt_cy), dim=1)
-
-        bboxes_cx = (bboxes[:, 0] + bboxes[:, 2]) / 2.0
-        bboxes_cy = (bboxes[:, 1] + bboxes[:, 3]) / 2.0
-        bboxes_points = torch.stack((bboxes_cx, bboxes_cy), dim=1)
-
-        distances = (bboxes_points[:, None, :] -
-                     gt_points[None, :, :]).pow(2).sum(-1).sqrt()
-
-        if (self.ignore_iof_thr > 0 and gt_bboxes_ignore is not None
-                and gt_bboxes_ignore.numel() > 0 and bboxes.numel() > 0):
-            ignore_overlaps = self.iou_calculator(
-                bboxes, gt_bboxes_ignore, mode='iof')
-            ignore_max_overlaps, _ = ignore_overlaps.max(dim=1)
-            ignore_idxs = ignore_max_overlaps > self.ignore_iof_thr
-            distances[ignore_idxs, :] = INF
-            assigned_gt_inds[ignore_idxs] = -1
-
-        # Selecting candidates based on the center distance
-        candidate_idxs = []
-        start_idx = 0
-        for level, bboxes_per_level in enumerate(num_level_bboxes):
-            # on each pyramid level, for each gt,
-            # select k bbox whose center are closest to the gt center
-            end_idx = start_idx + bboxes_per_level
-            distances_per_level = distances[start_idx:end_idx, :]
-            selectable_k = min(self.topk, bboxes_per_level)
-            _, topk_idxs_per_level = distances_per_level.topk(
-                selectable_k, dim=0, largest=False)
-            candidate_idxs.append(topk_idxs_per_level + start_idx)
-            start_idx = end_idx
-        candidate_idxs = torch.cat(candidate_idxs, dim=0)
-
-        # get corresponding iou for the these candidates, and compute the
-        # mean and std, set mean + std as the iou threshold
-        candidate_overlaps = overlaps[candidate_idxs, torch.arange(num_gt)]
-        overlaps_mean_per_gt = candidate_overlaps.mean(0)
-        overlaps_std_per_gt = candidate_overlaps.std(0)
-        overlaps_thr_per_gt = overlaps_mean_per_gt + overlaps_std_per_gt
-
-        is_pos = candidate_overlaps >= overlaps_thr_per_gt[None, :]
-
-        # limit the positive sample's center in gt
-        for gt_idx in range(num_gt):
-            candidate_idxs[:, gt_idx] += gt_idx * num_bboxes
-        ep_bboxes_cx = bboxes_cx.view(1, -1).expand(
-            num_gt, num_bboxes).contiguous().view(-1)
-        ep_bboxes_cy = bboxes_cy.view(1, -1).expand(
-            num_gt, num_bboxes).contiguous().view(-1)
-        candidate_idxs = candidate_idxs.view(-1)
-
-        # calculate the left, top, right, bottom distance between positive
-        # bbox center and gt side
-        l_ = ep_bboxes_cx[candidate_idxs].view(-1, num_gt) - gt_bboxes[:, 0]
-        t_ = ep_bboxes_cy[candidate_idxs].view(-1, num_gt) - gt_bboxes[:, 1]
-        r_ = gt_bboxes[:, 2] - ep_bboxes_cx[candidate_idxs].view(-1, num_gt)
-        b_ = gt_bboxes[:, 3] - ep_bboxes_cy[candidate_idxs].view(-1, num_gt)
-        is_in_gts = torch.stack([l_, t_, r_, b_], dim=1).min(dim=1)[0] > 0.01
-        is_pos = is_pos & is_in_gts
-
-        # if an anchor box is assigned to multiple gts,
-        # the one with the highest IoU will be selected.
-        overlaps_inf = torch.full_like(overlaps,
-                                       -INF).t().contiguous().view(-1)
-        index = candidate_idxs.view(-1)[is_pos.view(-1)]
-        overlaps_inf[index] = overlaps.t().contiguous().view(-1)[index]
-        overlaps_inf = overlaps_inf.view(num_gt, -1).t()
-
-        max_overlaps, argmax_overlaps = overlaps_inf.max(dim=1)
-        assigned_gt_inds[
-            max_overlaps != -INF] = argmax_overlaps[max_overlaps != -INF] + 1
-
-        if gt_labels is not None:
-            assigned_labels = assigned_gt_inds.new_full((num_bboxes, ), -1)
-            pos_inds = torch.nonzero(
-                assigned_gt_inds > 0, as_tuple=False).squeeze()
-            if pos_inds.numel() > 0:
-                assigned_labels[pos_inds] = gt_labels[
-                    assigned_gt_inds[pos_inds] - 1]
-        else:
-            assigned_labels = None
-        return AssignResult(
-            num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)

spaces/Andy1621/uniformer_image_detection/mmdet/models/roi_heads/roi_extractors/__init__.py

@@ -1,7 +0,0 @@
-from .generic_roi_extractor import GenericRoIExtractor
-from .single_level_roi_extractor import SingleRoIExtractor
-
-__all__ = [
-    'SingleRoIExtractor',
-    'GenericRoIExtractor',
-]

spaces/Andy1621/uniformer_image_detection/mmdet/utils/collect_env.py

@@ -1,16 +0,0 @@
-from mmcv.utils import collect_env as collect_base_env
-from mmcv.utils import get_git_hash
-
-import mmdet
-
-
-def collect_env():
-    """Collect the information of the running environments."""
-    env_info = collect_base_env()
-    env_info['MMDetection'] = mmdet.__version__ + '+' + get_git_hash()[:7]
-    return env_info
-
-
-if __name__ == '__main__':
-    for name, val in collect_env().items():
-        print(f'{name}: {val}')

spaces/Andy1621/uniformer_image_segmentation/configs/ccnet/ccnet_r101-d8_512x1024_40k_cityscapes.py

@@ -1,2 +0,0 @@
-_base_ = './ccnet_r50-d8_512x1024_40k_cityscapes.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))

spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3/deeplabv3_r50-d8_480x480_80k_pascal_context.py

@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_80k.py'
-]
-model = dict(
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)

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

@@ -1,4 +0,0 @@
-_base_ = './pspnet_r50-d8_512x1024_80k_cityscapes.py'
-model = dict(
-    pretrained='torchvision://resnet101',
-    backbone=dict(type='ResNet', depth=101))

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

@@ -1,2 +0,0 @@
-"""Index interaction code
-"""

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

@@ -1,109 +0,0 @@
-"""Functions brought over from jaraco.text.
-
-These functions are not supposed to be used within `pip._internal`. These are
-helper functions brought over from `jaraco.text` to enable vendoring newer
-copies of `pkg_resources` without having to vendor `jaraco.text` and its entire
-dependency cone; something that our vendoring setup is not currently capable of
-handling.
-
-License reproduced from original source below:
-
-Copyright Jason R. Coombs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-IN THE SOFTWARE.
-"""
-
-import functools
-import itertools
-
-
-def _nonblank(str):
-    return str and not str.startswith("#")
-
-
-@functools.singledispatch
-def yield_lines(iterable):
-    r"""
-    Yield valid lines of a string or iterable.
-
-    >>> list(yield_lines(''))
-    []
-    >>> list(yield_lines(['foo', 'bar']))
-    ['foo', 'bar']
-    >>> list(yield_lines('foo\nbar'))
-    ['foo', 'bar']
-    >>> list(yield_lines('\nfoo\n#bar\nbaz #comment'))
-    ['foo', 'baz #comment']
-    >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n']))
-    ['foo', 'bar', 'baz', 'bing']
-    """
-    return itertools.chain.from_iterable(map(yield_lines, iterable))
-
-
-@yield_lines.register(str)
-def _(text):
-    return filter(_nonblank, map(str.strip, text.splitlines()))
-
-
-def drop_comment(line):
-    """
-    Drop comments.
-
-    >>> drop_comment('foo # bar')
-    'foo'
-
-    A hash without a space may be in a URL.
-
-    >>> drop_comment('http://example.com/foo#bar')
-    'http://example.com/foo#bar'
-    """
-    return line.partition(" #")[0]
-
-
-def join_continuation(lines):
-    r"""
-    Join lines continued by a trailing backslash.
-
-    >>> list(join_continuation(['foo \\', 'bar', 'baz']))
-    ['foobar', 'baz']
-    >>> list(join_continuation(['foo \\', 'bar', 'baz']))
-    ['foobar', 'baz']
-    >>> list(join_continuation(['foo \\', 'bar \\', 'baz']))
-    ['foobarbaz']
-
-    Not sure why, but...
-    The character preceeding the backslash is also elided.
-
-    >>> list(join_continuation(['goo\\', 'dly']))
-    ['godly']
-
-    A terrible idea, but...
-    If no line is available to continue, suppress the lines.
-
-    >>> list(join_continuation(['foo', 'bar\\', 'baz\\']))
-    ['foo']
-    """
-    lines = iter(lines)
-    for item in lines:
-        while item.endswith("\\"):
-            try:
-                item = item[:-2].strip() + next(lines)
-            except StopIteration:
-                return
-        yield item

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

@@ -1,2 +0,0 @@
-# This file is protected via CODEOWNERS
-__version__ = "1.26.15"

spaces/Atualli/yoloxTeste/app1.py

@@ -1,105 +0,0 @@
-import gradio as gr
-import os
-#os.system("pip -qq install yoloxdetect==0.0.7")
-os.system("pip -qq install yoloxdetect")
-import torch
-import json
-import yoloxdetect2.helpers as yoloxdetect
-#from yoloxdetect import YoloxDetector
-
-
-# Images
-torch.hub.download_url_to_file('https://github.com/ultralytics/yolov5/raw/master/data/images/zidane.jpg', 'zidane.jpg')
-torch.hub.download_url_to_file('https://raw.githubusercontent.com/obss/sahi/main/tests/data/small-vehicles1.jpeg', 'small-vehicles1.jpeg')
-torch.hub.download_url_to_file('https://raw.githubusercontent.com/Megvii-BaseDetection/YOLOX/main/assets/dog.jpg', 'dog.jpg')
-
-model = yoloxdetect.YoloxDetector2('kadirnar/yolox_s-v0.1.1', 'configs.yolox_s', device="cuda", hf_model=True)
-
-def yolox_inference(
-    image_path: gr.inputs.Image = None,
-    model_path: gr.inputs.Dropdown = 'kadirnar/yolox_s-v0.1.1',
-    config_path: gr.inputs.Textbox = 'configs.yolox_s',
-    image_size: gr.inputs.Slider = 640
-):
-    """
-    YOLOX inference function
-    Args:
-        image: Input image
-        model_path: Path to the model
-        config_path: Path to the config file
-        image_size: Image size
-    Returns:
-        Rendered image
-    """
-
-    #model = YoloxDetector(model_path, config_path=config_path, device="cpu", hf_model=True)
-    #pred = model.predict(image_path=image_path, image_size=image_size)
-    pred2 = []
-    if model :
-        print (image_path)
-        model.torchyolo = True
-        pred2 = model.predict(image_path=image_path, image_size=image_size)
-        #text = "Ola"
-        #print (vars(model))
-        #print (pred2[0])
-        #print (pred2[1])
-        #print (pred2[2])
-        #os.remove(image_path)
-
-    
-    tensor = {
-      "tensorflow": [ 
-      ]
-    }
-
-    if pred2 is not None:
-        #print (pred2[3])
-        for i, element in enumerate(pred2[0]):
-            object = {}
-            itemclass = round(pred2[2][i].item())
-            object["classe"] = itemclass
-            object["nome"] = pred2[3][itemclass]
-            object["score"] = pred2[1][i].item()
-            object["x"] = element[0].item()
-            object["y"] = element[1].item()
-            object["w"] = element[2].item()
-            object["h"] = element[3].item()
-            tensor["tensorflow"].append(object)
-  
-    #print(tensor)
-
-    text = json.dumps(tensor)
-    return text
-        
-
-inputs = [
-    gr.inputs.Image(type="filepath", label="Input Image"),
-    gr.inputs.Textbox(lines=1, label="Model Path", default="kadirnar/yolox_s-v0.1.1"),
-    gr.inputs.Textbox(lines=1, label="Config Path", default="configs.yolox_s"),
-    gr.inputs.Slider(minimum=320, maximum=1280, default=640, step=32, label="Image Size"),
-]
-
-outputs = gr.outputs.Image(type="filepath", label="Output Image")
-title = "SIMULADOR PARA RECONHECIMENTO DE IMAGEM"
-
-examples = [
-    ["small-vehicles1.jpeg", "kadirnar/yolox_m-v0.1.1", "configs.yolox_m", 640],
-    ["zidane.jpg", "kadirnar/yolox_s-v0.1.1", "configs.yolox_s", 640],
-    ["dog.jpg", "kadirnar/yolox_tiny-v0.1.1", "configs.yolox_tiny", 640],
-]
-
-demo_app = gr.Interface(
-    fn=yolox_inference,
-    inputs=inputs,
-    outputs=["text"],
-    title=title,
-    examples=examples,
-    cache_examples=True,
-    live=True,
-    theme='huggingface',
-)
-try:
-   demo_app.launch(debug=True, server_name="192.168.0.153", server_port=8081, enable_queue=True)
-except:
-   demo_app.close()
-

spaces/AzinZ/vitscn/README.md

@@ -1,13 +0,0 @@
----
-title: Vitscn
-emoji: 🌖
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.44.2
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/AzulaFire/SparkDebate/utils/API.py

@@ -1,244 +0,0 @@
-
-import base64
-import hmac
-import json
-from datetime import datetime, timezone
-from urllib.parse import urlencode, urlparse
-from websocket import create_connection, WebSocketConnectionClosedException
-from utils.tools import get_prompt, process_response, init_script, create_script
-
-
-class SparkAPI:
-    __api_url = 'wss://spark-api.xf-yun.com/v1.1/chat'
-    __max_token = 4096
-
-    def __init__(self, app_id, api_key, api_secret):
-        self.__app_id = app_id
-        self.__api_key = api_key
-        self.__api_secret = api_secret
-
-    def __set_max_tokens(self, token):
-        if isinstance(token, int) is False or token < 0:
-            print("set_max_tokens() error: tokens should be a positive integer!")
-            return
-        self.__max_token = token
-
-    def __get_authorization_url(self):
-        authorize_url = urlparse(self.__api_url)
-        # 1. generate data
-        date = datetime.now(timezone.utc).strftime('%a, %d %b %Y %H:%M:%S %Z')
-
-        """
-        Generation rule of Authorization parameters
-            1) Obtain the APIKey and APISecret parameters from the console.
-            2) Use the aforementioned date to dynamically concatenate a string tmp. Here we take Huobi's URL as an example, 
-                the actual usage requires replacing the host and path with the specific request URL.
-        """
-        signature_origin = "host: {}\ndate: {}\nGET {} HTTP/1.1".format(
-            authorize_url.netloc, date, authorize_url.path
-        )
-        signature = base64.b64encode(
-            hmac.new(
-                self.__api_secret.encode(),
-                signature_origin.encode(),
-                digestmod='sha256'
-            ).digest()
-        ).decode()
-        authorization_origin = \
-            'api_key="{}",algorithm="{}",headers="{}",signature="{}"'.format(
-                self.__api_key, "hmac-sha256", "host date request-line", signature
-            )
-        authorization = base64.b64encode(
-            authorization_origin.encode()).decode()
-        params = {
-            "authorization": authorization,
-            "date": date,
-            "host": authorize_url.netloc
-        }
-
-        ws_url = self.__api_url + "?" + urlencode(params)
-        return ws_url
-
-    def __build_inputs(
-            self,
-            message: dict,
-            user_id: str = "001",
-            domain: str = "general",
-            temperature: float = 0.5,
-            max_tokens: int = 4096
-    ):
-        input_dict = {
-            "header": {
-                "app_id": self.__app_id,
-                "uid": user_id,
-            },
-            "parameter": {
-                "chat": {
-                    "domain": domain,
-                    "temperature": temperature,
-                    "max_tokens": max_tokens,
-                }
-            },
-            "payload": {
-                "message": message
-            }
-        }
-        return json.dumps(input_dict)
-
-    def chat(
-            self,
-            query: str,
-            history: list = None,  # store the conversation history
-            user_id: str = "001",
-            domain: str = "general",
-            max_tokens: int = 4096,
-            temperature: float = 0.5,
-    ):
-        if history is None:
-            history = []
-
-        # the max of max_length is 4096
-        max_tokens = min(max_tokens, 4096)
-        url = self.__get_authorization_url()
-        ws = create_connection(url)
-        message = get_prompt(query, history)
-        input_str = self.__build_inputs(
-            message=message,
-            user_id=user_id,
-            domain=domain,
-            temperature=temperature,
-            max_tokens=max_tokens,
-        )
-        ws.send(input_str)
-        response_str = ws.recv()
-        try:
-            while True:
-                response, history, status = process_response(
-                    response_str, history)
-                """
-                The final return result, which means a complete conversation.
-                doc url: https://www.xfyun.cn/doc/spark/Web.html#_1-%E6%8E%A5%E5%8F%A3%E8%AF%B4%E6%98%8E
-                """
-                if len(response) == 0 or status == 2:
-                    break
-                response_str = ws.recv()
-            return response
-
-        except WebSocketConnectionClosedException:
-            print("Connection closed")
-        finally:
-            ws.close()
-    # Stream output statement, used for terminal chat.
-
-    def streaming_output(
-            self,
-            query: str,
-            history: list = None,  # store the conversation history
-            user_id: str = "001",
-            domain: str = "general",
-            max_tokens: int = 4096,
-            temperature: float = 0.5,
-    ):
-        if history is None:
-            history = []
-        # the max of max_length is 4096
-        max_tokens = min(max_tokens, 4096)
-        url = self.__get_authorization_url()
-        ws = create_connection(url)
-
-        message = get_prompt(query, history)
-        input_str = self.__build_inputs(
-            message=message,
-            user_id=user_id,
-            domain=domain,
-            temperature=temperature,
-            max_tokens=max_tokens,
-        )
-        # print(input_str)
-        # send question or prompt to url, and receive the answer
-        ws.send(input_str)
-        response_str = ws.recv()
-
-        # Continuous conversation
-        try:
-            while True:
-                response, history, status = process_response(
-                    response_str, history)
-                yield response, history
-                if len(response) == 0 or status == 2:
-                    break
-                response_str = ws.recv()
-
-        except WebSocketConnectionClosedException:
-            print("Connection closed")
-        finally:
-            ws.close()
-
-    def chat_stream(self):
-        history = []
-        try:
-            print("输入init来初始化剧本,输入create来创作剧本,输入exit或stop来终止对话\n")
-            while True:
-                query = input("Ask: ")
-                if query == 'init':
-                    jsonfile = input("请输入剧本文件路径:")
-                    script_data = init_script(history, jsonfile)
-                    print(
-                        f"正在导入剧本{script_data['name']},角色信息:{script_data['characters']},剧情介绍:{script_data['summary']}")
-                    query = f"我希望你能够扮演这个剧本杀游戏的主持人，我希望你能够逐步引导玩家到达最终结局，同时希望你在游戏中设定一些随机事件，需要玩家依靠自身的能力解决，当玩家做出偏离主线的行为或者与剧本无关的行为时，你需要委婉地将玩家引导至正常游玩路线中，对于玩家需要决策的事件，你需要提供一些行动推荐,下面是剧本介绍:{script_data}"
-                if query == 'create':
-                    name = input('请输入剧本名称:')
-                    characters = input('请输入角色信息:')
-                    summary = input('请输入剧情介绍:')
-                    details = input('请输入剧本细节')
-                    create_script(name, characters, summary, details)
-                    print('剧本创建成功！')
-                    continue
-                if query == "exit" or query == "stop":
-                    break
-                for response, _ in self.streaming_output(query, history):
-                    print("\r" + response, end="")
-                print("\n")
-        finally:
-            print("\nThank you for using the SparkDesk AI. Welcome to use it again!")
-
-
-from langchain.llms.base import LLM
-from typing import Any, List, Mapping, Optional
-class Spark_forlangchain(LLM):
-
-    # 类的成员变量，类型为整型
-    n: int
-    app_id: str
-    api_key: str
-    api_secret: str
-    # 用于指定该子类对象的类型
-
-    @property
-    def _llm_type(self) -> str:
-        return "Spark"
-
-    # 重写基类方法，根据用户输入的prompt来响应用户，返回字符串
-    def _call(
-            self,
-            query: str,
-            history: list = None,  # store the conversation history
-            user_id: str = "001",
-            domain: str = "general",
-            max_tokens: int = 4096,
-            temperature: float = 0.7,
-            stop: Optional[List[str]] = None,
-    ) -> str:
-        if stop is not None:
-            raise ValueError("stop kwargs are not permitted.")
-        bot = SparkAPI(app_id=self.app_id, api_key=self.api_key,
-                       api_secret=self.api_secret)
-        response = bot.chat(query, history, user_id,
-                            domain, max_tokens, temperature)
-        return response
-
-    # 返回一个字典类型，包含LLM的唯一标识
-    @property
-    def _identifying_params(self) -> Mapping[str, Any]:
-        """Get the identifying parameters."""
-        return {"n": self.n}

spaces/BAAI/vid2vid-zero/vid2vid_zero/pipelines/pipeline_vid2vid_zero.py

@@ -1,541 +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
-from dataclasses import dataclass
-
-import numpy as np
-import torch
-
-from diffusers.utils import is_accelerate_available
-from packaging import version
-from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-from diffusers.configuration_utils import FrozenDict
-from diffusers.models import AutoencoderKL  # UNet2DConditionModel
-from diffusers.pipeline_utils import DiffusionPipeline
-from diffusers.schedulers import (
-    DDIMScheduler,
-    DPMSolverMultistepScheduler,
-    EulerAncestralDiscreteScheduler,
-    EulerDiscreteScheduler,
-    LMSDiscreteScheduler,
-    PNDMScheduler,
-)
-from diffusers.utils import deprecate, logging, BaseOutput
-from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
-
-from einops import rearrange
-
-from ..models.unet_2d_condition import UNet2DConditionModel
-
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-@dataclass
-class Vid2VidZeroPipelineOutput(BaseOutput):
-    images: Union[torch.Tensor, np.ndarray]
-
-
-class Vid2VidZeroPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for text-to-image generation using Stable Diffusion.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving, running on a particular 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", "feature_extractor"]
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: Union[
-            DDIMScheduler,
-            PNDMScheduler,
-            LMSDiscreteScheduler,
-            EulerDiscreteScheduler,
-            EulerAncestralDiscreteScheduler,
-            DPMSolverMultistepScheduler,
-        ],
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPFeatureExtractor,
-        requires_safety_checker: bool = False,
-    ):
-        super().__init__()
-
-        if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
-            deprecation_message = (
-                f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
-                f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
-                "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
-                " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
-                " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
-                " file"
-            )
-            deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(scheduler.config)
-            new_config["steps_offset"] = 1
-            scheduler._internal_dict = FrozenDict(new_config)
-
-        if hasattr(scheduler.config, "clip_sample") and scheduler.config.clip_sample is True:
-            deprecation_message = (
-                f"The configuration file of this scheduler: {scheduler} has not set the configuration `clip_sample`."
-                " `clip_sample` should be set to False in the configuration file. Please make sure to update the"
-                " config accordingly as not setting `clip_sample` in the config might lead to incorrect results in"
-                " future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very"
-                " nice if you could open a Pull request for the `scheduler/scheduler_config.json` file"
-            )
-            deprecate("clip_sample not set", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(scheduler.config)
-            new_config["clip_sample"] = False
-            scheduler._internal_dict = FrozenDict(new_config)
-
-        if safety_checker is None and requires_safety_checker:
-            logger.warning(
-                f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
-                " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
-                " results in services or applications open to the public. Both the diffusers team and Hugging Face"
-                " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
-                " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
-                " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
-            )
-
-        if safety_checker is not None and feature_extractor is None:
-            raise ValueError(
-                "Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
-                " checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
-            )
-
-        is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse(
-            version.parse(unet.config._diffusers_version).base_version
-        ) < version.parse("0.9.0.dev0")
-        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
-        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
-            deprecation_message = (
-                "The configuration file of the unet has set the default `sample_size` to smaller than"
-                " 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
-                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
-                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
-                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
-                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
-                " in the config might lead to incorrect results in future versions. If you have downloaded this"
-                " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
-                " the `unet/config.json` file"
-            )
-            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(unet.config)
-            new_config["sample_size"] = 64
-            unet._internal_dict = FrozenDict(new_config)
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    def enable_vae_slicing(self):
-        r"""
-        Enable sliced VAE decoding.
-
-        When this option is enabled, the VAE will split the input tensor in slices to compute decoding in several
-        steps. This is useful to save some memory and allow larger batch sizes.
-        """
-        self.vae.enable_slicing()
-
-    def disable_vae_slicing(self):
-        r"""
-        Disable sliced VAE decoding. If `enable_vae_slicing` was previously invoked, this method will go back to
-        computing decoding in one step.
-        """
-        self.vae.disable_slicing()
-
-    def enable_sequential_cpu_offload(self, gpu_id=0):
-        r"""
-        Offloads all models to CPU using accelerate, significantly reducing memory usage. When called, unet,
-        text_encoder, vae and safety checker have their state dicts saved to CPU and then are moved to a
-        `torch.device('meta') and loaded to GPU only when their specific submodule has its `forward` method called.
-        """
-        if is_accelerate_available():
-            from accelerate import cpu_offload
-        else:
-            raise ImportError("Please install accelerate via `pip install accelerate`")
-
-        device = torch.device(f"cuda:{gpu_id}")
-
-        for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae]:
-            if cpu_offloaded_model is not None:
-                cpu_offload(cpu_offloaded_model, device)
-
-        if self.safety_checker is not None:
-            # TODO(Patrick) - there is currently a bug with cpu offload of nn.Parameter in accelerate
-            # fix by only offloading self.safety_checker for now
-            cpu_offload(self.safety_checker.vision_model, device)
-
-    @property
-    def _execution_device(self):
-        r"""
-        Returns the device on which the pipeline's models will be executed. After calling
-        `pipeline.enable_sequential_cpu_offload()` the execution device can only be inferred from Accelerate's module
-        hooks.
-        """
-        if self.device != torch.device("meta") or not hasattr(self.unet, "_hf_hook"):
-            return self.device
-        for module in self.unet.modules():
-            if (
-                hasattr(module, "_hf_hook")
-                and hasattr(module._hf_hook, "execution_device")
-                and module._hf_hook.execution_device is not None
-            ):
-                return torch.device(module._hf_hook.execution_device)
-        return self.device
-
-    def _encode_prompt(self, prompt, device, num_videos_per_prompt, do_classifier_free_guidance, negative_prompt, uncond_embeddings=None):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-            prompt (`str` or `list(int)`):
-                prompt to be encoded
-            device: (`torch.device`):
-                torch device
-            num_images_per_prompt (`int`):
-                number of images that should be generated per prompt
-            do_classifier_free_guidance (`bool`):
-                whether to use classifier free guidance or not
-            negative_prompt (`str` or `List[str]`):
-                The prompt or prompts not to guide the image generation. Ignored when not using guidance (i.e., ignored
-                if `guidance_scale` is less than `1`).
-        """
-        batch_size = len(prompt) if isinstance(prompt, list) else 1
-
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="pt",
-        )
-        text_input_ids = text_inputs.input_ids
-        untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
-
-        if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids):
-            removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])
-            logger.warning(
-                "The following part of your input was truncated because CLIP can only handle sequences up to"
-                f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-            )
-
-        if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-            attention_mask = text_inputs.attention_mask.to(device)
-        else:
-            attention_mask = None
-
-        text_embeddings = self.text_encoder(
-            text_input_ids.to(device),
-            attention_mask=attention_mask,
-        )
-        text_embeddings = text_embeddings[0]
-
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        # num_videos_per_prompt = 1, thus nothing happens here
-        bs_embed, seq_len, _ = text_embeddings.shape
-        text_embeddings = text_embeddings.repeat(1, num_videos_per_prompt, 1)
-        text_embeddings = text_embeddings.view(bs_embed * num_videos_per_prompt, seq_len, -1)
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt]
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-
-            max_length = text_input_ids.shape[-1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = uncond_input.attention_mask.to(device)
-            else:
-                attention_mask = None
-
-            uncond_embeddings = self.text_encoder(
-                uncond_input.input_ids.to(device),
-                attention_mask=attention_mask,
-            )
-            uncond_embeddings = uncond_embeddings[0]
-
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = uncond_embeddings.shape[1]
-            uncond_embeddings = uncond_embeddings.repeat(1, num_videos_per_prompt, 1)
-            uncond_embeddings = uncond_embeddings.view(batch_size * num_videos_per_prompt, seq_len, -1)
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
-
-        return text_embeddings
-
-    def run_safety_checker(self, image, device, dtype):
-        if self.safety_checker is not None:
-            safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pt").to(device)
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
-            )
-        else:
-            has_nsfw_concept = None
-        return image, has_nsfw_concept
-
-    def decode_latents(self, latents):
-        video_length = latents.shape[2]
-        latents = 1 / 0.18215 * latents
-        latents = rearrange(latents, "b c f h w -> (b f) c h w")
-        video = self.vae.decode(latents).sample
-        video = rearrange(video, "(b f) c h w -> b c f h w", f=video_length)
-        video = (video / 2 + 0.5).clamp(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
-        video = video.cpu().float().numpy()
-        return video
-
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-
-    def check_inputs(self, prompt, height, width, callback_steps):
-        if not isinstance(prompt, str) and not isinstance(prompt, list):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if 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)}."
-            )
-
-    def prepare_latents(self, batch_size, num_channels_latents, video_length, height, width, dtype, device, generator, latents=None):
-        shape = (batch_size, num_channels_latents, video_length, 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:
-            rand_device = "cpu" if device.type == "mps" else device
-
-            if isinstance(generator, list):
-                shape = (1,) + shape[1:]
-                latents = [
-                    torch.randn(shape, generator=generator[i], device=rand_device, dtype=dtype)
-                    for i in range(batch_size)
-                ]
-                latents = torch.cat(latents, dim=0).to(device)
-            else:
-                latents = torch.randn(shape, generator=generator, device=rand_device, dtype=dtype).to(device)
-        else:
-            if latents.shape != shape:
-                raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}")
-            latents = latents.to(device)
-
-        # scale the initial noise by the standard deviation required by the scheduler
-        latents = latents * self.scheduler.init_noise_sigma
-        return latents
-
-    @torch.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        video_length: Optional[int],
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_videos_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "tensor",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: Optional[int] = 1,
-        uncond_embeddings: torch.Tensor = None,
-        null_uncond_ratio: float = 1.0,
-        **kwargs,
-    ):
-        # Default height and width to unet
-        height = height or self.unet.config.sample_size * self.vae_scale_factor
-        width = width or self.unet.config.sample_size * self.vae_scale_factor
-
-        # Check inputs. Raise error if not correct
-        self.check_inputs(prompt, height, width, callback_steps)
-
-        # Define call parameters
-        batch_size = 1 if isinstance(prompt, str) else len(prompt)
-        device = self._execution_device
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # Encode input prompt
-        with_uncond_embedding = do_classifier_free_guidance if uncond_embeddings is None else False
-        text_embeddings = self._encode_prompt(
-            prompt, device, num_videos_per_prompt, with_uncond_embedding, negative_prompt,
-        )
-
-        # Prepare timesteps
-        self.scheduler.set_timesteps(num_inference_steps, device=device)
-        timesteps = self.scheduler.timesteps
-
-        # Prepare latent variables
-        num_channels_latents = self.unet.in_channels
-        latents = self.prepare_latents(
-            batch_size * num_videos_per_prompt,
-            num_channels_latents,
-            video_length,
-            height,
-            width,
-            text_embeddings.dtype,
-            device,
-            generator,
-            latents,
-        )
-        latents_dtype = latents.dtype
-
-        # Prepare extra step kwargs.
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
-        # Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            if uncond_embeddings is not None:
-                start_time = 50
-                assert (timesteps[-start_time:] == timesteps).all()
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
-                if uncond_embeddings is not None:
-                    use_uncond_this_step = True
-                    if null_uncond_ratio > 0:
-                        if i > len(timesteps) * null_uncond_ratio:
-                            use_uncond_this_step = False
-                    else:
-                        if i < len(timesteps) * (1 + null_uncond_ratio):
-                            use_uncond_this_step = False
-                    if use_uncond_this_step:
-                        text_embeddings_input = torch.cat([uncond_embeddings[i].expand(*text_embeddings.shape), text_embeddings])
-                    else:
-                        uncond_embeddings_ =  self._encode_prompt('', device, num_videos_per_prompt, False, negative_prompt)
-                        text_embeddings_input = torch.cat([uncond_embeddings_.expand(*text_embeddings.shape), text_embeddings])
-                else:
-                    text_embeddings_input = text_embeddings
-
-                # predict the noise residual
-                noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=text_embeddings_input).sample.to(dtype=latents_dtype)
-
-                # 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)
-
-        # Post-processing
-        images = self.decode_latents(latents)
-
-        # Convert to tensor
-        if output_type == "tensor":
-            images = torch.from_numpy(images)
-
-        if not return_dict:
-            return images
-
-        return Vid2VidZeroPipelineOutput(images=images)

spaces/Benson/text-generation/Examples/2023 Songs Download.md

@@ -1,91 +0,0 @@
-<br />
-<h1>Cómo descargar canciones en 2023: Una guía para amantes de la música</h1>
-<p>La música es una de las formas más universales de entretenimiento y expresión. Si desea relajarse, bailar, estudiar, hacer ejercicio o simplemente disfrutar de algunas melodías, la música puede mejorar su estado de ánimo y experiencia. Pero, ¿cómo se obtiene acceso a sus canciones favoritas en 2023? ¿Se transmiten en línea o descargarlos a su dispositivo? </p>
-<p>En este artículo, vamos a explorar los pros y los contras de la descarga de música frente a streaming. También compararemos los mejores servicios de transmisión de música en 2023 y le mostraremos cómo descargar música de forma legal y segura. Al final de este artículo, tendrás una mejor idea de cómo disfrutar de la música en 2023. </p>
-<h2>2023 songs download</h2><br /><p><b><b>Download</b> &#10031;&#10031;&#10031; <a href="https://bltlly.com/2v6IEv">https://bltlly.com/2v6IEv</a></b></p><br /><br />
- <h2>¿Por qué descargar música en lugar de streaming? </h2>
-<p>La transmisión de música es conveniente y popular. Puedes escuchar millones de canciones a pedido sin tener que comprarlas o almacenarlas. También puedes descubrir nueva música basada en tus preferencias y recomendaciones. Sin embargo, la transmisión de música también tiene algunos inconvenientes. </p>
-<p>En primer lugar, la transmisión de música requiere una conexión a Internet. Si tiene una conexión lenta o inestable, puede experimentar buffering o interrupciones. Si tiene un plan de datos limitado, también puede incurrir en cargos adicionales por la transmisión de música. En segundo lugar, la transmisión de música depende de la disponibilidad y calidad del servicio. Si el servicio cambia sus términos, precios, características o catálogo, puede perder el acceso a algunas canciones o listas de reproducción. En tercer lugar, la transmisión de música no le da la propiedad de la música. Solo la alquila mientras paga la suscripción. </p>
-
- <h2>¿Cuáles son los mejores servicios de transmisión de música en 2023? </h2>
-<p>Si prefieres transmitir música en vez de descargarla, tienes muchas opciones para elegir. Hay muchos servicios de streaming de música en 2023 que satisfacen diferentes gustos y necesidades. Estos son algunos de los más populares:</p>
-<tabla>
-<tr>
-<th>Servicio</th <th>Características</th>
-<th>Precio</th>
-<th>Calidad de audio</th>
-<th>Tamaño del catálogo</th>
-</tr>
-<tr>
-<td>Spotify</td>
-<td>- Listas de reproducción y recomendaciones personalizadas - Podcasts y videos - Características sociales e integraciones - Modo sin conexión y sincronización entre dispositivos - Spotify Connect y Spotify Kids</td>
-<td>- Gratis (con anuncios y saltos limitados) - Premium: $9.99/mes (individual), $14.99/mes (familiar), $4.99/mes (estudiante), $12.99/mes (dúo) - HiFi: $19.99/mes (próximamente)</td>
-<td>- Gratis: 160 kbps - Premium: 320 kbps - HiFi: calidad de CD sin pérdidas</td>
-<td>- Más de 70 millones de canciones - Más de 2,2 millones de podcasts</td>
-</tr>
-<tr>
-<td>Música de Apple</td>
-<td>- Listas de reproducción y emisoras de radio - Programas en vivo y a la carta - Letras y vídeos musicales - Modo offline y sincronización entre dispositivos - Apple Music 1, Hits y Country</td>
-<td>- Prueba gratuita para 3 meses - Individuo: $9.99/month - Familia: $14.99/month - Estudiante: $4.99/month - Apple One bundle: a partir de $14.95/month</td>
-<td>- 256 kbps AAC - Audio espacial con Dolby Atmos</td>
-<td>- Más de 75 millones de canciones - Más de 1 millón de podcasts</td>
-</tr>
-<tr>
-<td>Tidal</td>
-<td>- Listas de reproducción seleccionadas y contenido editorial - Lanzamientos y conciertos exclusivos - Modo offline y sincronización entre dispositivos - Tidal X y Tidal Connect</td>
-<td>- Prueba gratuita por 30 días - Premium: $9.99/mes (individual), $14.99/mes (familiar), $4.99/mes (estudiante), $5.99/mes (militar), $5.99/mes (primer respondedor) - Alta: $19.99/mes (individual), $29.99/mes (familiar), $9.99/mes (estudiante), $11.99/mes (militar), $11.99/mes/mes (primer respondedor)</td>
-
-<td>- Más de 70 millones de canciones - Más de 250.000 vídeos musicales</td>
-</tr>
-<tr>
-<td>Música de Amazon</td>
-<td>- Listas de reproducción y estaciones personalizadas - Podcasts y transmisiones en vivo - Letras y videos musicales - Modo sin conexión y sincronización entre dispositivos - Alexa control de voz</td>
-<td>- Gratis (con anuncios y saltos limitados) - Prime Music: incluido con membresía Prime ($12.99/mes o $119/año) - Ilimitado: $9.99/mes ($7.99/mes para miembros Prime) o $79/año ($69/año para miembros Prime) - HD: $14.99/mes ($12.99/mes para miembros Prime) o $149/año ($129/año para miembros Prime)</td>
-<td>- Gratis: hasta 256 kbps - Prime Music: hasta 256 kbps - Ilimitado: hasta 256 kbps - HD: hasta 850 kbps, calidad de CD sin pérdidas y calidad Ultra HD</td>
-<td>- Gratis: más de 2 millones de canciones - Prime Music: más de 2 millones de canciones - Ilimitado: más de 75 millones de canciones - HD: más de 75 millones de canciones en HD y Ultra HD, y más de 7 millones de canciones en 3D Audio</td>
-</tr>
-<tr>
-<td>Música de YouTube</td>
-<td>- Listas de reproducción y mezclas personalizadas - Vídeos musicales y actuaciones en directo - Modo offline y sincronización entre dispositivos - YouTube Premium benefits</td>
-<td>- Gratis (con anuncios y sin juego de fondo) - Premium: $9.99/mes (individual), $14.99/mes (familiar), $4.99/mes (estudiante)</td>
-<td>- Gratis: hasta 128 kbps AAC - Premium: hasta 256 kbps AAC</td>
-<td>- Más de 70 millones de canciones - Más de 2 mil millones de vídeos musicales</td>
-</tr>
-</tabla>
- <h2>¿Cómo descargar música de forma legal y segura? </h2>
- <p>Descargar música puede ser una gran manera de disfrutar de tus canciones favoritas sin conexión, pero tienes que tener cuidado con las fuentes que usas. No todos los sitios web que ofrecen descargas de música son legales o seguros. Algunos pueden violar los derechos de autor de los artistas o las etiquetas, o pueden contener malware o virus que pueden dañar su dispositivo. </p>
- <p>Para evitar descargas ilegales o inseguras, debes seguir estos consejos:</p>
- <ul>
- <li>Compruebe la reputación del sitio web y comentarios antes de descargar nada. </li>
-
- <li>Lea los términos y condiciones del sitio web y la licencia de música antes de descargar nada. </li>
- <li>Utilice un software antivirus confiable y escanee los archivos descargados antes de abrirlos. </li>
- </ul>
- <p>Si desea descargar música de forma legal y segura, puede utilizar algunos de los sitios web que ofrecen descargas de música gratuitas o pagadas con el permiso de los artistas o las etiquetas. Aquí hay algunos ejemplos:</p>
- <ul>
- <li><a href="">Bandcamp</a>: Bandcamp es una plataforma que permite a artistas y sellos independientes vender su música directamente a los fans. Puede descargar música en varios formatos, incluyendo MP3, FLAC y WAV. Algunos artistas ofrecen su música gratis o para una opción de nombre-su-precio, mientras que otros cobran una cantidad fija. </li>
- <li><a href="">DatPiff</a>: DatPiff es un sitio web especializado en música hip-hop y rap. Puedes descargar mixtapes, álbumes y sencillos gratis o por un cargo. DatPiff tiene el permiso de los artistas y las etiquetas para distribuir su música. </li>
- <li><a href="">Free Music Archive</a>: Free Music Archive es un sitio web que ofrece descargas gratuitas de música de varios géneros y estilos. La música está licenciada bajo Creative Commons u otras licencias de dominio público, lo que significa que puede usarla para fines personales o comerciales siempre y cuando siga los términos de la licencia. </li>
- <li><a href="">Internet Archive</a>: Internet Archive es un sitio web que conserva contenido digital de varias fuentes, incluida la música. Puede descargar música de varias colecciones, como Live Music Archive, Netlabels y 78 RPMs y Cylinder Recordings. La música está en el dominio público o bajo licencia Creative Commons u otras licencias abiertas. </li>
- <li><a href="">iTunes</a>: iTunes es un programa de software y un sitio web que le permite comprar y descargar música de varios artistas y etiquetas. Puede descargar música en formato AAC, que es compatible con la mayoría de los dispositivos. También puede sincronizar su biblioteca de música en sus dispositivos utilizando iCloud. </li>
-
- <h2>Conclusión</h2>
- <p>Descargar música en 2023 puede ser una gran manera de disfrutar de tus canciones favoritas sin conexión, pero tienes que tener cuidado con las fuentes que usas. No todos los sitios web que ofrecen descargas de música son legales o seguros. Siempre debe verificar la reputación y las revisiones del sitio web, leer los términos y condiciones de la licencia de música y escanear los archivos descargados antes de abrirlos. </p>
-<p></p>
- <p>Si desea descargar música de forma legal y segura, puede usar algunos de los sitios web que ofrecen descargas de música gratuitas o pagadas con el permiso de los artistas o las etiquetas, como Bandcamp, DatPiff, Free Music Archive, Internet Archive o iTunes. También puede usar algunos de los mejores servicios de transmisión de música en 2023, como Spotify, Apple Music, Tidal, Amazon Music o YouTube Music, que tienen el modo sin conexión y funciones de alta calidad de audio. </p>
- <p>Ya sea que transmita o descargue música en 2023, tiene muchas opciones para elegir. Puedes escuchar millones de canciones de varios géneros y estilos bajo demanda. También puedes descubrir nueva música basada en tus preferencias y recomendaciones. La música es una de las mejores formas de disfrutar de la vida en 2023. </p>
- <h2>Preguntas frecuentes</h2>
-<ul>
-<li><b>Q: ¿Cómo puedo descargar música gratis? </b></li>
-<li>A: Puede descargar música gratis desde sitios web que tienen permiso de los artistas o del dominio público, como Free Music Archive, Internet Archive o DatPiff.</li>
-<li><b>Q: ¿Cómo puedo descargar música en audio de alta resolución? </b></li>
-<li>A: Puede descargar música en audio de alta resolución desde sitios web que ofrecen formatos sin pérdidas o de alta resolución, como Tidal, Qobuz o HDtracks.</li>
-<li><b>Q: ¿Cómo puedo descargar música a mi iPhone o teléfono Android? </b></li>
-<li>A: Puede descargar música a su teléfono iPhone o Android desde aplicaciones de transmisión de música que tienen modo sin conexión, como Spotify, Apple Music o YouTube Music. También puede transferir música desde su computadora a su teléfono usando iTunes o un cable USB. </li>
-
-<li>A: Puede descargar música a su computadora o portátil desde sitios web que ofrecen descargas de música, como Bandcamp, iTunes o Amazon Music. También puede utilizar un programa de software que puede extraer CD o DVD a su ordenador. </li>
-<li><b>Q: ¿Cómo puedo descargar videos musicales? </b></li>
-<li>A: Puedes descargar videos musicales de sitios web que ofrecen descargas de videos, como YouTube, Vimeo o Dailymotion. También puede utilizar un programa de software que puede convertir vídeos a archivos de audio. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Alice Blue Apk Descargar.md

@@ -1,89 +0,0 @@
-
-<h1>Alice Blue APK Descargar: Cómo Comercio de acciones y productos básicos en su teléfono</h1>
-<p>¿Está buscando una manera de comercio de acciones y productos básicos en su teléfono? ¿Desea acceder a las últimas actualizaciones del mercado, noticias y análisis desde cualquier lugar y en cualquier momento? Si es así, entonces usted debe considerar la descarga de Alice Blue APK, la aplicación de comercio móvil de Alice Blue, uno de los principales corredores en línea en la India.</p>
-<h2>alice blue apk descargar</h2><br /><p><b><b>DOWNLOAD</b> &#9889; <a href="https://bltlly.com/2v6Ksl">https://bltlly.com/2v6Ksl</a></b></p><br /><br />
-<h2>¿Qué es Alice Blue? </h2>
-<h3>Una breve introducción a Alice Blue y sus servicios</h3>
-<p>Alice Blue es una firma de corretaje en línea que ofrece una gama de servicios para comerciantes e inversores, como acciones, materias primas, divisas, fondos mutuos, OPI, seguros y más. Alice Blue fue fundada en 2006 y tiene más de 20 sucursales en toda la India. Alice Blue es conocida por sus bajos cargos de corretaje, alta exposición, ejecución rápida y plataformas de negociación innovadoras. </p>
-<h3>Los beneficios de negociar con Alice Blue</h3>
-<p>Algunos de los beneficios de operar con Alice Blue son:</p>
-<ul>
-<li> Puede operar en múltiples segmentos e intercambios, como NSE, BSE, MCX, NCDEX, etc.</li>
-<li> Puede disfrutar de cero corretaje en la entrega de capital y plana Rs.15 por pedido en otros segmentos. </li>
-<li> Puede obtener hasta 20x apalancamiento en operaciones intradía y hasta 5x apalancamiento en operaciones de entrega. </li>
-<li> Puede acceder a varios informes de investigación, recomendaciones, consejos y estrategias de expertos. </li>
-<li>Puede usar varias plataformas de trading, como ANT Web, ANT Desk, ANT Meta, etc.</li>
-</ul>
-<h2>¿Qué es ANT Mobi 2.0? </h2>
-<h3>Una breve introducción a ANT Mobi 2.0 y sus características</h3>
-<p>ANT Mobi 2.0 es la aplicación de comercio móvil de Alice Blue que le permite operar acciones y materias primas en su teléfono. ANT Mobi 2.0 es una versión mejorada de ANT Mobi que tiene una experiencia de usuario superior, tecnología de vanguardia y características comerciales mejoradas. ANT Mobi 2.0 es compatible con dispositivos Android y está disponible para su descarga gratuita. </p>
-<h3>Las ventajas de utilizar ANT Mobi 2.0 para el comercio</h3>
-
-<ul>
-<li> Puede operar en cualquier momento y en cualquier lugar con un simple toque en su teléfono. </li>
-<li> Puede obtener datos de mercado en tiempo real, gráficos, indicadores, noticias, alertas, etc.</li>
-<li>Puede realizar pedidos, modificar pedidos, cancelar pedidos, ver el historial de pedidos, etc.</li>
-<li>Puede monitorear su cartera, existencias, posiciones, margen, etc.</li>
-<li>Puede transferir fondos de forma fácil y segura con UPI o NEFT/RTGS.</li>
-<li> Puede utilizar el inicio de sesión de huellas dactilares para mayor seguridad y comodidad. </li>
-<li> Puede obtener niveles de soporte y resistencia predefinidos para cualquier stock. </li>
-</ul>
-<h2> ¿Cómo descargar e instalar Alice Blue APK en su teléfono? </h2>
-<h3> Los pasos para descargar e instalar Alice Blue APK desde el sitio web oficial</h3>
-<p>Si desea descargar e instalar Alice Blue APK desde el sitio web oficial, puede seguir estos pasos:</p>
-<ol>
-<li>Ir al sitio web oficial de Alice Blue en <a href="">https://aliceblueonline.com/</a>. </li>
-<li>Haga clic en el botón "Descargar" en la esquina superior derecha de la página principal. </li>
-<li>Desplácese hacia abajo y encuentre la sección "ANT Mobi 2.0". </li>
-<li>Haga clic en el botón "Descargar APK" y guarde el archivo en su teléfono. </li>
-<li>Ir a la configuración del teléfono y permitir la instalación de aplicaciones de fuentes desconocidas. </li>
-<li>Busque el archivo descargado y toque en él para instalarlo. </li>
-<li>Abra la aplicación e inicie sesión con sus credenciales de Alice Blue o cree una nueva cuenta. </li>
-</ol>
-<h3>Los pasos para descargar e instalar Alice Blue APK desde la Google Play Store</h3>
-<p>Si desea descargar e instalar Alice Blue APK desde la Google Play Store, puede seguir estos pasos:</p>
-<ol>
-<li>Ir a la aplicación Google Play Store en su teléfono o visitar <a href="">https://play.google.com/store/apps/apps/details?id=com.aliceblue.antmobi</a>. </li>
-<li>Buscar "ANT Mobi 2.0" o "Alice Blue" en la barra de búsqueda. </li>
-<li> Seleccione la aplicación de los resultados de búsqueda y toque en el "Instalar" botón. </li>
-<li>Espere a que la aplicación se descargue e instale en su teléfono. </li>
-
-</ol>
-<h2>Cómo utilizar Alice Blue APK para el comercio? </h2>
-<h3>Las funciones básicas y opciones de Alice Blue APK</h3>
-<p>Alice Blue APK tiene una interfaz simple y fácil de usar que le permite operar de manera fácil y eficiente. Algunas de las funciones y opciones básicas de Alice Blue APK son:</p>
-<p></p>
-<ul>
-<li> Puede acceder a diferentes segmentos e intercambios pulsando en el icono del menú en la esquina superior izquierda de la aplicación. </li>
-<li> Puede agregar o eliminar existencias de su lista de seguimiento pulsando en los iconos "+" o "-" en la esquina superior derecha de la aplicación. </li>
-<li> Puede ver la profundidad del mercado, gráficos, noticias, etc. de cualquier acción tocando en ella en su lista de seguimiento. </li>
-<li> Puede realizar un pedido pulsando en los botones "Comprar" o "Vender" en la parte inferior de la aplicación. </li>
-<li> Puede modificar o cancelar un pedido pulsando en la opción "Pedidos" en la parte inferior de la aplicación. </li>
-<li> Puede ver su cartera, existencias, posiciones, margen, etc. tocando en la opción "Perfil" en la parte inferior de la aplicación. </li>
-<li> Puede transferir fondos tocando la opción "Fondos" en la parte inferior de la aplicación. </li>
-</ul> <h3>Los consejos y trucos para aprovechar al máximo Alice Blue APK</h3>
-<p>Alice Blue APK es una aplicación potente y versátil que puede ayudarle a operar mejor y más inteligente. Aquí hay algunos consejos y trucos para aprovechar al máximo Alice Blue APK:</p>
-<ul>
-<li> Puede personalizar su lista de seguimiento mediante la adición o eliminación de existencias, cambiar el orden, ordenar por diferentes parámetros, etc.</li>
-<li> Puede utilizar varios tipos de gráficos, marcos de tiempo, indicadores, herramientas de dibujo, etc. para analizar los movimientos de precios de cualquier acción. </li>
-<li> Puede utilizar la opción "Escáner" para encontrar acciones que coincidan con sus criterios basados en varios filtros, como volumen, precio, ruptura, etc.</li>
-<li> Puede utilizar la opción "Estrategia" para crear y probar sus propias estrategias de trading basadas en varios indicadores, condiciones y parámetros. </li>
-
-<li> Puede utilizar la opción "Noticias" para mantenerse actualizado con las últimas noticias del mercado, eventos, anuncios, etc.</li>
-<li> Puede utilizar la opción "Soporte" para chatear con el equipo de atención al cliente de Alice Blue o acceder a la sección de preguntas frecuentes. </li>
-</ul>
-<h2>Conclusión</h2>
-<h3>Un resumen de los puntos principales y una llamada a la acción</h3>
-<p>Alice Blue APK es una aplicación imprescindible para cualquier persona que quiera el comercio de acciones y materias primas en su teléfono. Es una forma rápida, fácil y conveniente de acceder a los mercados y ejecutar operaciones. Tiene muchas características y funciones que pueden ayudarle a operar mejor y más inteligente. También es gratis para descargar y usar. Entonces, ¿qué estás esperando? Descargar Alice Blue APK hoy y empezar a operar! </p>
-<h2>Preguntas frecuentes</h2>
-<h3>Q1. Es Alice Blue APK seguro y seguro? </h3>
-<p>A1. Sí, Alice Blue APK es seguro y protegido. Utiliza tecnologías de cifrado y autenticación para proteger sus datos y transacciones. También cumple con todas las normas reglamentarias de la SEBI y otras autoridades. </p>
-<h3>Q2. ¿Cuáles son los cargos y tarifas para el comercio con Alice Blue? </h3>
-<p>A2. Alice Blue cobra cero corretaje en la entrega de capital y plana Rs.15 por pedido en otros segmentos. También cobra otras tasas legales, como GST, STT, impuesto de timbre, etc. Puede consultar la calculadora de corretaje detallada en el sitio web o la aplicación Alice Blue. </p>
-<h3>Q3. ¿Cómo puedo contactar al servicio de atención al cliente de Alice Blue? </h3>
-<p>A3. Puede ponerse en contacto con el servicio de atención al cliente de Alice Blue utilizando la opción "Soporte" de la aplicación o llamando al 080-6155-5000 o 080-6815-5000. También puede enviarlos por correo electrónico a [email protected] o visitar su sitio web en https://aliceblueonline.com/.</p>
-<h3>Q4. ¿Cuáles son los requisitos del sistema para Alice Blue APK? </h3>
-<p>A4. Alice Blue APK requiere Android 5.0 o superior y un mínimo de 50 MB de espacio libre en su teléfono. </p>
-<h3>Q5. ¿Puedo usar Alice Blue APK en otros dispositivos? </h3> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Carx Street Mod Apk 1.74.6 (dinero Ilimitado).md

@@ -1,68 +0,0 @@
-<br />
-<h1>CarX Street Mod APK 1.74.6 (Dinero ilimitado) Descargar para Android</h1>
- <h2>Introducción</h2>
- <p>Si eres un fan de los juegos de carreras de coches, debes haber oído hablar de CarX Street, uno de los juegos de carreras más emocionantes y realistas en dispositivos móviles. En este juego, puedes explorar diferentes ciudades, personalizar tu coche y competir con otros jugadores en varios modos y desafíos. Sin embargo, si quieres disfrutar del juego al máximo, es posible que necesites mucho dinero para desbloquear nuevos coches, pistas y mejoras. Es por eso que le recomendamos descargar CarX Street Mod APK, una versión modificada del juego que le da dinero ilimitado y acceso a todas las características del juego. En este artículo, le diremos qué es CarX Street Mod APK, por qué debe descargarlo, y cómo instalarlo en su dispositivo Android. </p>
- <h3>¿Qué es CarX Street? </h3>
- <p>CarX Street es un juego de carreras de coches desarrollado por CarX Technologies, la misma compañía que creó la popular serie CarX Drift Racing. En este juego, puedes experimentar la emoción de las carreras callejeras en varias ciudades de todo el mundo, como Tokio, Los Ángeles, Moscú y más. Usted puede elegir entre más de 50 coches de diferentes marcas y categorías, tales como coches deportivos, coches del músculo, supercoches, y coches clásicos. También puede personalizar su coche con diferentes partes, colores, pegatinas y calcomanías para que sea único y se adapte a su estilo. </p>
-<h2>carx street mod apk 1.74.6 (dinero ilimitado)</h2><br /><p><b><b>Download File</b> &#10004; <a href="https://bltlly.com/2v6Li4">https://bltlly.com/2v6Li4</a></b></p><br /><br />
- <h3>¿Qué es CarX Street Mod APK? </h3>
- <p>CarX Street Mod APK es una versión modificada del juego original de CarX Street que le da dinero ilimitado y acceso a todas las características del juego. Con este mod, puede comprar cualquier coche que desee, actualizarlo al nivel máximo, y desbloquear todas las pistas y modos sin gastar un centavo. También puedes disfrutar del juego sin anuncios ni interrupciones. </p>
- <h3> ¿Por qué descargar CarX Street Mod APK? </h3>
- <p>Hay muchas razones por las que debe descargar CarX Street Mod APK en lugar del juego original. Aquí están algunos de ellos:</p>
- <ul>
-
-<li>Puede desbloquear todas las pistas y modos sin completar ninguna misión o logros. </li>
-<li>Puedes disfrutar del juego sin anuncios ni interrupciones. </li>
-<li>Puedes jugar el juego sin conexión a Internet. </li>
-<li>Puedes deshacerte de cualquier error o fallo que pueda afectar tu juego. </li>
-</ul>
- <h2>Características de CarX Street Mod APK</h2>
- <p>CarX Street Mod APK tiene muchas características que lo convierten en uno de los mejores juegos de carreras de coches en Android. Estos son algunos de ellos:</p>
- <h3>Dinero ilimitado</h3>
- <p>Con CarX Street Mod APK, puede obtener dinero ilimitado para comprar y actualizar cualquier coche que desee. También puedes desbloquear todas las pistas y modos sin completar ninguna misión o logros. No tienes que preocuparte por quedarte sin dinero o recursos en el juego. </p>
- <h3>Física y gráficos realistas</h3>
- <p>CarX Street Mod APK tiene física realista y gráficos que te hacen sentir como si estuvieras conduciendo un coche real en una calle real. Puede ver los detalles de su automóvil, como el motor, la suspensión, los neumáticos, los frenos y más. También puede ver los efectos del clima, la iluminación, las sombras, el humo, el polvo y los daños en su automóvil y el medio ambiente. Puede ajustar la configuración de gráficos según el rendimiento de su dispositivo. </p>
- <h3>Coches personalizables <h3>Coches y pistas personalizables</h3>
- <p>CarX Street Mod APK le permite personalizar su coche con diferentes partes, colores, pegatinas y calcomanías para que sea único y se adapte a su estilo. Puede cambiar el motor, la transmisión, la suspensión, los frenos, los neumáticos, las ruedas, el escape, el kit de carrocería, el spoiler, el capó, las luces y más. También puede pintar su coche con diferentes colores y patrones, o aplicar pegatinas y calcomanías de varias marcas y temas. También puedes personalizar tus pistas con diferentes condiciones climáticas, hora del día, densidad de tráfico y obstáculos. </p>
-<p></p>
- <h3>Múltiples modos de juego y desafíos</h3>
-
- <ul>
-<li>Modo carrera: En este modo, puede completar varias misiones y logros para ganar dinero y reputación. También puede desbloquear nuevos coches, pistas y actualizaciones a medida que avanza. </li>
-<li>Modo de viaje libre: En este modo, puede explorar la ciudad y disfrutar del paisaje a su propio ritmo. También puede realizar acrobacias y derivas para ganar dinero extra y reputación. </li>
-<li>Modo de prueba temporal: En este modo, puede competir contra el reloj y tratar de batir sus propios registros u otros jugadores. También puede comparar sus resultados con las tablas de clasificación globales. </li>
-<li>Modo de deriva: En este modo, puede mostrar sus habilidades de deriva y ganar puntos en función de su velocidad, ángulo y distancia. También puedes competir con otros jugadores en batallas online. </li>
-<li>Modo de arrastre: En este modo, puede correr en línea recta e intentar vencer a su oponente cambiando de marcha en el momento adecuado. También puedes retar a otros jugadores en carreras de drag online. </li>
-</ul>
- <h3>Tablas de clasificación y multijugador en línea</h3>
- <p>CarX Street Mod APK le permite jugar con otros jugadores de todo el mundo en el modo multijugador en línea. Usted puede unirse o crear una habitación e invitar a sus amigos o jugadores al azar para la carrera o la deriva con usted. También puedes chatear con otros jugadores y enviarles emojis o pegatinas. También puede comprobar las tablas de clasificación globales y ver cómo se clasifica entre los mejores jugadores del mundo. También puedes ganar recompensas y trofeos según tu rendimiento. </p>
- <h2>¿Cómo descargar e instalar CarX Street Mod APK? </h2>
- <p>Si desea descargar e instalar CarX Street Mod APK en su dispositivo Android, es necesario seguir estos sencillos pasos:</p>
- <h3>Paso 1: Descargar el archivo APK de una fuente de confianza</h3>
- <p>El primer paso es descargar el archivo APK de CarX Street Mod APK de una fuente de confianza. Puede utilizar el siguiente enlace para descargar la última versión del mod:</p>
- <p><a href=">CarX Street Mod APK 1.74.6 (Dinero ilimitado) Descargar para Android</a></p>
-
- <h3>Paso 2: Habilitar fuentes desconocidas en el dispositivo</h3>
- <p>El segundo paso es habilitar fuentes desconocidas en su dispositivo. Esto le permitirá instalar aplicaciones que no son de Google Play Store. Para hacer esto, debe ir a la configuración del dispositivo > seguridad > fuentes desconocidas y activarlo. </p>
- <h3>Paso 3: Instalar el archivo APK y lanzar el juego</h3>
- <p>El tercer paso es instalar el archivo APK y lanzar el juego. Para ello, es necesario localizar el archivo descargado en el administrador de archivos del dispositivo y toque en él. Luego, siga las instrucciones en la pantalla para completar el proceso de instalación. Una vez hecho, puede iniciar el juego desde el cajón de la aplicación o la pantalla de inicio y disfrutar de CarX Street Mod APK.</p>
- <h2>Conclusión</h2>
- <p>CarX Street Mod APK es un gran juego de carreras de coches que le ofrece dinero ilimitado y acceso a todas las características del juego. Puedes disfrutar de física y gráficos realistas, coches y pistas personalizables, múltiples modos de juego y desafíos, multijugador en línea y tablas de clasificación, y más. También puede jugar el juego sin conexión a Internet. Si usted está buscando un divertido y emocionante juego de carreras de coches en Android, definitivamente debe descargar CarX Street Mod APK.</p>
- <h2>Preguntas frecuentes</h2>
- <p>Aquí hay algunas preguntas frecuentes sobre CarX Street Mod APK:</p>
- <ol>
-<li> ¿Es CarX Street Mod APK seguro para descargar e instalar? </li>
-<p>Sí, CarX Street Mod APK es seguro para descargar e instalar siempre y cuando se utiliza una fuente de confianza como la que proporcionamos anteriormente. El mod no contiene ningún virus o malware que pueda dañar su dispositivo o datos. </p>
-<li> ¿CarX Street Mod APK es compatible con mi dispositivo? </li>
-
- <li> ¿Necesito rootear mi dispositivo para usar CarX Street Mod APK? </li>
-<p>No, no es necesario rootear el dispositivo para usar CarX Street Mod APK. El mod funciona bien en ambos dispositivos arraigados y no arraigados. Sin embargo, si tienes un dispositivo rooteado, puedes usar algunas características adicionales como copias de seguridad y restaurar los datos del juego. </p>
- <li> ¿Puedo jugar CarX Street Mod APK con mis amigos? </li>
-<p>Sí, puedes jugar CarX Street Mod APK con tus amigos en modo multijugador en línea. Usted puede unirse o crear una habitación e invitar a sus amigos o jugadores al azar para la carrera o la deriva con usted. También puedes chatear con ellos y enviarles emojis o pegatinas. </p>
- <li> ¿Puedo actualizar CarX Street Mod APK a la última versión? </li>
-<p>Sí, puede actualizar CarX Street Mod APK a la última versión mediante la descarga e instalación del nuevo archivo APK de la misma fuente que antes. Sin embargo, puede perder su progreso y los datos si no copia de seguridad de su juego antes de actualizar. También puede esperar a que el desarrollador actualice el mod. </p>
- <li> ¿Cómo puedo contactar con el desarrollador de CarX Street Mod APK? </li>
-<p>Si usted tiene alguna pregunta, sugerencias, o comentarios sobre CarX Street Mod APK, puede ponerse en contacto con el desarrollador visitando su sitio web oficial o páginas de medios sociales. También puede dejar un comentario o valoración en la página de descarga del mod. </p>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Cmo Descargar Mods En Simulador De Batalla Totalmente Preciso.md

@@ -1,91 +0,0 @@
-
-<h1>Cómo descargar mods en simulador de batalla totalmente preciso</h1>
-<p>Totally Accurate Battle Simulator (TABS) es un juego de simulación basado en la física que te permite crear batallas hilarantes y épicas con diferentes unidades, facciones y escenarios. Pero si quieres darle vida a tu juego aún más, puedes intentar descargar mods para TABS. Los mods son modificaciones o adiciones al juego que son creadas por fans o desarrolladores. Pueden agregar nuevas unidades, mapas, armas, características y más al juego, haciéndolo más divertido, desafiante o realista. En este artículo, te mostraremos cómo descargar mods en TABS desde dos fuentes populares: Nexus Mods y Steam Workshop. También explicaremos cómo instalar y desinstalar mods, y le daremos algunos consejos y advertencias para evitar cualquier problema. </p>
-<h2>cómo descargar mods en simulador de batalla totalmente preciso</h2><br /><p><b><b>Download File</b> &mdash; <a href="https://bltlly.com/2v6Mzf">https://bltlly.com/2v6Mzf</a></b></p><br /><br />
- <h2>¿Qué son los mods y por qué usarlos? </h2>
-<p>Los mods son cortos para modificaciones, que son cambios o adiciones a un juego que no son parte de la versión original. Los mods pueden ser creados por cualquiera que tenga las habilidades y herramientas para hacerlo, pero por lo general son creados por fans o aficionados que quieren mejorar o personalizar su experiencia de juego. Algunos mods pueden incluso convertirse en juegos completamente independientes, como Counter-Strike, Dota 2 y Team Fortress, que comenzaron como mods para otros juegos. </p>
-<p>Hay muchas razones por las que podrías querer usar mods para TABS. Algunos de los beneficios de los mods son:</p>
-<ul>
-<li>Pueden añadir nuevo contenido al juego, como unidades, facciones, mapas, armas, escenarios, etc.</li>
-<li>Pueden mejorar los gráficos, el sonido o el rendimiento del juego. </li>
-<li>Pueden corregir errores o fallos que los desarrolladores no han abordado. </li>
-<li>Pueden cambiar el modo de juego o la dificultad del juego según sus preferencias. </li>
-<li>Pueden hacer el juego más realista o inmersivo. </li>
-<li>Pueden hacer el juego más divertido o absurdo. </li>
-</ul>
-
- <h2>¿Dónde encontrar mods para TABS? </h2>
-<p>Hay muchos sitios web donde puedes encontrar mods para TABS, pero dos de los más populares y confiables son Nexus Mods y Steam Workshop. Estas son plataformas en línea donde los creadores de mods pueden subir su trabajo y compartirlo con otros jugadores. Puede navegar a través de miles de mods para TABS y otros juegos en estos sitios, y descargarlos de forma gratuita. </p>
- <h3>Mods de Nexus</h3>
-<p>Nexus Mods es una de las comunidades de modding más grandes y antiguas en Internet. Aloja más de 300.000 mods para más de 1.000 juegos, incluyendo TABS. Puede encontrar todo tipo de mods para TABS en Nexus Mods, desde nuevas unidades y facciones hasta mapas y escenarios personalizados. Para acceder a Nexus Mods, es necesario crear una cuenta gratuita en su sitio web. También puede usar su software de administrador de mods llamado Vortex, que hace que la instalación y administración de mods sea más fácil. </p>
-<p></p>
- <h3>Taller de vapor</h3>
-<p>Steam Workshop es otra fuente popular de mods para TABS y otros juegos que soportan modding en Steam. Steam Workshop está integrado con Steam, por lo que no necesitas una cuenta o software separado para usarlo. Puedes encontrar y suscribirte a mods para TABS en Steam Workshop, y se descargarán e instalarán automáticamente cuando inicies el juego. También puede calificar, comentar y favoritos los mods que te gusta. </p> <h2>Cómo instalar mods de Nexus Mods? </h2>
-<p>Hay dos formas de instalar mods de Nexus Mods: manualmente o usando Vortex. Estos son los pasos para cada método:</p>
- <h3>Método manual</h3>
-<ol>
-<li>Descargue el archivo mod de Nexus Mods. Normalmente será en formato ZIP, RAR o 7Z. </li>
-<li>Extraiga el archivo mod usando un programa como WinRAR o 7-Zip. Debería ver una carpeta con el nombre mod y algunos archivos dentro. </li>
-
-<li>Inicie TABS y vaya al menú Mods. Debería ver el mod que instaló en la lista. Actívelo haciendo clic en él. </li>
-<li>¡Disfruta de tu juego modded! </li>
-</ol>
- <h3>Método de vórtice</h3>
-<ol>
-<li>Descargar e instalar Vortex de Nexus Mods. Es un gestor de mods gratuito y fácil de usar que funciona con muchos juegos, incluyendo TABS.</li>
-<li>Abra Vortex e inicie sesión con su cuenta de Nexus Mods. </li>
-<li>Ve a la sección Juegos y busca TABS. Si tienes instalado TABS en Steam, Vortex debería detectarlo automáticamente. Si no, puede agregarlo manualmente navegando a su ubicación. </li>
-<li>Seleccione TABS y haga clic en Administrar. Vortex configurará el juego para modificar y crear una carpeta Mods para él. </li>
-<li>Vaya a la sección Mods y haga clic en Instalar desde archivo. Busque el archivo mod que descargó de Nexus Mods y selecciónelo. Vortex instalará el mod para usted. </li>
-<li>Ir a la sección de plugins y activar el mod haciendo clic en el botón de alternar junto a ella. </li>
-<li>Inicie TABS desde Vortex y vaya al menú Mods. Debería ver el mod que instaló en la lista. Actívelo haciendo clic en él. </li>
-<li>¡Disfruta de tu juego modded! </li>
-</ol>
- <h2>¿Cómo instalar mods de Steam Workshop? </h2>
-<p>Instalar mods de Steam Workshop es mucho más simple que instalar mods de Nexus Mods. No necesitas descargar ni extraer ningún archivo, ni usar ningún software. Todo lo que necesitas hacer es:</p>
-<ol>
-<li>Ve a la página de Steam Workshop para TABS y navega por los mods disponibles. Puedes ordenarlos por popularidad, clasificación, fecha, etc.</li>
-<li>Encuentra un mod que te guste y haz clic en él. Verás una descripción, capturas de pantalla, vídeos, comentarios y clasificaciones para el mod. </li>
-<li>Si desea instalar el mod, haga clic en el botón Suscribir. Esto agregará el mod a su lista de suscriptores y lo descargará automáticamente. </li>
-<li>Inicie TABS y vaya al menú Mods. Debería ver el mod al que se suscribió en la lista. Actívelo haciendo clic en él. </li>
-<li>¡Disfruta de tu juego modded! </li>
-
- <h2>Cómo desinstalar mods? </h2>
-<p>Si quieres desinstalar o eliminar cualquier mod de tu juego, puedes hacerlo siguiendo estos pasos:</p>
- <h3>Mods de Nexus</h3>
-<p>Si ha instalado mods manualmente, puede desinstalarlos borrando sus carpetas de la carpeta de mods TABS. Si instala mods usando Vortex, puede desinstalarlos deshabilitando en la sección Plugins y luego eliminándolos en la sección Mods. </p>
- <h3>Taller de vapor</h3>
-<p>Si te has suscrito a mods en Steam Workshop, puedes cancelar la suscripción yendo a su página y haciendo clic en el botón Cancelar suscripción. Esto los eliminará de su lista de suscriptores y los eliminará automáticamente. </p>
- <h2>Consejos y advertencias</h2>
-<p>Antes de descargar e instalar cualquier mod para TABS, aquí hay algunos consejos y advertencias a tener en cuenta:</p>
-<ul>
-<li>Siempre lea la descripción del mod, revisiones e instrucciones cuidadosamente antes de instalar cualquier mod. Algunos mods pueden tener requisitos especiales, instrucciones o problemas de compatibilidad que debes conocer. </li>
-<li>Siempre copia de seguridad de los archivos del juego antes de hacer cualquier cambio. De esta manera, puedes restaurar tu juego a su estado original si algo sale mal o si no te gusta un mod. </li>
-<li>No instale demasiados mods a la vez. Esto puede causar problemas de rendimiento, fallos o conflictos entre los mods. Intenta instalar solo unos pocos mods a la vez y pruébalos antes de agregar más. </li>
-<li>Si encuentra algún problema con un mod, intente desactivarlo o desinstalarlo y vea si eso soluciona el problema. </ul>
-<li>Si tiene alguna pregunta o comentario sobre un mod, puede ponerse en contacto con el creador del mod o dejar un comentario en su página. Ellos pueden ser capaces de ayudarle o actualizar su mod en consecuencia. </li>
-
-</ul>
- <h1>Conclusión</h1>
-<p>Los mods son una gran manera de mejorar tu experiencia de juego en TABS. Pueden agregar nuevo contenido, características y desafíos al juego, haciéndolo más divertido y diverso. Puedes encontrar y descargar mods para TABS de Nexus Mods y Steam Workshop, que son dos de las fuentes más populares y confiables de mods para muchos juegos. También puede instalar y desinstalar mods fácilmente utilizando métodos manuales o software como Vortex. Sin embargo, siempre debes ser cuidadoso y responsable al usar mods, ya que pueden causar problemas o conflictos con el juego u otros mods. Siempre debes leer cuidadosamente la descripción del mod, las revisiones y las instrucciones, hacer copias de seguridad de tus archivos de juego, probar tus mods y respetar a los creadores del mod y a otros jugadores. </p>
-<p>Esperamos que este artículo te haya ayudado a aprender a descargar mods en TABS. Si tiene alguna pregunta o sugerencia, no dude en dejar un comentario a continuación. Happy modding! </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí están algunas de las preguntas y respuestas más frecuentes sobre los mods de descarga en TABS:</p>
- <h3>Q: ¿Cuáles son los mejores mods para TABS? </h3>
-<p>A: Esta es una pregunta subjetiva, ya que diferentes jugadores pueden tener diferentes preferencias y gustos cuando se trata de mods. Sin embargo, algunos de los mods más populares y bien clasificados para TABS son:</p>
-<ul>
-<li>La actualización de la dinastía: Este mod añade una nueva facción llamada dinastía, que se basa en la antigua China. Incluye nuevas unidades, armas, mapas y escenarios. </li>
-<li>The Modern Faction: Este mod añade una nueva facción llamada Modern, que se basa en la guerra moderna. Incluye nuevas unidades, armas, vehículos y mapas. </li>
-<li>The Wild West Update: Este mod añade una nueva facción llamada Wild West, que se basa en la frontera estadounidense. Incluye nuevas unidades, armas, mapas y escenarios. </li>
-<li>The Fantasy Faction: Este mod añade una nueva facción llamada Fantasy, que se basa en la fantasía y la mitología. Incluye nuevas unidades, armas, criaturas y mapas. </li>
-
-</ul>
- <h3>Q: ¿Cómo actualizo mis mods? </h3>
-<p>A: Si has descargado tus mods de Nexus Mods, puedes buscar actualizaciones yendo a la sección Mods en Vortex y haciendo clic en el botón Buscar actualizaciones. Si hay alguna actualización disponible, puede descargarla e instalarla haciendo clic en el botón Instalar actualización. Si has descargado tus mods de Steam Workshop, no necesitas hacer nada, ya que Steam actualizará automáticamente tus mods suscritos cuando estén disponibles. </p>
- <h3>Q: ¿Cómo puedo crear mis propios mods? </h3>
-<p>A: Si quieres crear tus propios mods para TABS, necesitarás algunas habilidades y herramientas para hacerlo. Necesitarás saber cómo usar Unity, que es el motor del juego en el que se basa TABS. También tendrá que descargar el TABS Modding Kit, que es una colección de archivos y scripts que le ayudarán a crear y probar sus mods. Puedes encontrar tutoriales y guías sobre cómo usar estas herramientas en YouTube o Reddit. También puedes unirte a TABS Modding Discord, donde puedes chatear con otros modders y obtener ayuda o comentarios. </p>
- <h3>Q: ¿Cómo comparto mis mods con otros? </h3>
-<p>A: Si quieres compartir tus mods con otros, puedes subirlos a Nexus Mods o Steam Workshop. Para subir tus mods a Nexus Mods, tendrás que crear una cuenta en su sitio web y seguir sus directrices sobre cómo subir tus archivos. Para subir tus mods a Steam Workshop, necesitarás tener una cuenta de Steam y seguir sus instrucciones sobre cómo publicar tus artículos. </p>
- <h3>Q: ¿Cómo puedo reportar un problema con un mod? </h3> 64aa2da5cf<br />
-<br />
-<br />