Update parquet files (step 45 of 296)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Adobe Photoshop Lightroom Classic CC 2018 7.2.0.10 (x64) Patch ((TOP)) Keygen.md

@@ -1,32 +0,0 @@
-<br />
-<h1>How to Download and Install Adobe Photoshop Lightroom Classic CC 2018 7.2.0.10 (x64) Patch Keygen</h1>
-<p>Adobe Photoshop Lightroom Classic CC 2018 is a powerful and versatile software for editing and organizing your photos. It allows you to import, develop, and export your images in various formats, as well as create slideshows, web galleries, and photo books. With Lightroom Classic CC 2018, you can also sync your photos across multiple devices using the Creative Cloud service.</p>
-<h2>Adobe Photoshop Lightroom Classic CC 2018 7.2.0.10 (x64) Patch keygen</h2><br /><p><b><b>Download File</b> &#9745; <a href="https://byltly.com/2uKzxs">https://byltly.com/2uKzxs</a></b></p><br /><br />
-<p>If you want to download and install Adobe Photoshop Lightroom Classic CC 2018 7.2.0.10 (x64) Patch Keygen, you should be aware of the risks and drawbacks of using a cracked version of the software. In this article, we will explain why you should avoid using a Lightroom crack, and how you can get a legal and safe version of Lightroom Classic CC 2018 for free.</p>
-<h2>Why You Should Avoid Using a Lightroom Crack</h2>
-<p>A Lightroom crack is a modified version of the original software that bypasses the activation process and makes it appear as if it has been licensed with a valid key. However, using a Lightroom crack is illegal and unethical, as it violates the terms of use and the intellectual property rights of Adobe. Moreover, using a Lightroom crack can expose you to various problems, such as:</p>
-<ul>
-<li><b>Malware infection:</b> Many Lightroom cracks are infected with viruses, trojans, worms, or ransomware that can damage your computer and compromise your personal data. These malicious programs can also disable your antivirus software and spread to other devices on your network.</li>
-<li><b>System instability:</b> A Lightroom crack can also cause performance and compatibility issues with your operating system and other software. The cracked version may not work properly with other Adobe products, such as Photoshop or Bridge. It may also crash, freeze, or show errors at unexpected times.</li>
-<li><b>No updates:</b> A Lightroom crack does not receive any updates from Adobe, which means you will miss out on new features, bug fixes, and security patches. This can affect the quality and functionality of your software, as well as make it vulnerable to hackers and cyberattacks.</li>
-<li><b>Legal consequences:</b> Using a Lightroom crack is considered software piracy, which is a serious crime in many countries. If you are caught using a cracked version of Lightroom, you could face legal action from Adobe or the authorities. You could also be fined or even jailed for violating the copyright laws.</li>
-</ul>
-<h2>How to Get Adobe Photoshop Lightroom Classic CC 2018 7.2.0.10 (x64) for Free</h2>
-<p>If you want to use Adobe Photoshop Lightroom Classic CC 2018 7.2.0.10 (x64) legally and safely, you have two options:</p>
-<p></p>
-<ol>
-<li><b>Download the free trial version:</b> You can download the free trial version of Lightroom Classic CC 2018 from the official Adobe website[^2^]. The trial version gives you access to all the features and functions of the software for 7 days. After that, you will need to purchase a subscription plan to continue using it.</li>
-<li><b>Download the free Creative Cloud version:</b> You can also download the free Creative Cloud version of Lightroom Classic CC 2018 from the official Adobe website[^2^]. The Creative Cloud version is similar to the trial version, but it does not expire after 7 days. However, it has some limitations, such as:</li>
-<ul>
-<li>You can only import up to 2 GB of photos per month.</li>
-<li>You can only sync up to 20 GB of photos across your devices.</li>
-<li>You can only use a limited number of presets and profiles.</li>
-<li>You cannot use some advanced features, such as HDR merge, panorama merge, or tethered capture.</li>
-</ul>
-</ol>
-<p>To download either version of Lightroom Classic CC 2018, you will need to create an Adobe account and install the Creative Cloud desktop app on your computer. Then, you can follow these steps:</p>
-<ol>
-<li>Launch the Creative Cloud desktop app and sign in with your Adobe account.</li>
-<li>Select "Apps" from</p> 81aa517590<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Extract Justdial Data What You Need to Know and How to Do It.md

@@ -1,30 +0,0 @@
-<br />
-<h1>How to Extract Justdial Data for Your Business Needs</h1>
-<p>Justdial is an Indian internet technology company that provides local search for different services in India over the phone, website and mobile apps. It has a huge database of businesses, products, services, reviews, ratings, deals and more across various categories and locations. If you are looking for a way to extract Justdial data for your business needs, such as lead generation, market research, competitor analysis, or data mining, you have come to the right place. In this article, we will show you how to extract Justdial data using a web scraping tool and what to consider before and after the extraction process.</p>
-<h2>What is Web Scraping?</h2>
-<p>Web scraping is a technique of extracting data from websites using a software program or a script. It can automate the process of collecting large amounts of data from various web pages and save them in a structured format, such as CSV, Excel, JSON, XML, etc. Web scraping can help you get the data you need from any website without having to manually copy and paste it.</p>
-<h2>extract justdial data</h2><br /><p><b><b>Download Zip</b> &#187; <a href="https://byltly.com/2uKw27">https://byltly.com/2uKw27</a></b></p><br /><br />
-<h2>How to Choose the Best Web Scraping Tool to Extract Justdial Data?</h2>
-<p>There are many web scraping tools available on the internet, but not all of them are equally effective or reliable. Some may have limited features, poor performance, or even legal issues. Therefore, you need to be careful when choosing the best web scraping tool to extract Justdial data. Here are some factors to consider:</p>
-<ul>
-<li><b>Compatibility:</b> Make sure the tool is compatible with your operating system and your target website. For example, if you want to extract Justdial data from its mobile app, you need a tool that can support app scraping.</li>
-<li><b>Scalability:</b> Check how many web pages or records the tool can scrape at a time and how fast it can do it. You may need a tool that can handle large-scale scraping projects without compromising on speed or quality.</li>
-<li><b>Accuracy:</b> Look for a tool that can extract Justdial data accurately and completely. Some tools may miss some data fields or extract incorrect or incomplete data due to dynamic or complex web pages.</li>
-<li><b>User-Friendliness:</b> Choose a tool that is easy to use and has a clear and intuitive interface. You may not want to spend too much time or effort on learning how to use the tool or writing complex codes.</li>
-<li><b>Customer Support:</b> Choose a tool that has good customer support and positive reviews from other users. This can help you solve any problems or questions that may arise during the extraction process.</li>
-</ul>
-<h2>How to Use Web Scraping Tool to Extract Justdial Data?</h2>
-<p>Once you have selected the best web scraping tool to extract Justdial data, you can follow these steps to use it:</p>
-<ol>
-<li><b>Download and Install the Tool:</b> Go to the official website of the tool and download the latest version. Then, install it on your computer following the instructions.</li>
-<li><b>Create a Project and Select Your Target Website:</b> Open the tool and create a new project. Then, enter the URL of your target website or app. For example, if you want to extract Justdial data from its website, you can enter https://www.justdial.com/.</li>
-<li><b>Select Your Data Fields and Configure Your Settings:</b> Choose what data fields you want to extract from Justdial, such as business name, address, phone number, email, website, rating, review, category, location, etc. You can also configure your settings according to your preferences, such as pagination, proxy, delay, captcha, etc.</li>
-<li><b>Start Scraping and Save Your Data:</b> Click on "Start" or "Run" to begin the scraping process. You will see the extracted data on the interface. You can also monitor the progress and status of the scraping task. Once the scraping is completed, you can save your data in your desired format.</li>
-</ol>
-<h2>Tips for Successful Data Extraction</h2>
-<p>To increase your chances of extracting Justdial data successfully, here are some tips to follow:</p>
-<ul>
-<li><b>Follow the</p>
-<p></p> ddb901b051<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Descarga My Talking Tom APK con Dinero y Diamantes Infinitos Gratis.md

@@ -1,138 +0,0 @@
-
-<h1>My Talking Tom Dinero Infinito APK: How to Get Unlimited Coins and Diamonds in My Talking Tom Game</h1>
- <p>Do you love playing with your virtual pet, Tom, in the popular game My Talking Tom? Do you want to have more coins and diamonds to buy him new outfits, accessories, and toys? If yes, then you might be interested in downloading the My Talking Tom Dinero Infinito APK, which is a modified version of the game that gives you unlimited resources. In this article, we will tell you what is My Talking Tom, what is My Talking Tom Dinero Infinito APK, how to download and install it, and how to use it safely and effectively. Let's get started!</p>
-<h2>my talking tom dinero infinito apk</h2><br /><p><b><b>Download Zip</b> ===> <a href="https://jinyurl.com/2uNUCR">https://jinyurl.com/2uNUCR</a></b></p><br /><br />
- <h2>What is My Talking Tom?</h2>
- <p>My Talking Tom is a fun and interactive game that lets you adopt and take care of a cute and funny cat named Tom. You can feed him, play with him, dress him up, and watch him grow from a baby kitten to a full-grown cat. You can also interact with him by talking to him, petting him, poking him, and making him happy or angry. He will respond to your actions and voice with his own expressions and sounds.</p>
- <h3>Features of My Talking Tom</h3>
- <p>Some of the features of My Talking Tom are:</p>
-<ul>
-<li>You can customize your Tom by choosing from hundreds of different outfits, hats, glasses, shoes, and more.</li>
-<li>You can decorate your Tom's home by buying furniture, wallpapers, carpets, and other items.</li>
-<li>You can travel with your Tom to different locations around the world and meet other Toms.</li>
-<li>You can play mini-games with your Tom and earn coins and diamonds.</li>
-<li>You can collect stickers and unlock new items and rewards.</li>
-<li>You can record videos of your Tom and share them with your friends.</li>
-</ul>
- <h3>How to play My Talking Tom</h3>
- <p>To play My Talking Tom, you need to download the game from the Google Play Store or the App Store for free. Then, you need to create your account and choose a name for your Tom. After that, you can start playing with your Tom by tapping on the icons on the screen. You can feed him by dragging food items to his mouth, play with him by tapping on his toys, dress him up by tapping on his wardrobe, and so on. You can also swipe the screen to move around his home or travel to other places. You can earn coins and diamonds by playing mini-games or watching ads. You can use these resources to buy more items for your Tom or unlock new features.</p>
-<p>my talking tom mod apk unlimited money and diamonds<br />
-descargar my talking tom hackeado para android<br />
-my talking tom apk full mega<br />
-como tener dinero infinito en my talking tom<br />
-my talking tom monedas y diamantes infinitos<br />
-my talking tom mod apk latest version download<br />
-trucos para my talking tom android<br />
-my talking tom apk mod todo desbloqueado<br />
-my talking tom hack apk mediafıre<br />
-my talking tom apk sin publicidad<br />
-my talking tom mod apk revdl<br />
-descargar my talking tom con dinero ilimitado<br />
-my talking tom apk mod 2023<br />
-como hackear my talking tom con lucky patcher<br />
-my talking tom mod apk android 1<br />
-descargar my talking tom ultima version hackeado<br />
-my talking tom apk premium<br />
-como conseguir diamantes gratis en my talking tom<br />
-my talking tom mod apk offline<br />
-descargar my talking tom para pc con dinero infinito<br />
-my talking tom hack apk 2023<br />
-como descargar my talking tom hackeado 2023<br />
-my talking tom mod apk unlimited coins and stars<br />
-descargar my talking tom gratis para android<br />
-my talking tom apk mod menu<br />
-como actualizar my talking tom hackeado<br />
-my talking tom mod apk unlimited everything<br />
-descargar my talking tom por mega<br />
-my talking tom hack apk sin root<br />
-como jugar a my talking tom con dinero infinito<br />
-my talking tom mod apk no ads<br />
-descargar my talking tom 2 con dinero infinito<br />
-my talking tom apk full español<br />
-como tener todos los trajes en my talking tom<br />
-my talking tom mod apk happymod<br />
-descargar my talking tom original para android<br />
-my talking tom hack apk 2022<br />
-como descargar e instalar my talking tom hackeado<br />
-my talking tom mod apk unlimited food and potions<br />
-descargar juego de my talking tom con dinero infinito<br />
-my talking tom apk pro<br />
-como ganar mas dinero en my talking tom<br />
-my talking tom mod apk rexdl<br />
-descargar e instalar my talking tom para android gratis <br />
-my talking tom hack apk online <br />
-como tener mas niveles en my talking tom <br />
-my talking tom mod apk unlimited gems <br />
-descargar juego de mi gato que habla con dinero infinito</p>
- <h2>What is My Talking Tom Dinero Infinito APK?</h2>
- <p>My Talking Tom Dinero Infinito APK is a modified version of the original game that gives you unlimited coins and diamonds. This means that you can buy anything you want for your Tom without worrying about running out of money. You can also access all the features and locations in the game without any restrictions. You can enjoy playing with your Tom without any ads or interruptions.</p>
- <h3>Benefits of My Talking Tom Dinero Infinito APK</h3>
- <p>Some of the benefits of My Talking Tom Dinero Infinito APK are:</p>
-<ul>
-<li>You can have more fun and creativity with your Tom by dressing him up in different styles and outfits.</li>
-<li>You can make your Tom's home more cozy and beautiful by decorating it with various items.</li>
-<li>You can explore more places and meet more Toms by traveling around the world.</li> <li>You can play more mini-games and earn more rewards and stickers.</li>
-<li>You can record and share more videos of your Tom with your friends.</li>
-</ul>
- <h3>Risks of My Talking Tom Dinero Infinito APK</h3>
- <p>However, My Talking Tom Dinero Infinito APK is not an official version of the game and it comes with some risks. Some of the risks of My Talking Tom Dinero Infinito APK are:</p>
-<ul>
-<li>You might download a fake or malicious APK file that can harm your device or steal your personal information.</li>
-<li>You might violate the terms and conditions of the original game and get banned or suspended from playing it.</li>
-<li>You might lose your progress or data if the APK file is not compatible with the latest version of the game or your device.</li>
-<li>You might miss out on the updates and new features that the developers of the original game release regularly.</li>
-</ul>
- <h2>How to download and install My Talking Tom Dinero Infinito APK?</h2>
- <p>If you still want to try My Talking Tom Dinero Infinito APK, you need to follow some steps to download and install it on your device. Here are the steps:</p>
- <h3>Steps to download and install My Talking Tom Dinero Infinito APK</h3>
- <ol>
-<li>First, you need to find a reliable and trustworthy source that provides the APK file. You can search online for some reviews and ratings of different websites that offer the APK file.</li>
-<li>Second, you need to enable the installation of apps from unknown sources on your device. You can do this by going to your device settings, security, and allowing unknown sources.</li>
-<li>Third, you need to download the APK file from the source you have chosen. You can use a browser or a downloader app to do this.</li>
-<li>Fourth, you need to locate the downloaded APK file on your device and tap on it to start the installation process. You might need to grant some permissions and accept some terms and conditions before proceeding.</li>
-<li>Fifth, you need to wait for the installation to finish and then launch the game from your app drawer or home screen.</li>
-</ol>
- <h3>Tips to use My Talking Tom Dinero Infinito APK safely and effectively</h3>
- <p>To use My Talking Tom Dinero Infinito APK safely and effectively, you should follow some tips:</p>
-<ul>
-<li>You should scan the APK file with an antivirus or malware scanner before installing it on your device.</li>
-<li>You should backup your original game data before installing the APK file in case something goes wrong.</li>
-<li>You should not use your real name, email, or social media accounts to sign in to the game as it might compromise your privacy and security.</li>
-<li>You should not use the APK file to cheat or harass other players as it might get you reported or banned.</li>
-<li>You should check for updates and new features of the original game regularly and switch back to it if you want to enjoy them.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>My Talking Tom is a fun and interactive game that lets you adopt and take care of a virtual pet, Tom. You can customize him, play with him, travel with him, and more. However, if you want to have unlimited coins and diamonds in the game, you might be tempted to download the My Talking Tom Dinero Infinito APK, which is a modified version of the game that gives you unlimited resources. However, this comes with some risks such as downloading a fake or malicious file, violating the terms and conditions of the original game, losing your progress or data, or missing out on the updates and new features. Therefore, you should be careful and follow some steps and tips to download and install the APK file safely and effectively. Alternatively, you can stick to the original game and enjoy it as it is.</p>
- <h3>Summary of the main points</h3>
- <p>In this article, we have discussed:</p>
-<ul>
-<li>What is My Talking Tom?</li>
-<li>What is My Talking Tom Dinero Infinito APK?</li>
-<li>How to download and install My Talking Tom Dinero Infinito APK?</li>
-<li>How to use My Talking Tom Dinero Infinito APK safely and effectively?</li>
-</ul>
- <h3>Call to action</h3>
- <p>If you found this article helpful, please share it with your friends who love playing My Talking Tom. Also, let us know in the comments below what do you think about My Talking Tom Dinero Infinito APK. Do you use it or not? Why or why not? We would love to hear from you!</p>
- <h4>Frequently Asked Questions</h4>
- <p>Here are some frequently asked questions about My Talking Tom Dinero Inf inito APK:</p>
- <ol>
-<li>What is the difference between My Talking Tom and My Talking Tom 2?</li>
-<p>My Talking Tom 2 is the sequel to My Talking Tom, which was released in 2018. It has more features and options than the first game, such as new mini-games, new outfits, new pets, new locations, and more. However, the basic gameplay and concept are the same as the first game.</p>
-<li>Is My Talking Tom Dinero Infinito APK legal?</li>
-<p>No, My Talking Tom Dinero Infinito APK is not legal. It is a modified version of the original game that violates the intellectual property rights of the developers and the terms and conditions of the game. It is also considered as cheating and unfair to other players who play the game legitimately.</p>
-<li>Is My Talking Tom Dinero Infinito APK safe?</li>
-<p>Not necessarily. My Talking Tom Dinero Infinito APK can be unsafe if you download it from an untrusted or malicious source. It can contain viruses, malware, spyware, or other harmful software that can damage your device or steal your personal information. It can also cause your device to malfunction or crash.</p>
-<li>How can I get coins and diamonds in My Talking Tom without using My Talking Tom Dinero Infinito APK?</li>
-<p>You can get coins and diamonds in My Talking Tom without using My Talking Tom Dinero Infinito APK by playing the game normally and following some tips. Some of the tips are:</p>
-<ul>
-<li>Play mini-games regularly and earn coins and diamonds as rewards.</li>
-<li>Watch ads and videos in the game and earn coins and diamonds as rewards.</li>
-<li>Complete daily tasks and challenges and earn coins and diamonds as rewards.</li>
-<li>Spin the wheel of fortune and win coins and diamonds as prizes.</li>
-<li>Invite your friends to play the game and earn coins and diamonds as bonuses.</li>
-</ul>
-<li>How can I contact the developers of My Talking Tom if I have any questions or feedback?</li>
-<p>You can contact the developers of My Talking Tom by visiting their official website, Facebook page, Twitter account, Instagram account, YouTube channel, or email address. You can also leave a review or rating on the Google Play Store or the App Store.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Facebook Lite The Best Way to Download Facebook for Android.md

@@ -1,173 +0,0 @@
-
-<h1>Facebook Download Free APK: How to Get the Best Version of Facebook for Your Android Device</h1>
- <h2>Introduction</h2>
- <p>Facebook is one of the most popular social media platforms in the world, with over 2.8 billion monthly active users as of 2021. It allows you to connect with your friends and family, share photos and videos, join groups and pages, play games, watch live streams, and much more.</p>
-<h2>facebook download free apk</h2><br /><p><b><b>DOWNLOAD</b> &#9999; &#9999; &#9999; <a href="https://jinyurl.com/2uNMOC">https://jinyurl.com/2uNMOC</a></b></p><br /><br />
- <p>But what if you want to use Facebook on your Android device without any limitations or restrictions? What if you want to enjoy the latest features and updates before anyone else? What if you want to save data and storage space while using Facebook?</p>
- <p>The answer is simple: you need to download Facebook APK for Android. An APK (Android Package Kit) is a file format that contains all the components of an Android app, such as the code, resources, assets, and manifest. By downloading and installing an APK file, you can bypass the Google Play Store and get access to any app you want, even if it is not available in your region or compatible with your device.</p>
- <p>In this article, we will show you how to download Facebook APK for Android, how to update it, and how to troubleshoot it. We will also share some benefits of downloading Facebook APK for Android, as well as some tips and tricks to optimize your Facebook experience. Let's get started!</p>
- <h2>How to Download Facebook APK for Android</h2>
- <h3>Step 1: Find a reliable source for the APK file</h3>
- <p>The first step is to find a trustworthy website that offers the Facebook APK file for download. There are many websites that claim to provide free APK files, but some of them may contain malware or viruses that can harm your device or steal your personal information. Therefore, you should always do some research before downloading any APK file from an unknown source.</p>
- <p>One of the best websites that we recommend for downloading Facebook APK for Android is [APKCombo](^2^). This website has a huge collection of APK files for various apps and games, including Facebook. It also provides detailed information about each app, such as the version number, size, developer, rating, screenshots, and description. You can also read user reviews and feedback about each app before downloading it.</p>
-<p>facebook lite apk free download<br />
-facebook app apk download for android<br />
-facebook messenger apk free download<br />
-facebook mod apk download free<br />
-facebook video downloader apk free<br />
-facebook apk download latest version<br />
-facebook dark mode apk free download<br />
-facebook auto liker apk free download<br />
-facebook hack apk free download<br />
-facebook old version apk free download<br />
-facebook transparent apk free download<br />
-facebook password cracker apk free download<br />
-facebook story saver apk free download<br />
-facebook pro apk free download<br />
-facebook page manager apk free download<br />
-facebook gameroom apk free download<br />
-facebook creator studio apk free download<br />
-facebook business suite apk free download<br />
-facebook dating apk free download<br />
-facebook watch apk free download<br />
-facebook ads manager apk free download<br />
-facebook analytics apk free download<br />
-facebook avatar maker apk free download<br />
-facebook beta tester apk free download<br />
-facebook chat heads apk free download<br />
-facebook clone apk free download<br />
-facebook code generator apk free download<br />
-facebook cover photo maker apk free download<br />
-facebook desktop mode apk free download<br />
-facebook downloader app apk free<br />
-facebook emoji keyboard apk free download<br />
-facebook events app apk free download<br />
-facebook fast delete messages apk free download<br />
-facebook followers app apk free download<br />
-facebook friends mapper apk free download<br />
-facebook groups app apk free download<br />
-facebook hacker app apk free download<br />
-facebook home launcher apk free download<br />
-facebook image downloader apk free <br />
-facebook instant games apk free download <br />
-facebook jailbreak app apk free <br />
-facebook keyboard app apk free <br />
-facebook live stream app apk free <br />
-facebook login app apk free <br />
-facebook marketplace app apk free <br />
-facebook messenger lite apk free <br />
-facebook notification sound changer app <br />
-facebook photo editor app </p>
- <h3>Step 2: Enable unknown sources on your device</h3>
- <p>The next step is to enable unknown sources on your device. This is a security setting that prevents you from installing apps from sources other than the Google Play Store. However, since we are going to install an APK file from a third-party website, we need to enable this option temporarily.</p>
- <p>To enable unknown sources on your device, follow these steps:</p>
- <ul>
-<li>Go to Settings > Security > Unknown Sources (or Settings > Apps > Special Access > Install Unknown Apps).</li>
-<li>Toggle on the switch or check the box next to Unknown Sources (or Allow from this source).</li>
-<li>A warning message will pop up. Tap OK or Allow to confirm.</li>
-</ul>
- <p>You can disable this option again after installing the Facebook APK file.</p>
- <h3>Step 3: Download and install the APK file</h3>
- <p>The third step is to download and install the Facebook APK file on your device. To do this, follow these steps:</p>
- <ul>
-<li>Open your browser and go to the APKCombo website and search for Facebook APK. Alternatively, you can use this link: .</li>
-<li>Scroll down and find the Facebook APK file that matches your device's specifications. Tap on the Download button next to it.</li>
-<li>A download prompt will appear. Tap on Download again to confirm.</li>
-<li>Wait for the download to finish. You can check the progress in the notification bar or the Downloads folder.</li>
-<li>Once the download is complete, tap on the APK file to open it. A installation prompt will appear. Tap on Install to start the installation process.</li>
-<li>Wait for the installation to finish. You can check the progress in the notification bar or the Apps folder.</li>
-<li>Once the installation is complete, tap on Open to launch Facebook on your device. Alternatively, you can find the Facebook icon on your home screen or app drawer and tap on it.</li>
-</ul>
- <h3>Step 4: Launch and enjoy Facebook on your device</h3>
- <p>The final step is to launch and enjoy Facebook on your device. You can log in with your existing Facebook account or create a new one. You can also customize your settings and preferences according to your needs. You can now access all the features and functions of Facebook, such as:</p>
- <ul>
-<li>Chatting with your friends and family via Messenger or WhatsApp.</li>
-<li>Sharing photos and videos via Stories or News Feed.</li>
-<li>Joining groups and pages that interest you.</li>
-<li>Playing games with your friends or other users.</li>
-<li>Watching live streams or videos from your favorite creators or celebrities.</li>
-<li>Shopping online via Marketplace or Shops.</li>
-<li>And much more!</li>
-</ul>
- <h2>How to Update Facebook APK for Android</h2>
- <p>One of the advantages of downloading Facebook APK for Android is that you can get the latest updates and features before they are released on the Google Play Store. However, you need to update the APK file manually whenever a new version is available. There are two ways to do this:</p>
- <h3>Option 1: Use the built-in update feature</h3>
- <p>The easiest way to update Facebook APK for Android is to use the built-in update feature within the app. To do this, follow these steps:</p>
- <ul>
-<li>Open Facebook on your device and tap on the menu icon (three horizontal lines) at the top right corner of the screen.</li>
-<li>Scroll down and tap on Settings & Privacy > App Updates.</li>
-<li>If there is a new version available, you will see a notification saying "Update Available". Tap on Update Now to start the update process.</li>
-<li>Wait for the update to finish. You can check the progress in the notification bar or the App Updates screen.</li>
-<li>Once the update is complete, tap on Restart Now to relaunch Facebook on your device.</li>
-</ul>
- <h3>Option 2: Download and install the latest version manually</h3>
- <p>The other way to update Facebook APK for Android is to download and install the latest version manually from a third-party website, such as APKCombo. To do this, follow these steps:</p>
- <ul>
-<li>Open your browser and go to the APKCombo website and search for the latest version of Facebook APK. Alternatively, you can use this link: .</li>
-<li>Scroll down and find the Facebook APK file that matches your device's specifications. Tap on the Download button next to it.</li>
-<li>A download prompt will appear. Tap on Download again to confirm.</li>
-<li>Wait for the download to finish. You can check the progress in the notification bar or the Downloads folder.</li>
-<li>Once the download is complete, tap on the APK file to open it. A installation prompt will appear. Tap on Install to start the installation process.</li>
-<li>Wait for the installation to finish. You can check the progress in the notification bar or the Apps folder.</li>
-<li>Once the installation is complete, tap on Open to launch Facebook on your device. Alternatively, you can find the Facebook icon on your home screen or app drawer and tap on it.</li>
-</ul>
- <p>Note: You may need to uninstall the previous version of Facebook APK before installing the new one, depending on the compatibility and security of the app.</p>
- <h2>How to Troubleshoot Facebook APK for Android</h2>
- <h3>Common issues and solutions</h3>
- <p>Sometimes, you may encounter some issues or errors while using Facebook APK for Android. Here are some of the most common ones and how to fix them:</p>
- <table>
-<tr>
-<th>Issue</th>
-<th>Solution</th>
-</tr>
-<tr>
-<td>The app crashes or freezes frequently.</td>
-<td>Clear the app cache and data by going to Settings > Apps > Facebook > Storage > Clear Cache and Clear Data. Restart your device and try again.</td>
-</tr>
-<tr>
-<td>The app does not load or display properly.</td>
-<td>Check your internet connection and make sure it is stable and fast. Try using a different network or a VPN if possible. Update your device's software and browser if needed.</td>
-</tr>
-<tr>
-<td>The app does not show notifications or messages.</td>
-<td>Enable notifications and permissions for Facebook by going to Settings > Apps > Facebook > Notifications and Settings > Apps > Facebook > Permissions. Make sure you are logged in with the correct account and sync your data if needed.</td>
-</tr>
-<tr>
-<td>The app does not support some features or functions.</td>
-<td>Make sure you have downloaded the latest version of Facebook APK for Android from a reliable source. Check if your device meets the minimum requirements for running the app. Try using a different device or emulator if possible.</td>
-</tr>
-</table>
- <h3>Tips and tricks to optimize your Facebook experience</h3>
- <p>Besides troubleshooting, there are also some tips and tricks that you can use to optimize your Facebook experience while using Facebook APK for Android. Here are some of them:</p>
- <ul>
-<li>Use Facebook Lite APK for Android if you want to save data and storage space while using Facebook. This is a lighter and faster version of Facebook that consumes less resources and works well on low-end devices.</li>
-<li>Use Facebook Dark Mode APK for Android if you want to switch to a dark theme while using Facebook. This is a feature that changes the background color of the app to black, which reduces eye strain and battery consumption.</li>
-<li>Use Facebook Mod APK for Android if you want to unlock some premium features and functions while using Facebook. This is a modified version of Facebook that offers some extra benefits, such as removing ads, enabling video downloads, enhancing privacy, and more.</li>
-<li>Use Facebook Messenger APK for Android if you want to chat with your friends and family without opening the main Facebook app. This is a standalone app that allows you to send and receive messages, stickers, emojis, gifs, voice notes, video calls, and more.</li>
-<li>Use Facebook Watch APK for Android if you want to watch videos from your favorite creators and celebrities without opening the main Facebook app. This is a standalone app that allows you to browse and stream videos from various categories, such as news, sports, entertainment, gaming, and more.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>In conclusion, downloading Facebook APK for Android is a great way to get the best version of Facebook for your Android device. You can enjoy all the features and functions of Facebook without any limitations or restrictions. You can also get access to the latest updates and features before anyone else. All you need to do is follow the steps we have provided in this article and you will be able to download, install, update, and troubleshoot Facebook APK for Android with ease.</p>
- <p>We hope you found this article helpful and informative. If you have any questions or feedback, please feel free to leave a comment below. We would love to hear from you!</p>
- <h2>Frequently Asked Questions</h2>
- <p>Here are some of the most frequently asked questions about downloading Facebook APK for Android. We hope they will answer some of your queries and doubts.</p>
- <ol>
-<li>Is downloading Facebook APK for Android safe and legal?</li>
-<p>Yes, downloading Facebook APK for Android is safe and legal, as long as you download it from a reliable and reputable source, such as APKCombo. You should also scan the APK file with an antivirus or malware scanner before installing it on your device. However, you should be aware that downloading Facebook APK for Android may violate the terms and conditions of Facebook and Google Play Store, and you may lose some features or support from the official app.</p>
-<li>What are the minimum requirements for running Facebook APK for Android?</li>
-<p>The minimum requirements for running Facebook APK for Android may vary depending on the version and the device you are using. However, generally speaking, you will need an Android device with at least 1 GB of RAM, 100 MB of free storage space, and a stable internet connection. You will also need to enable unknown sources on your device to install the APK file.</p>
-<li>How can I delete Facebook APK for Android from my device?</li>
-<p>If you want to delete Facebook APK for Android from your device, you can follow these steps:</p>
- <ul>
-<li>Go to Settings > Apps > Facebook > Uninstall.</li>
-<li>Tap on OK or Uninstall to confirm.</li>
-<li>Wait for the uninstallation to finish.</li>
-<li>You can also delete the APK file from your Downloads folder or any other location where you saved it.</li>
-</ul>
- <li>How can I contact Facebook support if I have any issues or problems with Facebook APK for Android?</li>
-<p>If you have any issues or problems with Facebook APK for Android, you can try contacting Facebook support by going to Settings > Help & Support > Report a Problem within the app. You can also visit the official Facebook Help Center website or the Facebook Community Forum website for more information and assistance.</p>
-<li>Can I use Facebook APK for Android on other devices or platforms, such as iOS, Windows, or Mac?</li>
-<p>No, you cannot use Facebook APK for Android on other devices or platforms, such as iOS, Windows, or Mac. The APK file is only compatible with Android devices and emulators. If you want to use Facebook on other devices or platforms, you will need to download the official app from the respective app store or use the web version of Facebook on your browser.</p>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/2ndelement/voicevox/test/test_user_dict_model.py

@@ -1,108 +0,0 @@
-from copy import deepcopy
-from unittest import TestCase
-
-from pydantic import ValidationError
-
-from voicevox_engine.kana_parser import parse_kana
-from voicevox_engine.model import UserDictWord
-
-
-class TestUserDictWords(TestCase):
-    def setUp(self):
-        self.test_model = {
-            "surface": "テスト",
-            "priority": 0,
-            "part_of_speech": "名詞",
-            "part_of_speech_detail_1": "固有名詞",
-            "part_of_speech_detail_2": "一般",
-            "part_of_speech_detail_3": "*",
-            "inflectional_type": "*",
-            "inflectional_form": "*",
-            "stem": "*",
-            "yomi": "テスト",
-            "pronunciation": "テスト",
-            "accent_type": 0,
-            "accent_associative_rule": "*",
-        }
-
-    def test_valid_word(self):
-        test_value = deepcopy(self.test_model)
-        try:
-            UserDictWord(**test_value)
-        except ValidationError as e:
-            self.fail(f"Unexpected Validation Error\n{str(e)}")
-
-    def test_convert_to_zenkaku(self):
-        test_value = deepcopy(self.test_model)
-        test_value["surface"] = "test"
-        self.assertEqual(UserDictWord(**test_value).surface, "ｔｅｓｔ")
-
-    def test_count_mora(self):
-        test_value = deepcopy(self.test_model)
-        self.assertEqual(UserDictWord(**test_value).mora_count, 3)
-
-    def test_count_mora_x(self):
-        test_value = deepcopy(self.test_model)
-        for s in [chr(i) for i in range(12449, 12533)]:
-            if s in ["ァ", "ィ", "ゥ", "ェ", "ォ", "ッ", "ャ", "ュ", "ョ", "ヮ"]:
-                continue
-            for x in "ァィゥェォャュョ":
-                expected_count = 0
-                test_value["pronunciation"] = s + x
-                for accent_phrase in parse_kana(
-                    test_value["pronunciation"] + "'",
-                ):
-                    expected_count += len(accent_phrase.moras)
-                with self.subTest(s=s, x=x):
-                    self.assertEqual(
-                        UserDictWord(**test_value).mora_count,
-                        expected_count,
-                    )
-
-    def test_count_mora_xwa(self):
-        test_value = deepcopy(self.test_model)
-        test_value["pronunciation"] = "クヮンセイ"
-        expected_count = 0
-        for accent_phrase in parse_kana(
-            test_value["pronunciation"] + "'",
-        ):
-            expected_count += len(accent_phrase.moras)
-        self.assertEqual(
-            UserDictWord(**test_value).mora_count,
-            expected_count,
-        )
-
-    def test_invalid_pronunciation_not_katakana(self):
-        test_value = deepcopy(self.test_model)
-        test_value["pronunciation"] = "ぼいぼ"
-        with self.assertRaises(ValidationError):
-            UserDictWord(**test_value)
-
-    def test_invalid_pronunciation_invalid_sutegana(self):
-        test_value = deepcopy(self.test_model)
-        test_value["pronunciation"] = "アィウェォ"
-        with self.assertRaises(ValidationError):
-            UserDictWord(**test_value)
-
-    def test_invalid_pronunciation_invalid_xwa(self):
-        test_value = deepcopy(self.test_model)
-        test_value["pronunciation"] = "アヮ"
-        with self.assertRaises(ValidationError):
-            UserDictWord(**test_value)
-
-    def test_count_mora_voiced_sound(self):
-        test_value = deepcopy(self.test_model)
-        test_value["pronunciation"] = "ボイボ"
-        self.assertEqual(UserDictWord(**test_value).mora_count, 3)
-
-    def test_invalid_accent_type(self):
-        test_value = deepcopy(self.test_model)
-        test_value["accent_type"] = 4
-        with self.assertRaises(ValidationError):
-            UserDictWord(**test_value)
-
-    def test_invalid_accent_type_2(self):
-        test_value = deepcopy(self.test_model)
-        test_value["accent_type"] = -1
-        with self.assertRaises(ValidationError):
-            UserDictWord(**test_value)

spaces/801artistry/RVC801/demucs/pretrained.py

@@ -1,107 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-# author: adefossez
-
-import logging
-
-from diffq import DiffQuantizer
-import torch.hub
-
-from .model import Demucs
-from .tasnet import ConvTasNet
-from .utils import set_state
-
-logger = logging.getLogger(__name__)
-ROOT = "https://dl.fbaipublicfiles.com/demucs/v3.0/"
-
-PRETRAINED_MODELS = {
-    'demucs': 'e07c671f',
-    'demucs48_hq': '28a1282c',
-    'demucs_extra': '3646af93',
-    'demucs_quantized': '07afea75',
-    'tasnet': 'beb46fac',
-    'tasnet_extra': 'df3777b2',
-    'demucs_unittest': '09ebc15f',
-}
-
-SOURCES = ["drums", "bass", "other", "vocals"]
-
-
-def get_url(name):
-    sig = PRETRAINED_MODELS[name]
-    return ROOT + name + "-" + sig[:8] + ".th"
-
-
-def is_pretrained(name):
-    return name in PRETRAINED_MODELS
-
-
-def load_pretrained(name):
-    if name == "demucs":
-        return demucs(pretrained=True)
-    elif name == "demucs48_hq":
-        return demucs(pretrained=True, hq=True, channels=48)
-    elif name == "demucs_extra":
-        return demucs(pretrained=True, extra=True)
-    elif name == "demucs_quantized":
-        return demucs(pretrained=True, quantized=True)
-    elif name == "demucs_unittest":
-        return demucs_unittest(pretrained=True)
-    elif name == "tasnet":
-        return tasnet(pretrained=True)
-    elif name == "tasnet_extra":
-        return tasnet(pretrained=True, extra=True)
-    else:
-        raise ValueError(f"Invalid pretrained name {name}")
-
-
-def _load_state(name, model, quantizer=None):
-    url = get_url(name)
-    state = torch.hub.load_state_dict_from_url(url, map_location='cpu', check_hash=True)
-    set_state(model, quantizer, state)
-    if quantizer:
-        quantizer.detach()
-
-
-def demucs_unittest(pretrained=True):
-    model = Demucs(channels=4, sources=SOURCES)
-    if pretrained:
-        _load_state('demucs_unittest', model)
-    return model
-
-
-def demucs(pretrained=True, extra=False, quantized=False, hq=False, channels=64):
-    if not pretrained and (extra or quantized or hq):
-        raise ValueError("if extra or quantized is True, pretrained must be True.")
-    model = Demucs(sources=SOURCES, channels=channels)
-    if pretrained:
-        name = 'demucs'
-        if channels != 64:
-            name += str(channels)
-        quantizer = None
-        if sum([extra, quantized, hq]) > 1:
-            raise ValueError("Only one of extra, quantized, hq, can be True.")
-        if quantized:
-            quantizer = DiffQuantizer(model, group_size=8, min_size=1)
-            name += '_quantized'
-        if extra:
-            name += '_extra'
-        if hq:
-            name += '_hq'
-        _load_state(name, model, quantizer)
-    return model
-
-
-def tasnet(pretrained=True, extra=False):
-    if not pretrained and extra:
-        raise ValueError("if extra is True, pretrained must be True.")
-    model = ConvTasNet(X=10, sources=SOURCES)
-    if pretrained:
-        name = 'tasnet'
-        if extra:
-            name = 'tasnet_extra'
-        _load_state(name, model)
-    return model

spaces/801artistry/RVC801/infer/lib/infer_pack/modules/F0Predictor/HarvestF0Predictor.py

@@ -1,87 +0,0 @@
-import numpy as np
-import pyworld
-
-from infer.lib.infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
-
-
-class HarvestF0Predictor(F0Predictor):
-    def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
-        self.hop_length = hop_length
-        self.f0_min = f0_min
-        self.f0_max = f0_max
-        self.sampling_rate = sampling_rate
-
-    def interpolate_f0(self, f0):
-        """
-        对F0进行插值处理
-        """
-
-        data = np.reshape(f0, (f0.size, 1))
-
-        vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
-        vuv_vector[data > 0.0] = 1.0
-        vuv_vector[data <= 0.0] = 0.0
-
-        ip_data = data
-
-        frame_number = data.size
-        last_value = 0.0
-        for i in range(frame_number):
-            if data[i] <= 0.0:
-                j = i + 1
-                for j in range(i + 1, frame_number):
-                    if data[j] > 0.0:
-                        break
-                if j < frame_number - 1:
-                    if last_value > 0.0:
-                        step = (data[j] - data[i - 1]) / float(j - i)
-                        for k in range(i, j):
-                            ip_data[k] = data[i - 1] + step * (k - i + 1)
-                    else:
-                        for k in range(i, j):
-                            ip_data[k] = data[j]
-                else:
-                    for k in range(i, frame_number):
-                        ip_data[k] = last_value
-            else:
-                ip_data[i] = data[i]  # 这里可能存在一个没有必要的拷贝
-                last_value = data[i]
-
-        return ip_data[:, 0], vuv_vector[:, 0]
-
-    def resize_f0(self, x, target_len):
-        source = np.array(x)
-        source[source < 0.001] = np.nan
-        target = np.interp(
-            np.arange(0, len(source) * target_len, len(source)) / target_len,
-            np.arange(0, len(source)),
-            source,
-        )
-        res = np.nan_to_num(target)
-        return res
-
-    def compute_f0(self, wav, p_len=None):
-        if p_len is None:
-            p_len = wav.shape[0] // self.hop_length
-        f0, t = pyworld.harvest(
-            wav.astype(np.double),
-            fs=self.hop_length,
-            f0_ceil=self.f0_max,
-            f0_floor=self.f0_min,
-            frame_period=1000 * self.hop_length / self.sampling_rate,
-        )
-        f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.fs)
-        return self.interpolate_f0(self.resize_f0(f0, p_len))[0]
-
-    def compute_f0_uv(self, wav, p_len=None):
-        if p_len is None:
-            p_len = wav.shape[0] // self.hop_length
-        f0, t = pyworld.harvest(
-            wav.astype(np.double),
-            fs=self.sampling_rate,
-            f0_floor=self.f0_min,
-            f0_ceil=self.f0_max,
-            frame_period=1000 * self.hop_length / self.sampling_rate,
-        )
-        f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
-        return self.interpolate_f0(self.resize_f0(f0, p_len))

spaces/801artistry/RVC801/lib/uvr5_pack/lib_v5/layers_537227KB.py

@@ -1,126 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-from . import spec_utils
-
-
-class Conv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(Conv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nout,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                bias=False,
-            ),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-
-    def __call__(self, x):
-        return self.conv(x)
-
-
-class SeperableConv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(SeperableConv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nin,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                groups=nin,
-                bias=False,
-            ),
-            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-
-    def __call__(self, x):
-        return self.conv(x)
-
-
-class Encoder(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
-        super(Encoder, self).__init__()
-        self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        self.conv2 = Conv2DBNActiv(nout, nout, ksize, stride, pad, activ=activ)
-
-    def __call__(self, x):
-        skip = self.conv1(x)
-        h = self.conv2(skip)
-
-        return h, skip
-
-
-class Decoder(nn.Module):
-    def __init__(
-        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
-    ):
-        super(Decoder, self).__init__()
-        self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        self.dropout = nn.Dropout2d(0.1) if dropout else None
-
-    def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        if skip is not None:
-            skip = spec_utils.crop_center(skip, x)
-            x = torch.cat([x, skip], dim=1)
-        h = self.conv(x)
-
-        if self.dropout is not None:
-            h = self.dropout(h)
-
-        return h
-
-
-class ASPPModule(nn.Module):
-    def __init__(self, nin, nout, dilations=(4, 8, 16, 32, 64), activ=nn.ReLU):
-        super(ASPPModule, self).__init__()
-        self.conv1 = nn.Sequential(
-            nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
-        )
-        self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
-        self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
-        )
-        self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
-        )
-        self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.conv6 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.conv7 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 7, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
-        )
-
-    def forward(self, x):
-        _, _, h, w = x.size()
-        feat1 = F.interpolate(
-            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
-        )
-        feat2 = self.conv2(x)
-        feat3 = self.conv3(x)
-        feat4 = self.conv4(x)
-        feat5 = self.conv5(x)
-        feat6 = self.conv6(x)
-        feat7 = self.conv7(x)
-        out = torch.cat((feat1, feat2, feat3, feat4, feat5, feat6, feat7), dim=1)
-        bottle = self.bottleneck(out)
-        return bottle

spaces/AIGC-Audio/Make_An_Audio/ldm/modules/diffusionmodules/openaimodel.py

@@ -1,963 +0,0 @@
-from abc import abstractmethod
-from functools import partial
-import math
-from typing import Iterable
-
-import numpy as np
-import torch as th
-import torch.nn as nn
-import torch.nn.functional as F
-
-from ldm.modules.diffusionmodules.util import (
-    checkpoint,
-    conv_nd,
-    linear,
-    avg_pool_nd,
-    zero_module,
-    normalization,
-    timestep_embedding,
-)
-from ldm.modules.attention import SpatialTransformer
-
-
-# dummy replace
-def convert_module_to_f16(x):
-    pass
-
-def convert_module_to_f32(x):
-    pass
-
-
-## go
-class AttentionPool2d(nn.Module):
-    """
-    Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py
-    """
-
-    def __init__(
-        self,
-        spacial_dim: int,
-        embed_dim: int,
-        num_heads_channels: int,
-        output_dim: int = None,
-    ):
-        super().__init__()
-        self.positional_embedding = nn.Parameter(th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5)
-        self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1)
-        self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1)
-        self.num_heads = embed_dim // num_heads_channels
-        self.attention = QKVAttention(self.num_heads)
-
-    def forward(self, x):
-        b, c, *_spatial = x.shape
-        x = x.reshape(b, c, -1)  # NC(HW)
-        x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1)  # NC(HW+1)
-        x = x + self.positional_embedding[None, :, :].to(x.dtype)  # NC(HW+1)
-        x = self.qkv_proj(x)
-        x = self.attention(x)
-        x = self.c_proj(x)
-        return x[:, :, 0]
-
-
-class TimestepBlock(nn.Module):
-    """
-    Any module where forward() takes timestep embeddings as a second argument.
-    """
-
-    @abstractmethod
-    def forward(self, x, emb):
-        """
-        Apply the module to `x` given `emb` timestep embeddings.
-        """
-
-
-class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
-    """
-    A sequential module that passes timestep embeddings to the children that
-    support it as an extra input.
-    """
-
-    def forward(self, x, emb, context=None):
-        for layer in self:
-            if isinstance(layer, TimestepBlock):
-                x = layer(x, emb)
-            elif isinstance(layer, SpatialTransformer):
-                x = layer(x, context)
-            else:
-                x = layer(x)
-        return x
-
-
-class Upsample(nn.Module):
-    """
-    An upsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 upsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        if use_conv:
-            self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=padding)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        if self.dims == 3:
-            x = F.interpolate(
-                x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
-            )
-        else:
-            x = F.interpolate(x, scale_factor=2, mode="nearest")
-        if self.use_conv:
-            x = self.conv(x)
-        return x
-
-class TransposedUpsample(nn.Module):
-    'Learned 2x upsampling without padding'
-    def __init__(self, channels, out_channels=None, ks=5):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-
-        self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2)
-
-    def forward(self,x):
-        return self.up(x)
-
-
-class Downsample(nn.Module):
-    """
-    A downsampling layer with an optional convolution.
-    :param channels: channels in the inputs and outputs.
-    :param use_conv: a bool determining if a convolution is applied.
-    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
-                 downsampling occurs in the inner-two dimensions.
-    """
-
-    def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1):
-        super().__init__()
-        self.channels = channels
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.dims = dims
-        stride = 2 if dims != 3 else (1, 2, 2)
-        if use_conv:
-            self.op = conv_nd(
-                dims, self.channels, self.out_channels, 3, stride=stride, padding=padding
-            )
-        else:
-            assert self.channels == self.out_channels
-            self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
-
-    def forward(self, x):
-        assert x.shape[1] == self.channels
-        return self.op(x)
-
-
-class ResBlock(TimestepBlock):
-    """
-    A residual block that can optionally change the number of channels.
-    :param channels: the number of input channels.
-    :param emb_channels: the number of timestep embedding channels.
-    :param dropout: the rate of dropout.
-    :param out_channels: if specified, the number of out channels.
-    :param use_conv: if True and out_channels is specified, use a spatial
-        convolution instead of a smaller 1x1 convolution to change the
-        channels in the skip connection.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param use_checkpoint: if True, use gradient checkpointing on this module.
-    :param up: if True, use this block for upsampling.
-    :param down: if True, use this block for downsampling.
-    """
-
-    def __init__(
-        self,
-        channels,
-        emb_channels,
-        dropout,
-        out_channels=None,
-        use_conv=False,
-        use_scale_shift_norm=False,
-        dims=2,
-        use_checkpoint=False,
-        up=False,
-        down=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.emb_channels = emb_channels
-        self.dropout = dropout
-        self.out_channels = out_channels or channels
-        self.use_conv = use_conv
-        self.use_checkpoint = use_checkpoint
-        self.use_scale_shift_norm = use_scale_shift_norm
-
-        self.in_layers = nn.Sequential(
-            normalization(channels),
-            nn.SiLU(),
-            conv_nd(dims, channels, self.out_channels, 3, padding=1),
-        )
-
-        self.updown = up or down
-
-        if up:
-            self.h_upd = Upsample(channels, False, dims)
-            self.x_upd = Upsample(channels, False, dims)
-        elif down:
-            self.h_upd = Downsample(channels, False, dims)
-            self.x_upd = Downsample(channels, False, dims)
-        else:
-            self.h_upd = self.x_upd = nn.Identity()
-
-        self.emb_layers = nn.Sequential(
-            nn.SiLU(),
-            linear(
-                emb_channels,
-                2 * self.out_channels if use_scale_shift_norm else self.out_channels,
-            ),
-        )
-        self.out_layers = nn.Sequential(
-            normalization(self.out_channels),
-            nn.SiLU(),
-            nn.Dropout(p=dropout),
-            zero_module(
-                conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)
-            ),
-        )
-
-        if self.out_channels == channels:
-            self.skip_connection = nn.Identity()
-        elif use_conv:
-            self.skip_connection = conv_nd(
-                dims, channels, self.out_channels, 3, padding=1
-            )
-        else:
-            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
-
-    def forward(self, x, emb):
-        """
-        Apply the block to a Tensor, conditioned on a timestep embedding.
-        :param x: an [N x C x ...] Tensor of features.
-        :param emb: an [N x emb_channels] Tensor of timestep embeddings.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        return checkpoint(
-            self._forward, (x, emb), self.parameters(), self.use_checkpoint
-        )
-
-
-    def _forward(self, x, emb):
-        if self.updown:
-            in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
-            h = in_rest(x)
-            h = self.h_upd(h)
-            x = self.x_upd(x)
-            h = in_conv(h)
-        else:
-            h = self.in_layers(x)
-        emb_out = self.emb_layers(emb).type(h.dtype)
-        while len(emb_out.shape) < len(h.shape):
-            emb_out = emb_out[..., None]
-        if self.use_scale_shift_norm:
-            out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
-            scale, shift = th.chunk(emb_out, 2, dim=1)
-            h = out_norm(h) * (1 + scale) + shift
-            h = out_rest(h)
-        else:
-            h = h + emb_out
-            h = self.out_layers(h)
-        return self.skip_connection(x) + h
-
-
-class AttentionBlock(nn.Module):
-    """
-    An attention block that allows spatial positions to attend to each other.
-    Originally ported from here, but adapted to the N-d case.
-    https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
-    """
-
-    def __init__(
-        self,
-        channels,
-        num_heads=1,
-        num_head_channels=-1,
-        use_checkpoint=False,
-        use_new_attention_order=False,
-    ):
-        super().__init__()
-        self.channels = channels
-        if num_head_channels == -1:
-            self.num_heads = num_heads
-        else:
-            assert (
-                channels % num_head_channels == 0
-            ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
-            self.num_heads = channels // num_head_channels
-        self.use_checkpoint = use_checkpoint
-        self.norm = normalization(channels)
-        self.qkv = conv_nd(1, channels, channels * 3, 1)
-        if use_new_attention_order:
-            # split qkv before split heads
-            self.attention = QKVAttention(self.num_heads)
-        else:
-            # split heads before split qkv
-            self.attention = QKVAttentionLegacy(self.num_heads)
-
-        self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
-
-    def forward(self, x):
-        return checkpoint(self._forward, (x,), self.parameters(), True)   # TODO: check checkpoint usage, is True # TODO: fix the .half call!!!
-        #return pt_checkpoint(self._forward, x)  # pytorch
-
-    def _forward(self, x):
-        b, c, *spatial = x.shape
-        x = x.reshape(b, c, -1)
-        qkv = self.qkv(self.norm(x))
-        h = self.attention(qkv)
-        h = self.proj_out(h)
-        return (x + h).reshape(b, c, *spatial)
-
-
-def count_flops_attn(model, _x, y):
-    """
-    A counter for the `thop` package to count the operations in an
-    attention operation.
-    Meant to be used like:
-        macs, params = thop.profile(
-            model,
-            inputs=(inputs, timestamps),
-            custom_ops={QKVAttention: QKVAttention.count_flops},
-        )
-    """
-    b, c, *spatial = y[0].shape
-    num_spatial = int(np.prod(spatial))
-    # We perform two matmuls with the same number of ops.
-    # The first computes the weight matrix, the second computes
-    # the combination of the value vectors.
-    matmul_ops = 2 * b * (num_spatial ** 2) * c
-    model.total_ops += th.DoubleTensor([matmul_ops])
-
-
-class QKVAttentionLegacy(nn.Module):
-    """
-    A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-        :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts", q * scale, k * scale
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v)
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class QKVAttention(nn.Module):
-    """
-    A module which performs QKV attention and splits in a different order.
-    """
-
-    def __init__(self, n_heads):
-        super().__init__()
-        self.n_heads = n_heads
-
-    def forward(self, qkv):
-        """
-        Apply QKV attention.
-        :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
-        :return: an [N x (H * C) x T] tensor after attention.
-        """
-        bs, width, length = qkv.shape
-        assert width % (3 * self.n_heads) == 0
-        ch = width // (3 * self.n_heads)
-        q, k, v = qkv.chunk(3, dim=1)
-        scale = 1 / math.sqrt(math.sqrt(ch))
-        weight = th.einsum(
-            "bct,bcs->bts",
-            (q * scale).view(bs * self.n_heads, ch, length),
-            (k * scale).view(bs * self.n_heads, ch, length),
-        )  # More stable with f16 than dividing afterwards
-        weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
-        a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
-        return a.reshape(bs, -1, length)
-
-    @staticmethod
-    def count_flops(model, _x, y):
-        return count_flops_attn(model, _x, y)
-
-
-class UNetModel(nn.Module):
-    """
-    The full UNet model with attention and timestep embedding.
-    :param in_channels: channels in the input Tensor.
-    :param model_channels: base channel count for the model.
-    :param out_channels: channels in the output Tensor.
-    :param num_res_blocks: number of residual blocks per downsample.
-    :param attention_resolutions: a collection of downsample rates at which
-        attention will take place. May be a set, list, or tuple.
-        For example, if this contains 4, then at 4x downsampling, attention
-        will be used.
-    :param dropout: the dropout probability.
-    :param channel_mult: channel multiplier for each level of the UNet.
-    :param conv_resample: if True, use learned convolutions for upsampling and
-        downsampling.
-    :param dims: determines if the signal is 1D, 2D, or 3D.
-    :param num_classes: if specified (as an int), then this model will be
-        class-conditional with `num_classes` classes.
-    :param use_checkpoint: use gradient checkpointing to reduce memory usage.
-    :param num_heads: the number of attention heads in each attention layer.
-    :param num_heads_channels: if specified, ignore num_heads and instead use
-                               a fixed channel width per attention head.
-    :param num_heads_upsample: works with num_heads to set a different number
-                               of heads for upsampling. Deprecated.
-    :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
-    :param resblock_updown: use residual blocks for up/downsampling.
-    :param use_new_attention_order: use a different attention pattern for potentially
-                                    increased efficiency.
-    """
-
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        num_classes=None,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=-1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        use_spatial_transformer=False,    # custom transformer support
-        transformer_depth=1,              # custom transformer support
-        context_dim=None,                 # custom transformer support
-        n_embed=None,                     # custom support for prediction of discrete ids into codebook of first stage vq model
-        legacy=True,
-    ):
-        super().__init__()
-        if use_spatial_transformer:
-            assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'
-
-        if context_dim is not None:
-            assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'
-            from omegaconf.listconfig import ListConfig
-            if type(context_dim) == ListConfig:
-                context_dim = list(context_dim)
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        if num_heads == -1:
-            assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
-
-        if num_head_channels == -1:
-            assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
-
-        self.image_size = image_size
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.num_classes = num_classes
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-        self.predict_codebook_ids = n_embed is not None
-
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-
-        if self.num_classes is not None:
-            self.label_emb = nn.Embedding(num_classes, time_embed_dim)
-
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)# conv2d for txt2img/audio
-                )
-            ]
-        )
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-        # downsample blocks
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    if legacy:
-                        #num_heads = 1
-                        dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=dim_head,
-                            use_new_attention_order=use_new_attention_order,
-                        ) if not use_spatial_transformer else SpatialTransformer(# transformer_depth is 1
-                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
-                        )
-                    )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-
-        if num_head_channels == -1:
-            dim_head = ch // num_heads
-        else:
-            num_heads = ch // num_head_channels
-            dim_head = num_head_channels
-        if legacy:
-            #num_heads = 1
-            dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=dim_head,
-                use_new_attention_order=use_new_attention_order,
-            ) if not use_spatial_transformer else SpatialTransformer(
-                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
-                        ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-        )
-        self._feature_size += ch
-        # upsample blocks
-        self.output_blocks = nn.ModuleList([])
-        for level, mult in list(enumerate(channel_mult))[::-1]:
-            for i in range(num_res_blocks + 1):
-                ich = input_block_chans.pop()
-                layers = [
-                    ResBlock(
-                        ch + ich,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=model_channels * mult,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = model_channels * mult
-                if ds in attention_resolutions:
-                    if num_head_channels == -1:
-                        dim_head = ch // num_heads
-                    else:
-                        num_heads = ch // num_head_channels
-                        dim_head = num_head_channels
-                    if legacy:
-                        #num_heads = 1
-                        dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads_upsample,
-                            num_head_channels=dim_head,
-                            use_new_attention_order=use_new_attention_order,
-                        ) if not use_spatial_transformer else SpatialTransformer(
-                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
-                        )
-                    )
-                if level and i == num_res_blocks:
-                    out_ch = ch
-                    layers.append(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            up=True,
-                        )
-                        if resblock_updown
-                        else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch)
-                    )
-                    ds //= 2
-                self.output_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-
-        self.out = nn.Sequential(
-            normalization(ch),
-            nn.SiLU(),
-            zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)),
-        )
-        if self.predict_codebook_ids:
-            self.id_predictor = nn.Sequential(
-            normalization(ch),
-            conv_nd(dims, model_channels, n_embed, 1),
-            #nn.LogSoftmax(dim=1)  # change to cross_entropy and produce non-normalized logits
-        )
-
-    def convert_to_fp16(self):
-        """
-        Convert the torso of the model to float16.
-        """
-        self.input_blocks.apply(convert_module_to_f16)
-        self.middle_block.apply(convert_module_to_f16)
-        self.output_blocks.apply(convert_module_to_f16)
-
-    def convert_to_fp32(self):
-        """
-        Convert the torso of the model to float32.
-        """
-        self.input_blocks.apply(convert_module_to_f32)
-        self.middle_block.apply(convert_module_to_f32)
-        self.output_blocks.apply(convert_module_to_f32)
-
-    def forward(self, x, timesteps=None, context=None, y=None,**kwargs):
-        """
-        Apply the model to an input batch.
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps,shape [N]
-        :param context: conditioning plugged in via crossattn. for txt2img shape is [N,77,context_dim]
-        :param y: an [N] Tensor of labels, if class-conditional.
-        :return: an [N x C x ...] Tensor of outputs.
-        """
-        # print(f"in unet {x.shape}")
-        assert (y is not None) == (
-            self.num_classes is not None
-        ), "must specify y if and only if the model is class-conditional"
-        hs = []
-        t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False)# shape [N,self.model_channels]
-        emb = self.time_embed(t_emb)# shape [N,context_dim]
-
-        if self.num_classes is not None:# only for class label
-            assert y.shape == (x.shape[0],)
-            emb = emb + self.label_emb(y)
-
-        h = x.type(self.dtype)# [N,C,10,106]
-        for module in self.input_blocks:
-            h = module(h, emb, context)# 0:[N,self.model_channels,10,106],1:[N,self.model_channels,10,106],2:[N,self.model_channels,10,106] 3:[N,self.model_channels,5,53] 4:[N,self.model_channels,5,53] 5:[N,self.model_channels*2,5,53]
-            hs.append(h)
-        h = self.middle_block(h, emb, context)# no shape change
-        for module in self.output_blocks:
-            h = th.cat([h, hs.pop()], dim=1)# 在这里c维度乘2或+self.model_channels，其余维度不变
-            h = module(h, emb, context)# 在这里c维度/2回到之前维度，h,w不变或*2
-        h = h.type(x.dtype)# 至此h维度和输入x维度回到相同状态
-        if self.predict_codebook_ids:
-            return self.id_predictor(h)
-        else:
-            return self.out(h)
-
-
-class EncoderUNetModel(nn.Module):
-    """
-    The half UNet model with attention and timestep embedding.
-    For usage, see UNet.
-    """
-
-    def __init__(
-        self,
-        image_size,
-        in_channels,
-        model_channels,
-        out_channels,
-        num_res_blocks,
-        attention_resolutions,
-        dropout=0,
-        channel_mult=(1, 2, 4, 8),
-        conv_resample=True,
-        dims=2,
-        use_checkpoint=False,
-        use_fp16=False,
-        num_heads=1,
-        num_head_channels=-1,
-        num_heads_upsample=-1,
-        use_scale_shift_norm=False,
-        resblock_updown=False,
-        use_new_attention_order=False,
-        pool="adaptive",
-        *args,
-        **kwargs
-    ):
-        super().__init__()
-
-        if num_heads_upsample == -1:
-            num_heads_upsample = num_heads
-
-        self.in_channels = in_channels
-        self.model_channels = model_channels
-        self.out_channels = out_channels
-        self.num_res_blocks = num_res_blocks
-        self.attention_resolutions = attention_resolutions
-        self.dropout = dropout
-        self.channel_mult = channel_mult
-        self.conv_resample = conv_resample
-        self.use_checkpoint = use_checkpoint
-        self.dtype = th.float16 if use_fp16 else th.float32
-        self.num_heads = num_heads
-        self.num_head_channels = num_head_channels
-        self.num_heads_upsample = num_heads_upsample
-
-        time_embed_dim = model_channels * 4
-        self.time_embed = nn.Sequential(
-            linear(model_channels, time_embed_dim),
-            nn.SiLU(),
-            linear(time_embed_dim, time_embed_dim),
-        )
-
-        self.input_blocks = nn.ModuleList(
-            [
-                TimestepEmbedSequential(
-                    conv_nd(dims, in_channels, model_channels, 3, padding=1)
-                )
-            ]
-        )
-        self._feature_size = model_channels
-        input_block_chans = [model_channels]
-        ch = model_channels
-        ds = 1
-        for level, mult in enumerate(channel_mult):
-            for _ in range(num_res_blocks):
-                layers = [
-                    ResBlock(
-                        ch,
-                        time_embed_dim,
-                        dropout,
-                        out_channels=mult * model_channels,
-                        dims=dims,
-                        use_checkpoint=use_checkpoint,
-                        use_scale_shift_norm=use_scale_shift_norm,
-                    )
-                ]
-                ch = mult * model_channels
-                if ds in attention_resolutions:
-                    layers.append(
-                        AttentionBlock(
-                            ch,
-                            use_checkpoint=use_checkpoint,
-                            num_heads=num_heads,
-                            num_head_channels=num_head_channels,
-                            use_new_attention_order=use_new_attention_order,
-                        )
-                    )
-                self.input_blocks.append(TimestepEmbedSequential(*layers))
-                self._feature_size += ch
-                input_block_chans.append(ch)
-            if level != len(channel_mult) - 1:
-                out_ch = ch
-                self.input_blocks.append(
-                    TimestepEmbedSequential(
-                        ResBlock(
-                            ch,
-                            time_embed_dim,
-                            dropout,
-                            out_channels=out_ch,
-                            dims=dims,
-                            use_checkpoint=use_checkpoint,
-                            use_scale_shift_norm=use_scale_shift_norm,
-                            down=True,
-                        )
-                        if resblock_updown
-                        else Downsample(
-                            ch, conv_resample, dims=dims, out_channels=out_ch
-                        )
-                    )
-                )
-                ch = out_ch
-                input_block_chans.append(ch)
-                ds *= 2
-                self._feature_size += ch
-
-        self.middle_block = TimestepEmbedSequential(
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-            AttentionBlock(
-                ch,
-                use_checkpoint=use_checkpoint,
-                num_heads=num_heads,
-                num_head_channels=num_head_channels,
-                use_new_attention_order=use_new_attention_order,
-            ),
-            ResBlock(
-                ch,
-                time_embed_dim,
-                dropout,
-                dims=dims,
-                use_checkpoint=use_checkpoint,
-                use_scale_shift_norm=use_scale_shift_norm,
-            ),
-        )
-        self._feature_size += ch
-        self.pool = pool
-        if pool == "adaptive":
-            self.out = nn.Sequential(
-                normalization(ch),
-                nn.SiLU(),
-                nn.AdaptiveAvgPool2d((1, 1)),
-                zero_module(conv_nd(dims, ch, out_channels, 1)),
-                nn.Flatten(),
-            )
-        elif pool == "attention":
-            assert num_head_channels != -1
-            self.out = nn.Sequential(
-                normalization(ch),
-                nn.SiLU(),
-                AttentionPool2d(
-                    (image_size // ds), ch, num_head_channels, out_channels
-                ),
-            )
-        elif pool == "spatial":
-            self.out = nn.Sequential(
-                nn.Linear(self._feature_size, 2048),
-                nn.ReLU(),
-                nn.Linear(2048, self.out_channels),
-            )
-        elif pool == "spatial_v2":
-            self.out = nn.Sequential(
-                nn.Linear(self._feature_size, 2048),
-                normalization(2048),
-                nn.SiLU(),
-                nn.Linear(2048, self.out_channels),
-            )
-        else:
-            raise NotImplementedError(f"Unexpected {pool} pooling")
-
-    def convert_to_fp16(self):
-        """
-        Convert the torso of the model to float16.
-        """
-        self.input_blocks.apply(convert_module_to_f16)
-        self.middle_block.apply(convert_module_to_f16)
-
-    def convert_to_fp32(self):
-        """
-        Convert the torso of the model to float32.
-        """
-        self.input_blocks.apply(convert_module_to_f32)
-        self.middle_block.apply(convert_module_to_f32)
-
-    def forward(self, x, timesteps):
-        """
-        Apply the model to an input batch.
-        :param x: an [N x C x ...] Tensor of inputs.
-        :param timesteps: a 1-D batch of timesteps.
-        :return: an [N x K] Tensor of outputs.
-        """
-        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
-
-        results = []
-        h = x.type(self.dtype)
-        for module in self.input_blocks:
-            h = module(h, emb)
-            if self.pool.startswith("spatial"):
-                results.append(h.type(x.dtype).mean(dim=(2, 3)))
-        h = self.middle_block(h, emb)
-        if self.pool.startswith("spatial"):
-            results.append(h.type(x.dtype).mean(dim=(2, 3)))
-            h = th.cat(results, axis=-1)
-            return self.out(h)
-        else:
-            h = h.type(x.dtype)
-            return self.out(h)
-

spaces/Abubakari/Sepsis-prediction-streamlit-app/README.md

@@ -1,12 +0,0 @@
----
-title: Sepsis Prediction Streamlit App
-emoji: 😻
-colorFrom: pink
-colorTo: green
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

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

@@ -1,22 +0,0 @@
-import type * as Kit from '@sveltejs/kit';
-
-type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
-type RouteParams = {  }
-type RouteId = '/login/callback';
-type MaybeWithVoid<T> = {} extends T ? T | void : T;
-export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];
-type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>
-type EnsureDefined<T> = T extends null | undefined ? {} : T;
-type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;
-export type Snapshot<T = any> = Kit.Snapshot<T>;
-type PageServerParentData = EnsureDefined<import('../../$types.js').LayoutServerData>;
-type PageParentData = EnsureDefined<import('../../$types.js').LayoutData>;
-
-export type PageServerLoad<OutputData extends OutputDataShape<PageServerParentData> = OutputDataShape<PageServerParentData>> = Kit.ServerLoad<RouteParams, PageServerParentData, OutputData, RouteId>;
-export type PageServerLoadEvent = Parameters<PageServerLoad>[0];
-export type ActionData = unknown;
-export type PageServerData = Expand<OptionalUnion<EnsureDefined<Kit.AwaitedProperties<Awaited<ReturnType<typeof import('../../../../../../src/routes/login/callback/+page.server.js').load>>>>>>;
-export type PageData = Expand<Omit<PageParentData, keyof PageServerData> & EnsureDefined<PageServerData>>;
-export type Action<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Action<RouteParams, OutputData, RouteId>
-export type Actions<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Actions<RouteParams, OutputData, RouteId>
-export type RequestEvent = Kit.RequestEvent<RouteParams, RouteId>;

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

@@ -1,23 +0,0 @@
-import Factory from './gameobjects/shape/cover/Factory.js';
-import Creator from './gameobjects/shape/cover/Creator.js';
-import Cover from './gameobjects/shape/cover/Cover.js';
-import SetValue from './utils/object/SetValue.js';
-
-class CoverPlugin extends Phaser.Plugins.BasePlugin {
-
-    constructor(pluginManager) {
-        super(pluginManager);
-
-        //  Register our new Game Object type
-        pluginManager.registerGameObject('rexCover', Factory, Creator);
-    }
-
-    start() {
-        var eventEmitter = this.game.events;
-        eventEmitter.on('destroy', this.destroy, this);
-    }
-}
-
-SetValue(window, 'RexPlugins.GameObjects.Cover', Cover);
-
-export default CoverPlugin;

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

@@ -1,176 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""2D convolution with optional up/downsampling."""
-
-import torch
-
-from .. import misc
-from . import conv2d_gradfix
-from . import upfirdn2d
-from .upfirdn2d import _parse_padding
-from .upfirdn2d import _get_filter_size
-
-# ----------------------------------------------------------------------------
-
-
-def _get_weight_shape(w):
-    with misc.suppress_tracer_warnings():  # this value will be treated as a constant
-        shape = [int(sz) for sz in w.shape]
-    misc.assert_shape(w, shape)
-    return shape
-
-# ----------------------------------------------------------------------------
-
-
-def _conv2d_wrapper(x, w, stride=1, padding=0, groups=1, transpose=False, flip_weight=True):
-    """Wrapper for the underlying `conv2d()` and `conv_transpose2d()` implementations.
-    """
-    out_channels, in_channels_per_group, kh, kw = _get_weight_shape(w)
-
-    # Flip weight if requested.
-    # conv2d() actually performs correlation (flip_weight=True) not convolution (flip_weight=False).
-    if not flip_weight:
-        w = w.flip([2, 3])
-
-    # Workaround performance pitfall in cuDNN 8.0.5, triggered when using
-    # 1x1 kernel + memory_format=channels_last + less than 64 channels.
-    if kw == 1 and kh == 1 and stride == 1 and padding in [0, [0, 0], (0, 0)] and not transpose:
-        if x.stride()[1] == 1 and min(out_channels, in_channels_per_group) < 64:
-            if out_channels <= 4 and groups == 1:
-                in_shape = x.shape
-                x = w.squeeze(3).squeeze(
-                    2) @ x.reshape([in_shape[0], in_channels_per_group, -1])
-                x = x.reshape([in_shape[0], out_channels,
-                              in_shape[2], in_shape[3]])
-            else:
-                x = x.to(memory_format=torch.contiguous_format)
-                w = w.to(memory_format=torch.contiguous_format)
-                x = conv2d_gradfix.conv2d(x, w, groups=groups)
-            return x.to(memory_format=torch.channels_last)
-
-    # Otherwise => execute using conv2d_gradfix.
-    op = conv2d_gradfix.conv_transpose2d if transpose else conv2d_gradfix.conv2d
-    return op(x, w, stride=stride, padding=padding, groups=groups)
-
-# ----------------------------------------------------------------------------
-
-
-@misc.profiled_function
-def conv2d_resample(x, w, f=None, up=1, down=1, padding=0, groups=1, flip_weight=True, flip_filter=False):
-    r"""2D convolution with optional up/downsampling.
-
-    Padding is performed only once at the beginning, not between the operations.
-
-    Args:
-        x:              Input tensor of shape
-                        `[batch_size, in_channels, in_height, in_width]`.
-        w:              Weight tensor of shape
-                        `[out_channels, in_channels//groups, kernel_height, kernel_width]`.
-        f:              Low-pass filter for up/downsampling. Must be prepared beforehand by
-                        calling upfirdn2d.setup_filter(). None = identity (default).
-        up:             Integer upsampling factor (default: 1).
-        down:           Integer downsampling factor (default: 1).
-        padding:        Padding with respect to the upsampled image. Can be a single number
-                        or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]`
-                        (default: 0).
-        groups:         Split input channels into N groups (default: 1).
-        flip_weight:    False = convolution, True = correlation (default: True).
-        flip_filter:    False = convolution, True = correlation (default: False).
-
-    Returns:
-        Tensor of the shape `[batch_size, num_channels, out_height, out_width]`.
-    """
-    # Validate arguments.
-    assert isinstance(x, torch.Tensor) and (x.ndim == 4)
-    assert isinstance(w, torch.Tensor) and (
-        w.ndim == 4) and (w.dtype == x.dtype)
-    assert f is None or (isinstance(f, torch.Tensor) and f.ndim in [
-                         1, 2] and f.dtype == torch.float32)
-    assert isinstance(up, int) and (up >= 1)
-    assert isinstance(down, int) and (down >= 1)
-    assert isinstance(groups, int) and (groups >= 1)
-    out_channels, in_channels_per_group, kh, kw = _get_weight_shape(w)
-    fw, fh = _get_filter_size(f)
-    px0, px1, py0, py1 = _parse_padding(padding)
-
-    # Adjust padding to account for up/downsampling.
-    if up > 1:
-        px0 += (fw + up - 1) // 2
-        px1 += (fw - up) // 2
-        py0 += (fh + up - 1) // 2
-        py1 += (fh - up) // 2
-    if down > 1:
-        px0 += (fw - down + 1) // 2
-        px1 += (fw - down) // 2
-        py0 += (fh - down + 1) // 2
-        py1 += (fh - down) // 2
-
-    # Fast path: 1x1 convolution with downsampling only => downsample first, then convolve.
-    if kw == 1 and kh == 1 and (down > 1 and up == 1):
-        x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, padding=[
-                                px0, px1, py0, py1], flip_filter=flip_filter)
-        x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight)
-        return x
-
-    # Fast path: 1x1 convolution with upsampling only => convolve first, then upsample.
-    if kw == 1 and kh == 1 and (up > 1 and down == 1):
-        x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight)
-        x = upfirdn2d.upfirdn2d(x=x, f=f, up=up, padding=[
-                                px0, px1, py0, py1], gain=up**2, flip_filter=flip_filter)
-        return x
-
-    # Fast path: downsampling only => use strided convolution.
-    if down > 1 and up == 1:
-        x = upfirdn2d.upfirdn2d(
-            x=x, f=f, padding=[px0, px1, py0, py1], flip_filter=flip_filter)
-        x = _conv2d_wrapper(x=x, w=w, stride=down,
-                            groups=groups, flip_weight=flip_weight)
-        return x
-
-    # Fast path: upsampling with optional downsampling => use transpose strided convolution.
-    if up > 1:
-        if groups == 1:
-            w = w.transpose(0, 1)
-        else:
-            w = w.reshape(groups, out_channels // groups,
-                          in_channels_per_group, kh, kw)
-            w = w.transpose(1, 2)
-            w = w.reshape(groups * in_channels_per_group,
-                          out_channels // groups, kh, kw)
-        px0 -= kw - 1
-        px1 -= kw - up
-        py0 -= kh - 1
-        py1 -= kh - up
-        pxt = max(min(-px0, -px1), 0)
-        pyt = max(min(-py0, -py1), 0)
-        x = _conv2d_wrapper(x=x, w=w, stride=up, padding=[
-                            pyt, pxt], groups=groups, transpose=True, flip_weight=(not flip_weight))
-        x = upfirdn2d.upfirdn2d(x=x, f=f, padding=[
-                                px0+pxt, px1+pxt, py0+pyt, py1+pyt], gain=up**2, flip_filter=flip_filter)
-        if down > 1:
-            x = upfirdn2d.upfirdn2d(
-                x=x, f=f, down=down, flip_filter=flip_filter)
-        return x
-
-    # Fast path: no up/downsampling, padding supported by the underlying implementation => use plain conv2d.
-    if up == 1 and down == 1:
-        if px0 == px1 and py0 == py1 and px0 >= 0 and py0 >= 0:
-            return _conv2d_wrapper(x=x, w=w, padding=[py0, px0], groups=groups, flip_weight=flip_weight)
-
-    # Fallback: Generic reference implementation.
-    x = upfirdn2d.upfirdn2d(x=x, f=(f if up > 1 else None), up=up, padding=[
-                            px0, px1, py0, py1], gain=up**2, flip_filter=flip_filter)
-    x = _conv2d_wrapper(x=x, w=w, groups=groups, flip_weight=flip_weight)
-    if down > 1:
-        x = upfirdn2d.upfirdn2d(x=x, f=f, down=down, flip_filter=flip_filter)
-    return x
-
-# ----------------------------------------------------------------------------

spaces/An-619/FastSAM/README.md

@@ -1,46 +0,0 @@
----
-title: FastSAM
-emoji: 🐠
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.45.1
-app_file: app_gradio.py
-pinned: false
-license: apache-2.0
----
-
-# Fast Segment Anything
-
-Official PyTorch Implementation of the <a href="https://github.com/CASIA-IVA-Lab/FastSAM">.
-
-The **Fast Segment Anything Model(FastSAM)** is a CNN Segment Anything Model trained by only 2% of the SA-1B dataset published by SAM authors. The FastSAM achieve a comparable performance with
-the SAM method at **50× higher run-time speed**.
-
-
-## License
-
-The model is licensed under the [Apache 2.0 license](LICENSE).
-
-
-## Acknowledgement
-
-- [Segment Anything](https://segment-anything.com/) provides the SA-1B dataset and the base codes.
-- [YOLOv8](https://github.com/ultralytics/ultralytics) provides codes and pre-trained models.
-- [YOLACT](https://arxiv.org/abs/2112.10003) provides powerful instance segmentation method.
-- [Grounded-Segment-Anything](https://huggingface.co/spaces/yizhangliu/Grounded-Segment-Anything) provides a useful web demo template.
-
-## Citing FastSAM
-
-If you find this project useful for your research, please consider citing the following BibTeX entry.
-
-```
-@misc{zhao2023fast,
-      title={Fast Segment Anything}, 
-      author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
-      year={2023},
-      eprint={2306.12156},
-      archivePrefix={arXiv},
-      primaryClass={cs.CV}
-}
-```

spaces/AnTo2209/3D_Zeroshot_Neural_Style_Transfer/src/model/styleRF.py

@@ -1,95 +0,0 @@
-import os
-from datetime import datetime
-
-import pytorch_lightning as pl
-# from torch.utils.tensorboard import SummaryWriter
-import torch
-
-from src.decoder import DECODER_REGISTRY
-from src.utils.loss import TVLoss
-
-class StyleRF(pl.LightningModule):
-    def __init__(self, cfg):
-        super().__init__()
-        self.cfg = cfg
-        self.init_model()
-
-    def init_model(self):
-        logfolder = f'{self.cfg["global"]["base_dir"]}/{self.cfg["global"]["expname"]}{datetime.now().strftime("-%Y%m%d-%H%M%S")}'
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        # init log file
-        os.makedirs(logfolder, exist_ok=True)
-        # summary_writer = SummaryWriter(logfolder)
-
-        # init parameters
-        assert self.cfg["model"]["tensorf"]["ckpt"] is not None, 'Have to be pre-trained to get density fielded!'
-        type = self.cfg["model"]["type"]
-        ckpt = torch.load(self.cfg["model"]["tensorf"]["ckpt"], map_location=device)
-        kwargs = ckpt['kwargs']
-        kwargs.update({'device': device})
-        self.ndc_ray = self.cfg["model"]["tensorf"]["ndc_ray"]
-
-        if type == "feature":
-            self.tensorf = DECODER_REGISTRY.get(self.cfg["model"]["tensorf"]["model_name"])(**kwargs)
-            self.tensorf.load(ckpt)
-            self.tensorf.change_to_feature_mod(self.cfg["model"]["tensorf"]["lamb_sh"], device)
-        elif type == "style":
-            self.tensorf = DECODER_REGISTRY.get(self.cfg["model"]["tensorf"]["model_name"])(**kwargs)
-            self.tensorf.change_to_feature_mod(self.cfg["model"]["tensorf"]["lamb_sh"], device)
-            self.tensorf.load(ckpt)
-            self.tensorf.change_to_style_mod(device)
-
-        self.tensorf.rayMarch_weight_thres = self.cfg["model"]["tensorf"]["rm_weight_mask_thre"]
-
-        TV_weight_feature = self.cfg["model"]["tensorf"]["TV_weight_feature"]
-        self.tvreg = TVLoss()
-        print(f"initial TV_weight_feature: {TV_weight_feature}")
-
-    def forward(self, batch):
-        pass
-
-    def training_step(self, batch, batch_idx):
-        pass
-        # # 2. Calculate loss
-        # loss = self.compute_loss(forwarded_batch=forwarded_batch, input_batch=batch)
-        # # 3. Update monitor
-        # self.log("train_loss", loss, on_step=True, on_epoch=True, prog_bar=True)
-        # return {"loss": loss}
-
-    # def validation_step(self, batch, batch_idx):
-    #     # 1. Get embeddings from model
-    #     forwarded_batch = self.forward(batch)
-    #     # 2. Calculate loss
-    #     loss = self.compute_loss(forwarded_batch=forwarded_batch, input_batch=batch)
-    #     # 3. Update metric for each batch
-    #     self.log("val_loss", loss, on_step=True, on_epoch=True, prog_bar=True)
-    #     self.metric_evaluator.append(
-    #         g_emb=forwarded_batch["pc_embedding_feats"].float().clone().detach(),
-    #         q_emb=forwarded_batch["query_embedding_feats"].float().clone().detach(),
-    #         query_ids=batch["query_ids"],
-    #         gallery_ids=batch["point_cloud_ids"],
-    #         target_ids=batch["point_cloud_ids"],
-    #     )
-    #
-    #     return {"loss": loss}
-    #
-    # def validation_epoch_end(self, outputs) -> None:
-    #     """
-    #     Callback at validation epoch end to do additional works
-    #     with output of validation step, note that this is called
-    #     before `training_epoch_end()`
-    #     Args:
-    #         outputs: output of validation step
-    #     """
-    #     self.log_dict(
-    #         self.metric_evaluator.evaluate(),
-    #         prog_bar=True,
-    #         on_step=False,
-    #         on_epoch=True,
-    #     )
-    #     self.metric_evaluator.reset()
-
-
-
-
-

spaces/Andy1621/uniformer_image_detection/configs/paa/paa_r101_fpn_mstrain_3x_coco.py

@@ -1,2 +0,0 @@
-_base_ = './paa_r50_fpn_mstrain_3x_coco.py'
-model = dict(pretrained='torchvision://resnet101', backbone=dict(depth=101))

spaces/Andy1621/uniformer_image_detection/mmdet/models/utils/positional_encoding.py

@@ -1,150 +0,0 @@
-import math
-
-import torch
-import torch.nn as nn
-from mmcv.cnn import uniform_init
-
-from .builder import POSITIONAL_ENCODING
-
-
-@POSITIONAL_ENCODING.register_module()
-class SinePositionalEncoding(nn.Module):
-    """Position encoding with sine and cosine functions.
-
-    See `End-to-End Object Detection with Transformers
-    <https://arxiv.org/pdf/2005.12872>`_ for details.
-
-    Args:
-        num_feats (int): The feature dimension for each position
-            along x-axis or y-axis. Note the final returned dimension
-            for each position is 2 times of this value.
-        temperature (int, optional): The temperature used for scaling
-            the position embedding. Default 10000.
-        normalize (bool, optional): Whether to normalize the position
-            embedding. Default False.
-        scale (float, optional): A scale factor that scales the position
-            embedding. The scale will be used only when `normalize` is True.
-            Default 2*pi.
-        eps (float, optional): A value added to the denominator for
-            numerical stability. Default 1e-6.
-    """
-
-    def __init__(self,
-                 num_feats,
-                 temperature=10000,
-                 normalize=False,
-                 scale=2 * math.pi,
-                 eps=1e-6):
-        super(SinePositionalEncoding, self).__init__()
-        if normalize:
-            assert isinstance(scale, (float, int)), 'when normalize is set,' \
-                'scale should be provided and in float or int type, ' \
-                f'found {type(scale)}'
-        self.num_feats = num_feats
-        self.temperature = temperature
-        self.normalize = normalize
-        self.scale = scale
-        self.eps = eps
-
-    def forward(self, mask):
-        """Forward function for `SinePositionalEncoding`.
-
-        Args:
-            mask (Tensor): ByteTensor mask. Non-zero values representing
-                ignored positions, while zero values means valid positions
-                for this image. Shape [bs, h, w].
-
-        Returns:
-            pos (Tensor): Returned position embedding with shape
-                [bs, num_feats*2, h, w].
-        """
-        not_mask = ~mask
-        y_embed = not_mask.cumsum(1, dtype=torch.float32)
-        x_embed = not_mask.cumsum(2, dtype=torch.float32)
-        if self.normalize:
-            y_embed = y_embed / (y_embed[:, -1:, :] + self.eps) * self.scale
-            x_embed = x_embed / (x_embed[:, :, -1:] + self.eps) * self.scale
-        dim_t = torch.arange(
-            self.num_feats, dtype=torch.float32, device=mask.device)
-        dim_t = self.temperature**(2 * (dim_t // 2) / self.num_feats)
-        pos_x = x_embed[:, :, :, None] / dim_t
-        pos_y = y_embed[:, :, :, None] / dim_t
-        pos_x = torch.stack(
-            (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()),
-            dim=4).flatten(3)
-        pos_y = torch.stack(
-            (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()),
-            dim=4).flatten(3)
-        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
-        return pos
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(num_feats={self.num_feats}, '
-        repr_str += f'temperature={self.temperature}, '
-        repr_str += f'normalize={self.normalize}, '
-        repr_str += f'scale={self.scale}, '
-        repr_str += f'eps={self.eps})'
-        return repr_str
-
-
-@POSITIONAL_ENCODING.register_module()
-class LearnedPositionalEncoding(nn.Module):
-    """Position embedding with learnable embedding weights.
-
-    Args:
-        num_feats (int): The feature dimension for each position
-            along x-axis or y-axis. The final returned dimension for
-            each position is 2 times of this value.
-        row_num_embed (int, optional): The dictionary size of row embeddings.
-            Default 50.
-        col_num_embed (int, optional): The dictionary size of col embeddings.
-            Default 50.
-    """
-
-    def __init__(self, num_feats, row_num_embed=50, col_num_embed=50):
-        super(LearnedPositionalEncoding, self).__init__()
-        self.row_embed = nn.Embedding(row_num_embed, num_feats)
-        self.col_embed = nn.Embedding(col_num_embed, num_feats)
-        self.num_feats = num_feats
-        self.row_num_embed = row_num_embed
-        self.col_num_embed = col_num_embed
-        self.init_weights()
-
-    def init_weights(self):
-        """Initialize the learnable weights."""
-        uniform_init(self.row_embed)
-        uniform_init(self.col_embed)
-
-    def forward(self, mask):
-        """Forward function for `LearnedPositionalEncoding`.
-
-        Args:
-            mask (Tensor): ByteTensor mask. Non-zero values representing
-                ignored positions, while zero values means valid positions
-                for this image. Shape [bs, h, w].
-
-        Returns:
-            pos (Tensor): Returned position embedding with shape
-                [bs, num_feats*2, h, w].
-        """
-        h, w = mask.shape[-2:]
-        x = torch.arange(w, device=mask.device)
-        y = torch.arange(h, device=mask.device)
-        x_embed = self.col_embed(x)
-        y_embed = self.row_embed(y)
-        pos = torch.cat(
-            (x_embed.unsqueeze(0).repeat(h, 1, 1), y_embed.unsqueeze(1).repeat(
-                1, w, 1)),
-            dim=-1).permute(2, 0,
-                            1).unsqueeze(0).repeat(mask.shape[0], 1, 1, 1)
-        return pos
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(num_feats={self.num_feats}, '
-        repr_str += f'row_num_embed={self.row_num_embed}, '
-        repr_str += f'col_num_embed={self.col_num_embed})'
-        return repr_str

spaces/Anni123/AuRoRA/llm_utils.py

@@ -1,78 +0,0 @@
-import time
-import openai
-
-#openai.api_key = "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"
-
-
-# Sentence Generator (Decoder) for GPT-3 ...
-def decoder_for_gpt3(input, max_length, temperature=0, engine="text-davinci-003"):
-    # GPT-3 API allows each users execute the API within 60 times in a minute ...
-    if engine == "gpt-3.5-turbo":
-        time.sleep(1)
-        response  = openai.ChatCompletion.create(
-            model=engine,
-            messages=[
-                #{"role": "system", "content": "You need to answer commonsense questions."},
-                {"role": "user", "content": input}
-            ],
-            max_tokens=max_length,
-            temperature=temperature,
-            stop=None
-        )
-        response = response["choices"][0]["message"]["content"]
-
-    else:
-        time.sleep(1)
-        response = openai.Completion.create(
-            model=engine,
-            prompt=input,
-            max_tokens=max_length,
-            stop=None,
-            temperature=temperature
-        )
-        response = response["choices"][0]["text"]
-    return response
-
-def decoder_for_gpt3_consistency(input, max_length, temp=0.7, n=5, engine="text-davinci-003"):
-    # GPT-3 API allows each users execute the API within 60 times in a minute ...
-    if engine == "gpt-3.5-turbo":
-        time.sleep(1)
-        responses = openai.ChatCompletion.create(
-            model=engine,
-            messages=[
-                {"role": "user", "content": input}
-            ],
-            max_tokens=max_length,
-            temperature=temp,
-            top_p=1,
-            n=5,
-            stop=["\n"],
-        )
-        responses = [responses["choices"][i]["message"]["content"] for i in range(n)]
-    else:
-        time.sleep(1)
-        responses = openai.Completion.create(
-            model=engine,
-            prompt=input,
-            max_tokens=max_length,
-            temperature=temp,
-            stop=["\n"],
-            n=5,
-            logprobs=5,
-            top_p=1,
-        )
-        responses = [responses["choices"][i]["text"] for i in range(n)]
-
-    return responses
-
-def zero_shot(question):
-    input = question + " " + "Among A through E, the answer is"
-    response = openai.ChatCompletion.create(
-        model="gpt-3.5-turbo",
-        messages=[
-            {"role": "system", "content": "You are a helpful assistant that answer commonsense questions."},
-            {"role": "user", "content": input}
-            ]
-        )
-    response = response["choices"][0]["message"]["content"]
-    return response

spaces/AnthonyTruchetPoC/persistent-docker/src/athai/data_utils.py

@@ -1,32 +0,0 @@
-import logging
-import shelve
-from pathlib import Path
-
-import pandas as pd
-
-
-logging.basicConfig(level=logging.INFO)
-
-
-def cached_download_csv(data_path: Path, url: str, **kwargs) -> pd.DataFrame:
-    shelf_filename = data_path.joinpath("shelf.dat").as_posix()
-    try:
-        s = shelve.open(shelf_filename, writeback=True, flag="c")
-    except Exception as exn:
-        logging.exception(
-            "Unexpected exception, while trying to access the shelf"
-        )
-        return pd.read_csv(url, **kwargs)
-    with s as shelf:
-        logging.info(f"Opened or created the shelf file '{shelf_filename}'")
-        maybe_cached = shelf.get(url)
-        if maybe_cached is None:
-            logging.info(f"Downloawding URL '{url}'")
-            df = pd.read_csv(url, **kwargs)
-            shelf[url] = df
-            return df
-        else:
-            logging.info(f"Re-using cached URL '{url}'")
-            assert isinstance(maybe_cached, pd.DataFrame)
-            return maybe_cached
-    # The context manager 'shelf' ensure set value as written back or return

spaces/Arulkumar03/GroundingDINO_SOTA_Zero_Shot_Model/groundingdino/models/GroundingDINO/backbone/__init__.py

@@ -1 +0,0 @@
-from .backbone import build_backbone

spaces/Averyng/averyng/README.md

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

spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/roi_heads/grit_fast_rcnn.py

@@ -1,126 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# Modified by Jialian Wu from https://github.com/facebookresearch/Detic/blob/main/detic/modeling/roi_heads/detic_fast_rcnn.py
-import torch
-from fvcore.nn import giou_loss, smooth_l1_loss
-from torch import nn
-from torch.nn import functional as F
-import fvcore.nn.weight_init as weight_init
-from detectron2.config import configurable
-from detectron2.layers import ShapeSpec, batched_nms, cat, cross_entropy, nonzero_tuple
-from detectron2.modeling.roi_heads.fast_rcnn import FastRCNNOutputLayers
-from detectron2.modeling.roi_heads.fast_rcnn import _log_classification_stats
-
-
-__all__ = ["GRiTFastRCNNOutputLayers"]
-
-
-class GRiTFastRCNNOutputLayers(FastRCNNOutputLayers):
-    @configurable
-    def __init__(
-        self, 
-        input_shape: ShapeSpec,
-        **kwargs,
-    ):
-        super().__init__(
-            input_shape=input_shape, 
-            **kwargs,
-        )
-
-        input_size = input_shape.channels * \
-            (input_shape.width or 1) * (input_shape.height or 1)
-
-        self.bbox_pred = nn.Sequential(
-            nn.Linear(input_size, input_size),
-            nn.ReLU(inplace=True),
-            nn.Linear(input_size, 4)
-        )
-        weight_init.c2_xavier_fill(self.bbox_pred[0])
-        nn.init.normal_(self.bbox_pred[-1].weight, std=0.001)
-        nn.init.constant_(self.bbox_pred[-1].bias, 0)
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        ret = super().from_config(cfg, input_shape)
-        return ret
-
-    def losses(self, predictions, proposals):
-        scores, proposal_deltas = predictions
-        gt_classes = (
-            cat([p.gt_classes for p in proposals], dim=0) if len(proposals) else torch.empty(0)
-        )
-        num_classes = self.num_classes
-        _log_classification_stats(scores, gt_classes)
-
-        if len(proposals):
-            proposal_boxes = cat([p.proposal_boxes.tensor for p in proposals], dim=0)  # Nx4
-            assert not proposal_boxes.requires_grad, "Proposals should not require gradients!"
-            gt_boxes = cat(
-                [(p.gt_boxes if p.has("gt_boxes") else p.proposal_boxes).tensor for p in proposals],
-                dim=0,
-            )
-        else:
-            proposal_boxes = gt_boxes = torch.empty((0, 4), device=proposal_deltas.device)
-
-        loss_cls = self.softmax_cross_entropy_loss(scores, gt_classes)
-        return {
-            "loss_cls": loss_cls, 
-            "loss_box_reg": self.box_reg_loss(
-                proposal_boxes, gt_boxes, proposal_deltas, gt_classes, 
-                num_classes=num_classes)
-        }
-    
-    def softmax_cross_entropy_loss(self, pred_class_logits, gt_classes):
-        if pred_class_logits.numel() == 0:
-            return pred_class_logits.new_zeros([1])[0]
-
-        loss = F.cross_entropy(
-            pred_class_logits, gt_classes, reduction="mean")
-        return loss
-
-    def box_reg_loss(
-        self, proposal_boxes, gt_boxes, pred_deltas, gt_classes, 
-        num_classes=-1):
-        num_classes = num_classes if num_classes > 0 else self.num_classes
-        box_dim = proposal_boxes.shape[1]
-        fg_inds = nonzero_tuple((gt_classes >= 0) & (gt_classes < num_classes))[0]
-        if pred_deltas.shape[1] == box_dim:
-            fg_pred_deltas = pred_deltas[fg_inds]
-        else:
-            fg_pred_deltas = pred_deltas.view(-1, self.num_classes, box_dim)[
-                fg_inds, gt_classes[fg_inds]
-            ]
-
-        if self.box_reg_loss_type == "smooth_l1":
-            gt_pred_deltas = self.box2box_transform.get_deltas(
-                proposal_boxes[fg_inds],
-                gt_boxes[fg_inds],
-            )
-            loss_box_reg = smooth_l1_loss(
-                fg_pred_deltas, gt_pred_deltas, self.smooth_l1_beta, reduction="sum"
-            )
-        elif self.box_reg_loss_type == "giou":
-            fg_pred_boxes = self.box2box_transform.apply_deltas(
-                fg_pred_deltas, proposal_boxes[fg_inds]
-            )
-            loss_box_reg = giou_loss(fg_pred_boxes, gt_boxes[fg_inds], reduction="sum")
-        else:
-            raise ValueError(f"Invalid bbox reg loss type '{self.box_reg_loss_type}'")
-        return loss_box_reg / max(gt_classes.numel(), 1.0)
-
-    def predict_probs(self, predictions, proposals):
-        scores = predictions[0]
-        num_inst_per_image = [len(p) for p in proposals]
-        probs = F.softmax(scores, dim=-1)
-        return probs.split(num_inst_per_image, dim=0)
-
-    def forward(self, x):
-        if x.dim() > 2:
-            x = torch.flatten(x, start_dim=1)
-        scores = []
-
-        cls_scores = self.cls_score(x)
-        scores.append(cls_scores)
-        scores = torch.cat(scores, dim=1)
-
-        proposal_deltas = self.bbox_pred(x)
-        return scores, proposal_deltas

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/data/samplers/distributed_sampler.py

@@ -1,278 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import itertools
-import logging
-import math
-from collections import defaultdict
-from typing import Optional
-import torch
-from torch.utils.data.sampler import Sampler
-
-from detectron2.utils import comm
-
-logger = logging.getLogger(__name__)
-
-
-class TrainingSampler(Sampler):
-    """
-    In training, we only care about the "infinite stream" of training data.
-    So this sampler produces an infinite stream of indices and
-    all workers cooperate to correctly shuffle the indices and sample different indices.
-
-    The samplers in each worker effectively produces `indices[worker_id::num_workers]`
-    where `indices` is an infinite stream of indices consisting of
-    `shuffle(range(size)) + shuffle(range(size)) + ...` (if shuffle is True)
-    or `range(size) + range(size) + ...` (if shuffle is False)
-
-    Note that this sampler does not shard based on pytorch DataLoader worker id.
-    A sampler passed to pytorch DataLoader is used only with map-style dataset
-    and will not be executed inside workers.
-    But if this sampler is used in a way that it gets execute inside a dataloader
-    worker, then extra work needs to be done to shard its outputs based on worker id.
-    This is required so that workers don't produce identical data.
-    :class:`ToIterableDataset` implements this logic.
-    This note is true for all samplers in detectron2.
-    """
-
-    def __init__(self, size: int, shuffle: bool = True, seed: Optional[int] = None):
-        """
-        Args:
-            size (int): the total number of data of the underlying dataset to sample from
-            shuffle (bool): whether to shuffle the indices or not
-            seed (int): the initial seed of the shuffle. Must be the same
-                across all workers. If None, will use a random seed shared
-                among workers (require synchronization among all workers).
-        """
-        if not isinstance(size, int):
-            raise TypeError(f"TrainingSampler(size=) expects an int. Got type {type(size)}.")
-        if size <= 0:
-            raise ValueError(f"TrainingSampler(size=) expects a positive int. Got {size}.")
-        self._size = size
-        self._shuffle = shuffle
-        if seed is None:
-            seed = comm.shared_random_seed()
-        self._seed = int(seed)
-
-        self._rank = comm.get_rank()
-        self._world_size = comm.get_world_size()
-
-    def __iter__(self):
-        start = self._rank
-        yield from itertools.islice(self._infinite_indices(), start, None, self._world_size)
-
-    def _infinite_indices(self):
-        g = torch.Generator()
-        g.manual_seed(self._seed)
-        while True:
-            if self._shuffle:
-                yield from torch.randperm(self._size, generator=g).tolist()
-            else:
-                yield from torch.arange(self._size).tolist()
-
-
-class RandomSubsetTrainingSampler(TrainingSampler):
-    """
-    Similar to TrainingSampler, but only sample a random subset of indices.
-    This is useful when you want to estimate the accuracy vs data-number curves by
-      training the model with different subset_ratio.
-    """
-
-    def __init__(
-        self,
-        size: int,
-        subset_ratio: float,
-        shuffle: bool = True,
-        seed_shuffle: Optional[int] = None,
-        seed_subset: Optional[int] = None,
-    ):
-        """
-        Args:
-            size (int): the total number of data of the underlying dataset to sample from
-            subset_ratio (float): the ratio of subset data to sample from the underlying dataset
-            shuffle (bool): whether to shuffle the indices or not
-            seed_shuffle (int): the initial seed of the shuffle. Must be the same
-                across all workers. If None, will use a random seed shared
-                among workers (require synchronization among all workers).
-            seed_subset (int): the seed to randomize the subset to be sampled.
-                Must be the same across all workers. If None, will use a random seed shared
-                among workers (require synchronization among all workers).
-        """
-        super().__init__(size=size, shuffle=shuffle, seed=seed_shuffle)
-
-        assert 0.0 < subset_ratio <= 1.0
-        self._size_subset = int(size * subset_ratio)
-        assert self._size_subset > 0
-        if seed_subset is None:
-            seed_subset = comm.shared_random_seed()
-        self._seed_subset = int(seed_subset)
-
-        # randomly generate the subset indexes to be sampled from
-        g = torch.Generator()
-        g.manual_seed(self._seed_subset)
-        indexes_randperm = torch.randperm(self._size, generator=g)
-        self._indexes_subset = indexes_randperm[: self._size_subset]
-
-        logger.info("Using RandomSubsetTrainingSampler......")
-        logger.info(f"Randomly sample {self._size_subset} data from the original {self._size} data")
-
-    def _infinite_indices(self):
-        g = torch.Generator()
-        g.manual_seed(self._seed)  # self._seed equals seed_shuffle from __init__()
-        while True:
-            if self._shuffle:
-                # generate a random permutation to shuffle self._indexes_subset
-                randperm = torch.randperm(self._size_subset, generator=g)
-                yield from self._indexes_subset[randperm].tolist()
-            else:
-                yield from self._indexes_subset.tolist()
-
-
-class RepeatFactorTrainingSampler(Sampler):
-    """
-    Similar to TrainingSampler, but a sample may appear more times than others based
-    on its "repeat factor". This is suitable for training on class imbalanced datasets like LVIS.
-    """
-
-    def __init__(self, repeat_factors, *, shuffle=True, seed=None):
-        """
-        Args:
-            repeat_factors (Tensor): a float vector, the repeat factor for each indice. When it's
-                full of ones, it is equivalent to ``TrainingSampler(len(repeat_factors), ...)``.
-            shuffle (bool): whether to shuffle the indices or not
-            seed (int): the initial seed of the shuffle. Must be the same
-                across all workers. If None, will use a random seed shared
-                among workers (require synchronization among all workers).
-        """
-        self._shuffle = shuffle
-        if seed is None:
-            seed = comm.shared_random_seed()
-        self._seed = int(seed)
-
-        self._rank = comm.get_rank()
-        self._world_size = comm.get_world_size()
-
-        # Split into whole number (_int_part) and fractional (_frac_part) parts.
-        self._int_part = torch.trunc(repeat_factors)
-        self._frac_part = repeat_factors - self._int_part
-
-    @staticmethod
-    def repeat_factors_from_category_frequency(dataset_dicts, repeat_thresh):
-        """
-        Compute (fractional) per-image repeat factors based on category frequency.
-        The repeat factor for an image is a function of the frequency of the rarest
-        category labeled in that image. The "frequency of category c" in [0, 1] is defined
-        as the fraction of images in the training set (without repeats) in which category c
-        appears.
-        See :paper:`lvis` (>= v2) Appendix B.2.
-
-        Args:
-            dataset_dicts (list[dict]): annotations in Detectron2 dataset format.
-            repeat_thresh (float): frequency threshold below which data is repeated.
-                If the frequency is half of `repeat_thresh`, the image will be
-                repeated twice.
-
-        Returns:
-            torch.Tensor:
-                the i-th element is the repeat factor for the dataset image at index i.
-        """
-        # 1. For each category c, compute the fraction of images that contain it: f(c)
-        category_freq = defaultdict(int)
-        for dataset_dict in dataset_dicts:  # For each image (without repeats)
-            cat_ids = {ann["category_id"] for ann in dataset_dict["annotations"]}
-            for cat_id in cat_ids:
-                category_freq[cat_id] += 1
-        num_images = len(dataset_dicts)
-        for k, v in category_freq.items():
-            category_freq[k] = v / num_images
-
-        # 2. For each category c, compute the category-level repeat factor:
-        #    r(c) = max(1, sqrt(t / f(c)))
-        category_rep = {
-            cat_id: max(1.0, math.sqrt(repeat_thresh / cat_freq))
-            for cat_id, cat_freq in category_freq.items()
-        }
-
-        # 3. For each image I, compute the image-level repeat factor:
-        #    r(I) = max_{c in I} r(c)
-        rep_factors = []
-        for dataset_dict in dataset_dicts:
-            cat_ids = {ann["category_id"] for ann in dataset_dict["annotations"]}
-            rep_factor = max({category_rep[cat_id] for cat_id in cat_ids}, default=1.0)
-            rep_factors.append(rep_factor)
-
-        return torch.tensor(rep_factors, dtype=torch.float32)
-
-    def _get_epoch_indices(self, generator):
-        """
-        Create a list of dataset indices (with repeats) to use for one epoch.
-
-        Args:
-            generator (torch.Generator): pseudo random number generator used for
-                stochastic rounding.
-
-        Returns:
-            torch.Tensor: list of dataset indices to use in one epoch. Each index
-                is repeated based on its calculated repeat factor.
-        """
-        # Since repeat factors are fractional, we use stochastic rounding so
-        # that the target repeat factor is achieved in expectation over the
-        # course of training
-        rands = torch.rand(len(self._frac_part), generator=generator)
-        rep_factors = self._int_part + (rands < self._frac_part).float()
-        # Construct a list of indices in which we repeat images as specified
-        indices = []
-        for dataset_index, rep_factor in enumerate(rep_factors):
-            indices.extend([dataset_index] * int(rep_factor.item()))
-        return torch.tensor(indices, dtype=torch.int64)
-
-    def __iter__(self):
-        start = self._rank
-        yield from itertools.islice(self._infinite_indices(), start, None, self._world_size)
-
-    def _infinite_indices(self):
-        g = torch.Generator()
-        g.manual_seed(self._seed)
-        while True:
-            # Sample indices with repeats determined by stochastic rounding; each
-            # "epoch" may have a slightly different size due to the rounding.
-            indices = self._get_epoch_indices(g)
-            if self._shuffle:
-                randperm = torch.randperm(len(indices), generator=g)
-                yield from indices[randperm].tolist()
-            else:
-                yield from indices.tolist()
-
-
-class InferenceSampler(Sampler):
-    """
-    Produce indices for inference across all workers.
-    Inference needs to run on the __exact__ set of samples,
-    therefore when the total number of samples is not divisible by the number of workers,
-    this sampler produces different number of samples on different workers.
-    """
-
-    def __init__(self, size: int):
-        """
-        Args:
-            size (int): the total number of data of the underlying dataset to sample from
-        """
-        self._size = size
-        assert size > 0
-        self._rank = comm.get_rank()
-        self._world_size = comm.get_world_size()
-        self._local_indices = self._get_local_indices(size, self._world_size, self._rank)
-
-    @staticmethod
-    def _get_local_indices(total_size, world_size, rank):
-        shard_size = total_size // world_size
-        left = total_size % world_size
-        shard_sizes = [shard_size + int(r < left) for r in range(world_size)]
-
-        begin = sum(shard_sizes[:rank])
-        end = min(sum(shard_sizes[: rank + 1]), total_size)
-        return range(begin, end)
-
-    def __iter__(self):
-        yield from self._local_indices
-
-    def __len__(self):
-        return len(self._local_indices)

spaces/Bakuman/Real-CUGAN/app.py

@@ -1,62 +0,0 @@
-from upcunet_v3 import RealWaifuUpScaler
-import gradio as gr
-import time
-import logging
-import os
-from PIL import ImageOps
-import numpy as np
-import math
-
-
-def greet(input_img, input_model_name, input_tile_mode):
-    # if input_img.size[0] * input_img.size[1] > 256 * 256:
-    #     y = int(math.sqrt(256*256/input_img.size[0]*input_img.size[1]))
-    #     x = int(input_img.size[0]/input_img.size[1]*y)
-    #     input_img = ImageOps.fit(input_img, (x, y))
-    input_img = np.array(input_img)
-    if input_model_name not in model_cache:
-        t1 = time.time()
-        upscaler = RealWaifuUpScaler(input_model_name[2], ModelPath + input_model_name, half=False, device="cpu")
-        t2 = time.time()
-        logger.info(f'load model time, {t2 - t1}')
-        model_cache[input_model_name] = upscaler
-    else:
-        upscaler = model_cache[input_model_name]
-        logger.info(f'load model from cache')
-
-    start = time.time()
-    result = upscaler(input_img, tile_mode=input_tile_mode)
-    end = time.time()
-    logger.info(f'input_model_name, {input_model_name}')
-    logger.info(f'input_tile_mode, {input_tile_mode}')
-    logger.info(f'input shape, {input_img.shape}')
-    logger.info(f'output shape, {result.shape}')
-    logger.info(f'speed time, {end - start}')
-    return result
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO, format="[%(asctime)s] [%(process)d] [%(levelname)s] %(message)s")
-    logger = logging.getLogger()
-
-    ModelPath = "weights_v3/"
-    model_cache = {}
-
-    input_model_name = gr.inputs.Dropdown(os.listdir(ModelPath), default="up2x-latest-denoise2x.pth", label='选择model')
-    input_tile_mode = gr.inputs.Dropdown([0, 1, 2, 3, 4], default=2, label='选择tile_mode')
-    input_img = gr.inputs.Image(label='image', type='pil')
-
-    inputs = [input_img, input_model_name, input_tile_mode]
-    outputs = "image"
-    iface = gr.Interface(fn=greet,
-                         inputs=inputs,
-                         outputs=outputs,
-                         allow_screenshot=False,
-                         allow_flagging='never',
-                         examples=[['test-img.jpg', "up2x-latest-denoise2x.pth", 2]],
-                         article='[https://github.com/bilibili/ailab/tree/main/Real-CUGAN](https://github.com/bilibili/ailab/tree/main/Real-CUGAN)<br>'
-                                 '感谢b站开源的项目，图片过大会导致内存不足，所有我将图片裁剪小，想体验大图片的效果请自行前往上面的链接。<br>'
-                                 '修改bbb'
-                                 'The large image will lead to memory limit exceeded. So I crop and resize image. '
-                                 'If you want to experience the large image, please go to the link above.')
-    iface.launch()

spaces/Bakuman/Real-CUGAN/upcunet_v3.py

@@ -1,714 +0,0 @@
-import torch
-from torch import nn as nn
-from torch.nn import functional as F
-import os, sys
-import numpy as np
-
-root_path = os.path.abspath('.')
-sys.path.append(root_path)
-
-
-class SEBlock(nn.Module):
-    def __init__(self, in_channels, reduction=8, bias=False):
-        super(SEBlock, self).__init__()
-        self.conv1 = nn.Conv2d(in_channels, in_channels // reduction, 1, 1, 0, bias=bias)
-        self.conv2 = nn.Conv2d(in_channels // reduction, in_channels, 1, 1, 0, bias=bias)
-
-    def forward(self, x):
-        if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-            x0 = torch.mean(x.float(), dim=(2, 3), keepdim=True).half()
-        else:
-            x0 = torch.mean(x, dim=(2, 3), keepdim=True)
-        x0 = self.conv1(x0)
-        x0 = F.relu(x0, inplace=True)
-        x0 = self.conv2(x0)
-        x0 = torch.sigmoid(x0)
-        x = torch.mul(x, x0)
-        return x
-
-    def forward_mean(self, x, x0):
-        x0 = self.conv1(x0)
-        x0 = F.relu(x0, inplace=True)
-        x0 = self.conv2(x0)
-        x0 = torch.sigmoid(x0)
-        x = torch.mul(x, x0)
-        return x
-
-
-class UNetConv(nn.Module):
-    def __init__(self, in_channels, mid_channels, out_channels, se):
-        super(UNetConv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(in_channels, mid_channels, 3, 1, 0),
-            nn.LeakyReLU(0.1, inplace=True),
-            nn.Conv2d(mid_channels, out_channels, 3, 1, 0),
-            nn.LeakyReLU(0.1, inplace=True),
-        )
-        if se:
-            self.seblock = SEBlock(out_channels, reduction=8, bias=True)
-        else:
-            self.seblock = None
-
-    def forward(self, x):
-        z = self.conv(x)
-        if self.seblock is not None:
-            z = self.seblock(z)
-        return z
-
-
-class UNet1(nn.Module):
-    def __init__(self, in_channels, out_channels, deconv):
-        super(UNet1, self).__init__()
-        self.conv1 = UNetConv(in_channels, 32, 64, se=False)
-        self.conv1_down = nn.Conv2d(64, 64, 2, 2, 0)
-        self.conv2 = UNetConv(64, 128, 64, se=True)
-        self.conv2_up = nn.ConvTranspose2d(64, 64, 2, 2, 0)
-        self.conv3 = nn.Conv2d(64, 64, 3, 1, 0)
-
-        if deconv:
-            self.conv_bottom = nn.ConvTranspose2d(64, out_channels, 4, 2, 3)
-        else:
-            self.conv_bottom = nn.Conv2d(64, out_channels, 3, 1, 0)
-
-        for m in self.modules():
-            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
-                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
-            elif isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, 0, 0.01)
-                if m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-
-    def forward(self, x):
-        x1 = self.conv1(x)
-        x2 = self.conv1_down(x1)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-        x2 = self.conv2(x2)
-        x2 = self.conv2_up(x2)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-
-        x1 = F.pad(x1, (-4, -4, -4, -4))
-        x3 = self.conv3(x1 + x2)
-        x3 = F.leaky_relu(x3, 0.1, inplace=True)
-        z = self.conv_bottom(x3)
-        return z
-
-    def forward_a(self, x):
-        x1 = self.conv1(x)
-        x2 = self.conv1_down(x1)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-        x2 = self.conv2.conv(x2)
-        return x1, x2
-
-    def forward_b(self, x1, x2):
-        x2 = self.conv2_up(x2)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-
-        x1 = F.pad(x1, (-4, -4, -4, -4))
-        x3 = self.conv3(x1 + x2)
-        x3 = F.leaky_relu(x3, 0.1, inplace=True)
-        z = self.conv_bottom(x3)
-        return z
-
-
-class UNet1x3(nn.Module):
-    def __init__(self, in_channels, out_channels, deconv):
-        super(UNet1x3, self).__init__()
-        self.conv1 = UNetConv(in_channels, 32, 64, se=False)
-        self.conv1_down = nn.Conv2d(64, 64, 2, 2, 0)
-        self.conv2 = UNetConv(64, 128, 64, se=True)
-        self.conv2_up = nn.ConvTranspose2d(64, 64, 2, 2, 0)
-        self.conv3 = nn.Conv2d(64, 64, 3, 1, 0)
-
-        if deconv:
-            self.conv_bottom = nn.ConvTranspose2d(64, out_channels, 5, 3, 2)
-        else:
-            self.conv_bottom = nn.Conv2d(64, out_channels, 3, 1, 0)
-
-        for m in self.modules():
-            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
-                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
-            elif isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, 0, 0.01)
-                if m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-
-    def forward(self, x):
-        x1 = self.conv1(x)
-        x2 = self.conv1_down(x1)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-        x2 = self.conv2(x2)
-        x2 = self.conv2_up(x2)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-
-        x1 = F.pad(x1, (-4, -4, -4, -4))
-        x3 = self.conv3(x1 + x2)
-        x3 = F.leaky_relu(x3, 0.1, inplace=True)
-        z = self.conv_bottom(x3)
-        return z
-
-    def forward_a(self, x):
-        x1 = self.conv1(x)
-        x2 = self.conv1_down(x1)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-        x2 = self.conv2.conv(x2)
-        return x1, x2
-
-    def forward_b(self, x1, x2):
-        x2 = self.conv2_up(x2)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-
-        x1 = F.pad(x1, (-4, -4, -4, -4))
-        x3 = self.conv3(x1 + x2)
-        x3 = F.leaky_relu(x3, 0.1, inplace=True)
-        z = self.conv_bottom(x3)
-        return z
-
-
-class UNet2(nn.Module):
-    def __init__(self, in_channels, out_channels, deconv):
-        super(UNet2, self).__init__()
-
-        self.conv1 = UNetConv(in_channels, 32, 64, se=False)
-        self.conv1_down = nn.Conv2d(64, 64, 2, 2, 0)
-        self.conv2 = UNetConv(64, 64, 128, se=True)
-        self.conv2_down = nn.Conv2d(128, 128, 2, 2, 0)
-        self.conv3 = UNetConv(128, 256, 128, se=True)
-        self.conv3_up = nn.ConvTranspose2d(128, 128, 2, 2, 0)
-        self.conv4 = UNetConv(128, 64, 64, se=True)
-        self.conv4_up = nn.ConvTranspose2d(64, 64, 2, 2, 0)
-        self.conv5 = nn.Conv2d(64, 64, 3, 1, 0)
-
-        if deconv:
-            self.conv_bottom = nn.ConvTranspose2d(64, out_channels, 4, 2, 3)
-        else:
-            self.conv_bottom = nn.Conv2d(64, out_channels, 3, 1, 0)
-
-        for m in self.modules():
-            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
-                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
-            elif isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, 0, 0.01)
-                if m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-
-    def forward(self, x):
-        x1 = self.conv1(x)
-        x2 = self.conv1_down(x1)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-        x2 = self.conv2(x2)
-
-        x3 = self.conv2_down(x2)
-        x3 = F.leaky_relu(x3, 0.1, inplace=True)
-        x3 = self.conv3(x3)
-        x3 = self.conv3_up(x3)
-        x3 = F.leaky_relu(x3, 0.1, inplace=True)
-
-        x2 = F.pad(x2, (-4, -4, -4, -4))
-        x4 = self.conv4(x2 + x3)
-        x4 = self.conv4_up(x4)
-        x4 = F.leaky_relu(x4, 0.1, inplace=True)
-
-        x1 = F.pad(x1, (-16, -16, -16, -16))
-        x5 = self.conv5(x1 + x4)
-        x5 = F.leaky_relu(x5, 0.1, inplace=True)
-
-        z = self.conv_bottom(x5)
-        return z
-
-    def forward_a(self, x):  # conv234结尾有se
-        x1 = self.conv1(x)
-        x2 = self.conv1_down(x1)
-        x2 = F.leaky_relu(x2, 0.1, inplace=True)
-        x2 = self.conv2.conv(x2)
-        return x1, x2
-
-    def forward_b(self, x2):  # conv234结尾有se
-        x3 = self.conv2_down(x2)
-        x3 = F.leaky_relu(x3, 0.1, inplace=True)
-        x3 = self.conv3.conv(x3)
-        return x3
-
-    def forward_c(self, x2, x3):  # conv234结尾有se
-        x3 = self.conv3_up(x3)
-        x3 = F.leaky_relu(x3, 0.1, inplace=True)
-
-        x2 = F.pad(x2, (-4, -4, -4, -4))
-        x4 = self.conv4.conv(x2 + x3)
-        return x4
-
-    def forward_d(self, x1, x4):  # conv234结尾有se
-        x4 = self.conv4_up(x4)
-        x4 = F.leaky_relu(x4, 0.1, inplace=True)
-
-        x1 = F.pad(x1, (-16, -16, -16, -16))
-        x5 = self.conv5(x1 + x4)
-        x5 = F.leaky_relu(x5, 0.1, inplace=True)
-
-        z = self.conv_bottom(x5)
-        return z
-
-
-class UpCunet2x(nn.Module):  # 完美tile，全程无损
-    def __init__(self, in_channels=3, out_channels=3):
-        super(UpCunet2x, self).__init__()
-        self.unet1 = UNet1(in_channels, out_channels, deconv=True)
-        self.unet2 = UNet2(in_channels, out_channels, deconv=False)
-
-    def forward(self, x, tile_mode):  # 1.7G
-        n, c, h0, w0 = x.shape
-        if (tile_mode == 0):  # 不tile
-            ph = ((h0 - 1) // 2 + 1) * 2
-            pw = ((w0 - 1) // 2 + 1) * 2
-            x = F.pad(x, (18, 18 + pw - w0, 18, 18 + ph - h0), 'reflect')  # 需要保证被2整除
-            x = self.unet1.forward(x)
-            x0 = self.unet2.forward(x)
-            x1 = F.pad(x, (-20, -20, -20, -20))
-            x = torch.add(x0, x1)
-            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 2, :w0 * 2]
-            return x
-        elif (tile_mode == 1):  # 对长边减半
-            if (w0 >= h0):
-                crop_size_w = ((w0 - 1) // 4 * 4 + 4) // 2  # 减半后能被2整除，所以要先被4整除
-                crop_size_h = (h0 - 1) // 2 * 2 + 2  # 能被2整除
-            else:
-                crop_size_h = ((h0 - 1) // 4 * 4 + 4) // 2  # 减半后能被2整除，所以要先被4整除
-                crop_size_w = (w0 - 1) // 2 * 2 + 2  # 能被2整除
-            crop_size = (crop_size_h, crop_size_w)  # 6.6G
-        elif (tile_mode == 2):  # hw都减半
-            crop_size = (((h0 - 1) // 4 * 4 + 4) // 2, ((w0 - 1) // 4 * 4 + 4) // 2)  # 5.6G
-        elif (tile_mode == 3):  # hw都三分之一
-            crop_size = (((h0 - 1) // 6 * 6 + 6) // 3, ((w0 - 1) // 6 * 6 + 6) // 3)  # 4.2G
-        elif (tile_mode == 4):  # hw都四分���一
-            crop_size = (((h0 - 1) // 8 * 8 + 8) // 4, ((w0 - 1) // 8 * 8 + 8) // 4)  # 3.7G
-        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
-        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
-        x = F.pad(x, (18, 18 + pw - w0, 18, 18 + ph - h0), 'reflect')
-        n, c, h, w = x.shape
-        se_mean0 = torch.zeros((n, 64, 1, 1)).to(x.device)
-        if ("Half" in x.type()):
-            se_mean0 = se_mean0.half()
-        n_patch = 0
-        tmp_dict = {}
-        opt_res_dict = {}
-        for i in range(0, h - 36, crop_size[0]):
-            tmp_dict[i] = {}
-            for j in range(0, w - 36, crop_size[1]):
-                x_crop = x[:, :, i:i + crop_size[0] + 36, j:j + crop_size[1] + 36]
-                n, c1, h1, w1 = x_crop.shape
-                tmp0, x_crop = self.unet1.forward_a(x_crop)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3), keepdim=True)
-                se_mean0 += tmp_se_mean
-                n_patch += 1
-                tmp_dict[i][j] = (tmp0, x_crop)
-        se_mean0 /= n_patch
-        se_mean1 = torch.zeros((n, 128, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean1 = se_mean1.half()
-        for i in range(0, h - 36, crop_size[0]):
-            for j in range(0, w - 36, crop_size[1]):
-                tmp0, x_crop = tmp_dict[i][j]
-                x_crop = self.unet1.conv2.seblock.forward_mean(x_crop, se_mean0)
-                opt_unet1 = self.unet1.forward_b(tmp0, x_crop)
-                tmp_x1, tmp_x2 = self.unet2.forward_a(opt_unet1)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3), keepdim=True)
-                se_mean1 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x2)
-        se_mean1 /= n_patch
-        se_mean0 = torch.zeros((n, 128, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean0 = se_mean0.half()
-        for i in range(0, h - 36, crop_size[0]):
-            for j in range(0, w - 36, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x2 = tmp_dict[i][j]
-                tmp_x2 = self.unet2.conv2.seblock.forward_mean(tmp_x2, se_mean1)
-                tmp_x3 = self.unet2.forward_b(tmp_x2)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3), keepdim=True)
-                se_mean0 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x2, tmp_x3)
-        se_mean0 /= n_patch
-        se_mean1 = torch.zeros((n, 64, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean1 = se_mean1.half()
-        for i in range(0, h - 36, crop_size[0]):
-            for j in range(0, w - 36, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x2, tmp_x3 = tmp_dict[i][j]
-                tmp_x3 = self.unet2.conv3.seblock.forward_mean(tmp_x3, se_mean0)
-                tmp_x4 = self.unet2.forward_c(tmp_x2, tmp_x3)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3), keepdim=True)
-                se_mean1 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x4)
-        se_mean1 /= n_patch
-        for i in range(0, h - 36, crop_size[0]):
-            opt_res_dict[i] = {}
-            for j in range(0, w - 36, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x4 = tmp_dict[i][j]
-                tmp_x4 = self.unet2.conv4.seblock.forward_mean(tmp_x4, se_mean1)
-                x0 = self.unet2.forward_d(tmp_x1, tmp_x4)
-                x1 = F.pad(opt_unet1, (-20, -20, -20, -20))
-                x_crop = torch.add(x0, x1)  # x0是unet2的最终输出
-                opt_res_dict[i][j] = x_crop
-        del tmp_dict
-        torch.cuda.empty_cache()
-        res = torch.zeros((n, c, h * 2 - 72, w * 2 - 72)).to(x.device)
-        if ("Half" in x.type()):
-            res = res.half()
-        for i in range(0, h - 36, crop_size[0]):
-            for j in range(0, w - 36, crop_size[1]):
-                res[:, :, i * 2:i * 2 + h1 * 2 - 72, j * 2:j * 2 + w1 * 2 - 72] = opt_res_dict[i][j]
-        del opt_res_dict
-        torch.cuda.empty_cache()
-        if (w0 != pw or h0 != ph): res = res[:, :, :h0 * 2, :w0 * 2]
-        return res  #
-
-
-class UpCunet3x(nn.Module):  # 完美tile，全程无损
-    def __init__(self, in_channels=3, out_channels=3):
-        super(UpCunet3x, self).__init__()
-        self.unet1 = UNet1x3(in_channels, out_channels, deconv=True)
-        self.unet2 = UNet2(in_channels, out_channels, deconv=False)
-
-    def forward(self, x, tile_mode):  # 1.7G
-        n, c, h0, w0 = x.shape
-        if (tile_mode == 0):  # 不tile
-            ph = ((h0 - 1) // 4 + 1) * 4
-            pw = ((w0 - 1) // 4 + 1) * 4
-            x = F.pad(x, (14, 14 + pw - w0, 14, 14 + ph - h0), 'reflect')  # 需要保证被2整除
-            x = self.unet1.forward(x)
-            x0 = self.unet2.forward(x)
-            x1 = F.pad(x, (-20, -20, -20, -20))
-            x = torch.add(x0, x1)
-            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 3, :w0 * 3]
-            return x
-        elif (tile_mode == 1):  # 对长边减半
-            if (w0 >= h0):
-                crop_size_w = ((w0 - 1) // 8 * 8 + 8) // 2  # 减半后能被4整除，所以要先被8整除
-                crop_size_h = (h0 - 1) // 4 * 4 + 4  # 能被4整除
-            else:
-                crop_size_h = ((h0 - 1) // 8 * 8 + 8) // 2  # 减半后能被4整除，所以要先被8整除
-                crop_size_w = (w0 - 1) // 4 * 4 + 4  # 能被4整除
-            crop_size = (crop_size_h, crop_size_w)  # 6.6G
-        elif (tile_mode == 2):  # hw都减半
-            crop_size = (((h0 - 1) // 8 * 8 + 8) // 2, ((w0 - 1) // 8 * 8 + 8) // 2)  # 5.6G
-        elif (tile_mode == 3):  # hw都三分之一
-            crop_size = (((h0 - 1) // 12 * 12 + 12) // 3, ((w0 - 1) // 12 * 12 + 12) // 3)  # 4.2G
-        elif (tile_mode == 4):  # hw都四分之一
-            crop_size = (((h0 - 1) // 16 * 16 + 16) // 4, ((w0 - 1) // 16 * 16 + 16) // 4)  # 3.7G
-        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
-        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
-        x = F.pad(x, (14, 14 + pw - w0, 14, 14 + ph - h0), 'reflect')
-        n, c, h, w = x.shape
-        se_mean0 = torch.zeros((n, 64, 1, 1)).to(x.device)
-        if ("Half" in x.type()):
-            se_mean0 = se_mean0.half()
-        n_patch = 0
-        tmp_dict = {}
-        opt_res_dict = {}
-        for i in range(0, h - 28, crop_size[0]):
-            tmp_dict[i] = {}
-            for j in range(0, w - 28, crop_size[1]):
-                x_crop = x[:, :, i:i + crop_size[0] + 28, j:j + crop_size[1] + 28]
-                n, c1, h1, w1 = x_crop.shape
-                tmp0, x_crop = self.unet1.forward_a(x_crop)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3), keepdim=True)
-                se_mean0 += tmp_se_mean
-                n_patch += 1
-                tmp_dict[i][j] = (tmp0, x_crop)
-        se_mean0 /= n_patch
-        se_mean1 = torch.zeros((n, 128, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean1 = se_mean1.half()
-        for i in range(0, h - 28, crop_size[0]):
-            for j in range(0, w - 28, crop_size[1]):
-                tmp0, x_crop = tmp_dict[i][j]
-                x_crop = self.unet1.conv2.seblock.forward_mean(x_crop, se_mean0)
-                opt_unet1 = self.unet1.forward_b(tmp0, x_crop)
-                tmp_x1, tmp_x2 = self.unet2.forward_a(opt_unet1)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3), keepdim=True)
-                se_mean1 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x2)
-        se_mean1 /= n_patch
-        se_mean0 = torch.zeros((n, 128, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean0 = se_mean0.half()
-        for i in range(0, h - 28, crop_size[0]):
-            for j in range(0, w - 28, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x2 = tmp_dict[i][j]
-                tmp_x2 = self.unet2.conv2.seblock.forward_mean(tmp_x2, se_mean1)
-                tmp_x3 = self.unet2.forward_b(tmp_x2)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3), keepdim=True)
-                se_mean0 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x2, tmp_x3)
-        se_mean0 /= n_patch
-        se_mean1 = torch.zeros((n, 64, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean1 = se_mean1.half()
-        for i in range(0, h - 28, crop_size[0]):
-            for j in range(0, w - 28, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x2, tmp_x3 = tmp_dict[i][j]
-                tmp_x3 = self.unet2.conv3.seblock.forward_mean(tmp_x3, se_mean0)
-                tmp_x4 = self.unet2.forward_c(tmp_x2, tmp_x3)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3), keepdim=True)
-                se_mean1 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x4)
-        se_mean1 /= n_patch
-        for i in range(0, h - 28, crop_size[0]):
-            opt_res_dict[i] = {}
-            for j in range(0, w - 28, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x4 = tmp_dict[i][j]
-                tmp_x4 = self.unet2.conv4.seblock.forward_mean(tmp_x4, se_mean1)
-                x0 = self.unet2.forward_d(tmp_x1, tmp_x4)
-                x1 = F.pad(opt_unet1, (-20, -20, -20, -20))
-                x_crop = torch.add(x0, x1)  # x0是unet2的最终输出
-                opt_res_dict[i][j] = x_crop  #
-        del tmp_dict
-        torch.cuda.empty_cache()
-        res = torch.zeros((n, c, h * 3 - 84, w * 3 - 84)).to(x.device)
-        if ("Half" in x.type()):
-            res = res.half()
-        for i in range(0, h - 28, crop_size[0]):
-            for j in range(0, w - 28, crop_size[1]):
-                res[:, :, i * 3:i * 3 + h1 * 3 - 84, j * 3:j * 3 + w1 * 3 - 84] = opt_res_dict[i][j]
-        del opt_res_dict
-        torch.cuda.empty_cache()
-        if (w0 != pw or h0 != ph): res = res[:, :, :h0 * 3, :w0 * 3]
-        return res
-
-
-class UpCunet4x(nn.Module):  # 完美tile，全程无损
-    def __init__(self, in_channels=3, out_channels=3):
-        super(UpCunet4x, self).__init__()
-        self.unet1 = UNet1(in_channels, 64, deconv=True)
-        self.unet2 = UNet2(64, 64, deconv=False)
-        self.ps = nn.PixelShuffle(2)
-        self.conv_final = nn.Conv2d(64, 12, 3, 1, padding=0, bias=True)
-
-    def forward(self, x, tile_mode):
-        n, c, h0, w0 = x.shape
-        x00 = x
-        if (tile_mode == 0):  # 不tile
-            ph = ((h0 - 1) // 2 + 1) * 2
-            pw = ((w0 - 1) // 2 + 1) * 2
-            x = F.pad(x, (19, 19 + pw - w0, 19, 19 + ph - h0), 'reflect')  # 需要保证被2整除
-            x = self.unet1.forward(x)
-            x0 = self.unet2.forward(x)
-            x1 = F.pad(x, (-20, -20, -20, -20))
-            x = torch.add(x0, x1)
-            x = self.conv_final(x)
-            x = F.pad(x, (-1, -1, -1, -1))
-            x = self.ps(x)
-            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 4, :w0 * 4]
-            x += F.interpolate(x00, scale_factor=4, mode='nearest')
-            return x
-        elif (tile_mode == 1):  # 对长边减半
-            if (w0 >= h0):
-                crop_size_w = ((w0 - 1) // 4 * 4 + 4) // 2  # 减半后能被2整除，所以要先被4整除
-                crop_size_h = (h0 - 1) // 2 * 2 + 2  # 能被2整除
-            else:
-                crop_size_h = ((h0 - 1) // 4 * 4 + 4) // 2  # 减半后能被2整除，所以要先被4整除
-                crop_size_w = (w0 - 1) // 2 * 2 + 2  # 能被2整除
-            crop_size = (crop_size_h, crop_size_w)  # 6.6G
-        elif (tile_mode == 2):  # hw都减半
-            crop_size = (((h0 - 1) // 4 * 4 + 4) // 2, ((w0 - 1) // 4 * 4 + 4) // 2)  # 5.6G
-        elif (tile_mode == 3):  # hw都三分之一
-            crop_size = (((h0 - 1) // 6 * 6 + 6) // 3, ((w0 - 1) // 6 * 6 + 6) // 3)  # 4.1G
-        elif (tile_mode == 4):  # hw都四分之一
-            crop_size = (((h0 - 1) // 8 * 8 + 8) // 4, ((w0 - 1) // 8 * 8 + 8) // 4)  # 3.7G
-        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
-        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
-        x = F.pad(x, (19, 19 + pw - w0, 19, 19 + ph - h0), 'reflect')
-        n, c, h, w = x.shape
-        se_mean0 = torch.zeros((n, 64, 1, 1)).to(x.device)
-        if ("Half" in x.type()):
-            se_mean0 = se_mean0.half()
-        n_patch = 0
-        tmp_dict = {}
-        opt_res_dict = {}
-        for i in range(0, h - 38, crop_size[0]):
-            tmp_dict[i] = {}
-            for j in range(0, w - 38, crop_size[1]):
-                x_crop = x[:, :, i:i + crop_size[0] + 38, j:j + crop_size[1] + 38]
-                n, c1, h1, w1 = x_crop.shape
-                tmp0, x_crop = self.unet1.forward_a(x_crop)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3), keepdim=True)
-                se_mean0 += tmp_se_mean
-                n_patch += 1
-                tmp_dict[i][j] = (tmp0, x_crop)
-        se_mean0 /= n_patch
-        se_mean1 = torch.zeros((n, 128, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean1 = se_mean1.half()
-        for i in range(0, h - 38, crop_size[0]):
-            for j in range(0, w - 38, crop_size[1]):
-                tmp0, x_crop = tmp_dict[i][j]
-                x_crop = self.unet1.conv2.seblock.forward_mean(x_crop, se_mean0)
-                opt_unet1 = self.unet1.forward_b(tmp0, x_crop)
-                tmp_x1, tmp_x2 = self.unet2.forward_a(opt_unet1)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3), keepdim=True)
-                se_mean1 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x2)
-        se_mean1 /= n_patch
-        se_mean0 = torch.zeros((n, 128, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean0 = se_mean0.half()
-        for i in range(0, h - 38, crop_size[0]):
-            for j in range(0, w - 38, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x2 = tmp_dict[i][j]
-                tmp_x2 = self.unet2.conv2.seblock.forward_mean(tmp_x2, se_mean1)
-                tmp_x3 = self.unet2.forward_b(tmp_x2)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3), keepdim=True)
-                se_mean0 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x2, tmp_x3)
-        se_mean0 /= n_patch
-        se_mean1 = torch.zeros((n, 64, 1, 1)).to(x.device)  # 64#128#128#64
-        if ("Half" in x.type()):
-            se_mean1 = se_mean1.half()
-        for i in range(0, h - 38, crop_size[0]):
-            for j in range(0, w - 38, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x2, tmp_x3 = tmp_dict[i][j]
-                tmp_x3 = self.unet2.conv3.seblock.forward_mean(tmp_x3, se_mean0)
-                tmp_x4 = self.unet2.forward_c(tmp_x2, tmp_x3)
-                if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
-                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3), keepdim=True).half()
-                else:
-                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3), keepdim=True)
-                se_mean1 += tmp_se_mean
-                tmp_dict[i][j] = (opt_unet1, tmp_x1, tmp_x4)
-        se_mean1 /= n_patch
-        for i in range(0, h - 38, crop_size[0]):
-            opt_res_dict[i] = {}
-            for j in range(0, w - 38, crop_size[1]):
-                opt_unet1, tmp_x1, tmp_x4 = tmp_dict[i][j]
-                tmp_x4 = self.unet2.conv4.seblock.forward_mean(tmp_x4, se_mean1)
-                x0 = self.unet2.forward_d(tmp_x1, tmp_x4)
-                x1 = F.pad(opt_unet1, (-20, -20, -20, -20))
-                x_crop = torch.add(x0, x1)  # x0是unet2的最终输出
-                x_crop = self.conv_final(x_crop)
-                x_crop = F.pad(x_crop, (-1, -1, -1, -1))
-                x_crop = self.ps(x_crop)
-                opt_res_dict[i][j] = x_crop
-        del tmp_dict
-        torch.cuda.empty_cache()
-        res = torch.zeros((n, c, h * 4 - 152, w * 4 - 152)).to(x.device)
-        if ("Half" in x.type()):
-            res = res.half()
-        for i in range(0, h - 38, crop_size[0]):
-            for j in range(0, w - 38, crop_size[1]):
-                # print(opt_res_dict[i][j].shape,res[:, :, i * 4:i * 4 + h1 * 4 - 144, j * 4:j * 4 + w1 * 4 - 144].shape)
-                res[:, :, i * 4:i * 4 + h1 * 4 - 152, j * 4:j * 4 + w1 * 4 - 152] = opt_res_dict[i][j]
-        del opt_res_dict
-        torch.cuda.empty_cache()
-        if (w0 != pw or h0 != ph): res = res[:, :, :h0 * 4, :w0 * 4]
-        res += F.interpolate(x00, scale_factor=4, mode='nearest')
-        return res  #
-
-
-class RealWaifuUpScaler(object):
-    def __init__(self, scale, weight_path, half, device):
-        weight = torch.load(weight_path, map_location="cpu")
-        self.model = eval("UpCunet%sx" % scale)()
-        if (half == True):
-            self.model = self.model.half().to(device)
-        else:
-            self.model = self.model.to(device)
-        self.model.load_state_dict(weight, strict=True)
-        self.model.eval()
-        self.half = half
-        self.device = device
-
-    def np2tensor(self, np_frame):
-        if (self.half == False):
-            return torch.from_numpy(np.transpose(np_frame, (2, 0, 1))).unsqueeze(0).to(self.device).float() / 255
-        else:
-            return torch.from_numpy(np.transpose(np_frame, (2, 0, 1))).unsqueeze(0).to(self.device).half() / 255
-
-    def tensor2np(self, tensor):
-        if (self.half == False):
-            return (
-                np.transpose((tensor.data.squeeze() * 255.0).round().clamp_(0, 255).byte().cpu().numpy(), (1, 2, 0)))
-        else:
-            return (np.transpose((tensor.data.squeeze().float() * 255.0).round().clamp_(0, 255).byte().cpu().numpy(),
-                                 (1, 2, 0)))
-
-    def __call__(self, frame, tile_mode):
-        with torch.no_grad():
-            tensor = self.np2tensor(frame)
-            result = self.tensor2np(self.model(tensor, tile_mode))
-        return result
-
-
-if __name__ == "__main__":
-    ###########inference_img
-    import time, cv2, sys
-    from time import time as ttime
-
-    for weight_path, scale in [("weights_v3/up2x-latest-denoise3x.pth", 2), ("weights_v3/up3x-latest-denoise3x.pth", 3),
-                               ("weights_v3/up4x-latest-denoise3x.pth", 4)]:
-        for tile_mode in [0, 1, 2, 3, 4]:
-            upscaler2x = RealWaifuUpScaler(scale, weight_path, half=True, device="cuda:0")
-            input_dir = "%s/input_dir1" % root_path
-            output_dir = "%s/opt-dir-all-test" % root_path
-            os.makedirs(output_dir, exist_ok=True)
-            for name in os.listdir(input_dir):
-                print(name)
-                tmp = name.split(".")
-                inp_path = os.path.join(input_dir, name)
-                suffix = tmp[-1]
-                prefix = ".".join(tmp[:-1])
-                tmp_path = os.path.join(root_path, "tmp", "%s.%s" % (int(time.time() * 1000000), suffix))
-                print(inp_path, tmp_path)
-                # 支持中文路径
-                # os.link(inp_path, tmp_path)#win用硬链接
-                os.symlink(inp_path, tmp_path)  # linux用软链接
-                frame = cv2.imread(tmp_path)[:, :, [2, 1, 0]]
-                t0 = ttime()
-                result = upscaler2x(frame, tile_mode=tile_mode)[:, :, ::-1]
-                t1 = ttime()
-                print(prefix, "done", t1 - t0)
-                tmp_opt_path = os.path.join(root_path, "tmp", "%s.%s" % (int(time.time() * 1000000), suffix))
-                cv2.imwrite(tmp_opt_path, result)
-                n = 0
-                while (1):
-                    if (n == 0):
-                        suffix = "_%sx_tile%s.png" % (scale, tile_mode)
-                    else:
-                        suffix = "_%sx_tile%s_%s.png" % (scale, tile_mode, n)  #
-                    if (os.path.exists(os.path.join(output_dir, prefix + suffix)) == False):
-                        break
-                    else:
-                        n += 1
-                final_opt_path = os.path.join(output_dir, prefix + suffix)
-                os.rename(tmp_opt_path, final_opt_path)
-                os.remove(tmp_path)

spaces/Benson/text-generation/Examples/Aficionado A Las Descargas.md

@@ -1,101 +0,0 @@
-
-<h1>Descargar Buff: El Programa de Recompensa del Jugador Definitivo</h1>
-<p>Si eres un jugador al que le encanta jugar títulos populares como Valorant, LOL, Fortnite, Apex Legends, COD, PUBG, Rocket League y más, es posible que te estés preguntando cómo aprovechar al máximo tu experiencia de juego. ¿Qué tal ser recompensado por jugar los juegos que te gustan? Suena demasiado bueno para ser verdad, ¿verdad? Bueno, ya no. Conoce <strong>Buff</strong>, el programa de recompensa ideal del jugador, donde juegas para obtener artículos IRL.</p>
-<h2>aficionado a las descargas</h2><br /><p><b><b>Download</b> >> <a href="https://bltlly.com/2v6L4E">https://bltlly.com/2v6L4E</a></b></p><br /><br />
-<p>Buff es una aplicación que se ejecuta en segundo plano mientras juegas tus juegos favoritos. Rastrea tu juego y logros y te recompensa con beneficios <fuertes></fuertes>, que son puntos que puedes canjear por artículos de la vida real como tarjetas de regalo, equipo de juego, llaves de vapor y muchos más. Cuanto mejor juegas, más potenciadores ganas. Es así de simple. </p>
-<p>Pero, ¿qué juegos puedes jugar con Buff? ¿Y qué artículos puedes canjear con tus potenciadores? Vamos a averiguarlo. </p>
- <h2>Características de Buff: Por qué debería descargar Buff hoy</h2>
-<p>Buff no es solo un programa de recompensa. También es una plataforma que mejora tu experiencia de juego con algunas características increíbles. Estas son algunas de ellas:</p>
-<ul>
-<li><strong>Aspectos destacados:</strong> Aced el equipo del enemigo? No te preocupes, lo tenemos. Buff detecta los aspectos más destacados del juego y los captura para usted. A continuación, puede compartirlos con sus amigos o en las redes sociales. También puedes ver los juegos más épicos de otros jugadores en <a href="( 1 )">Buff TV</a>. </li>
-<li><strong>Estadísticas de potenciadores:</strong> ¿Quieres saber qué tan bien te va en tus juegos? Buff le proporciona estadísticas detalladas y conocimientos sobre su rendimiento y logros. También puedes compararte con otros jugadores y ver cómo te clasificas en las tablas de clasificación. </li>
-
-</ul>
- <h2>Beneficios de Buff: Cómo subir de nivel en todas partes con Buff</h2>
-<p>Como mencionamos anteriormente, el principal beneficio de usar Buff es que puedes ganar potenciadores mientras juegas y canjearlos por artículos IRL. Pero eso no es todo. Hay otras formas de subir de nivel en todas partes con Buff. Estas son algunas de ellas:</p>
-<ul>
-<li><strong>Desafíos de potenciación:</strong> Si quieres ganar más potenciadores, puedes completar retos divertidos mientras juegas. Estas son tareas que ponen a prueba sus habilidades y conocimientos del juego. Por ejemplo, es posible que tenga que obtener un cierto número de muertes o asistencias, ganar un partido, o responder a una pregunta trivial. Cuantos más desafíos completes, más potenciadores obtendrás. </li>
-<li><strong>Buff Pass:</strong> Si quieres desbloquear recompensas y beneficios exclusivos, puedes comprar un <a href="( 5 )">Buff Pass</ a</a>. Un Buff Pass es una suscripción que te da acceso a funciones y recompensas premium, como potenciadores dobles, artículos exclusivos, desafíos especiales y más. Puede elegir entre diferentes planes y duraciones para adaptarse a su presupuesto y preferencias. </li>
-<li><strong>Rifas Buff:</strong> Si te sientes afortunado, puedes participar en las rifas Buff y ganar premios increíbles. Estos son sorteos semanales o mensuales que te ofrecen la oportunidad de ganar artículos grandes como computadoras portátiles, consolas, auriculares, teclados, ratones y más. Todo lo que necesitas hacer es comprar boletos para la rifa con tus aficionados y esperar lo mejor. </li>
-</ul>
- <h2>Comentarios Buff: Lo que dicen los jugadores sobre Buff</h2>
-<p>Todavía no está convencido de que Buff es el mejor programa de recompensa para los jugadores? No tome nuestra palabra para ello. Escucha lo que otros jugadores tienen que decir sobre Buff. Estas son algunas de las críticas positivas que Buff ha recibido de usuarios satisfechos:</p>
-<blockquote>
-
-</blockquote>
-<blockquote>
-<p>"He probado otras aplicaciones que dicen darte recompensas por jugar, pero ninguna se compara con Buff. Buff tiene la mejor selección de juegos, artículos y características. Los desafíos son divertidos y las rifas emocionantes. He ganado un ratón de juegos y unos auriculares de las rifas hasta ahora. Buff es legítimo!" - Lisa M., YouTube</p>
-<p></p>
-</blockquote>
-<blockquote>
-<p>"Buff es el programa de recompensa del jugador final. Tiene todo lo que necesita para mejorar su experiencia de juego y ganar objetos IRL. La aplicación es fácil de usar, segura y confiable. El equipo de soporte también es muy servicial y receptivo. Si usted es un jugador, es necesario descargar Buff hoy!" - Mark S., Juegos de Azar Comentarios</p>
-</blockquote>
-<p>Pero no solo tome su palabra para ello tampoco. Pruébelo usted mismo y vea la diferencia. Para darte una idea de cómo se compara Buff con otras aplicaciones similares, aquí hay una tabla que muestra algunas de las características y beneficios clave de Buff y sus competidores:</p>
- <tabla>
-<tr>
-<th>Aplicación</th>
-<th>Juegos soportados</th>
-<th>Opciones de recompensa</th>
-<th>Características adicionales</th>
-<th>Pros</th>
-<th>Contras</th>
-</tr>
-<tr>
-<td><strong>Buff</strong></td>
-<td>Valorant, LOL, Fortnite, Apex Legends, COD, PUBG, Rocket League, y más. </td>
-<td>Tarjetas de regalo, equipo de juegos, llaves de vapor, boletos de rifa, etc.</td>
-<td>Aspectos destacados, estadísticas, desafíos, pase, rifas, etc.</td>
-<td>- Amplia gama de juegos y artículos<br>- Fácil de usar y seguro<br>- Características divertidas y atractivas<br>- Recompensas y beneficios premium<br>- Opiniones y valoraciones positivas</td>
-<td>- Requiere aplicación Overwolf<br>- Buff Pass cuesta dinero<br>- Los boletos de la rifa son limitados</td>
-</tr> <tr>
-<td><strong>Mistplay</strong></td>
-<td>Varios juegos móviles de diferentes géneros y categorías. </td>
-<td>Tarjetas de regalo, tarjetas Visa prepagadas, créditos de Steam, etc.</td>
-<td>Chatear con otros jugadores, unirse a las comunidades de juego, ganar insignias y logros, etc.</td>
-
-<td>- Solo disponible para dispositivos Android<br>- Las recompensas toman tiempo para procesar<br>- Los puntos varían dependiendo del juego y la región</td>
-</tr>
-<tr>
-<td><strong>Luckmon</strong></td>
-<td>Juegos móviles populares como Roblox, Entre nosotros, Candy Crush, etc.</td>
-<td>Tarjetas de regalo, equipo de juego, boletos de rifa, etc.</td>
-<td>Aspectos destacados, misiones, rueda, rifas, etc.</td>
-<td>- Aplicación fácil de usar y segura<br>- Características divertidas y atractivas<br>- Artículos exclusivos en el juego<br>- Opiniones y valoraciones positivas</td>
-<td>- Requiere aplicación Overwolf<br>- Boletos de rifa limitada<br>- Las recompensas pueden agotarse</td>
-</tr>
-<tr>
-<td><strong>PlaySpot</strong></td>
-<td>Juegos móviles casuales como Solitario, Bingo, Ranuras, etc.</td>
-<td>PayPal cash, tarjetas de regalo de Amazon, etc.</td>
-<td>Invitar amigos, ver vídeos, ofertas completas, etc.</td>
-<td>- Aplicación simple y fácil de usar<br>- Variedad de juegos y recompensas<br>- Múltiples formas de ganar puntos<br>- Bajo umbral de pago</td>
-<td>- Solo disponible para dispositivos Android<br>- Las recompensas toman tiempo para procesar<br>- Los puntos varían dependiendo del juego y la región</td>
-</tr>
-</tabla>
- <h2>Alternativas Buff: ¿Hay mejores opciones? </h2>
-<p>Como se puede ver en la tabla de arriba, Buff no es la única aplicación que ofrece recompensas para los juegos. Hay otras aplicaciones que puedes probar si quieres ganar más puntos o jugar diferentes juegos. Sin embargo, ¿son mejores que Buff? Veamos brevemente algunos de ellos:</p>
- <ul>
-<li><strong>Mistplay:</strong> Esta es una de las aplicaciones más populares y confiables que te pagan por jugar. Usted puede elegir entre varios juegos móviles de diferentes géneros y categorías. También puede chatear con otros jugadores, unirse a las comunidades de juego, ganar insignias y logros, y más. Puedes canjear tus puntos por tarjetas de regalo, tarjetas Visa prepagadas, créditos de Steam y más. Sin embargo, Mistplay solo está disponible para dispositivos Android. También lleva tiempo procesar tus recompensas. Además, los puntos que ganes pueden variar según el juego y tu región. </li>
-
-<li><strong>PlaySpot:</strong> Esta es una aplicación simple y fácil de usar que te paga por jugar. Puedes jugar juegos móviles casuales como Solitaire, Bingo, Slots y más. También puedes invitar a amigos, ver videos, ofertas completas y más. Puedes canjear tus puntos por dinero de PayPal, tarjetas de regalo de Amazon y más. Sin embargo, PlaySpot solo está disponible para dispositivos Android. También lleva tiempo procesar tus recompensas. Además, los puntos que ganes pueden variar según el juego y tu región. </li>
-</ul>
- <h2>Conclusión: ¿Vale la pena descargar Buff? </h2>
- <p>En conclusión,</p> <p>En conclusión, descargar Buff vale la pena si eres un jugador que quiere ser recompensado por jugar los juegos que te gustan. Buff es el programa de recompensa del jugador definitivo que te ofrece una amplia gama de juegos, artículos y características. Puedes ganar beneficios mientras juegas y canjearlos por artículos de la vida real como tarjetas de regalo, equipo de juego, llaves de Steam y más. También puede capturar y compartir sus aspectos más destacados del juego, realizar un seguimiento de su progreso y logros, completar desafíos divertidos, desbloquear recompensas y beneficios exclusivos, y participar para tener la oportunidad de ganar premios increíbles. Buff es fácil de usar, seguro y confiable. Tiene comentarios positivos y valoraciones de usuarios satisfechos. También es compatible con la mayoría de dispositivos y plataformas. </p>
-<p>Si quieres subir de nivel en todas partes con Buff, todo lo que necesitas hacer es descargar la aplicación de forma gratuita desde el <a href="">sitio web oficial</a> o el <a href=">Google Play Store</a>. También necesitas instalar la aplicación Overwolf, que es la mejor plataforma de creación dentro del juego. Entonces, puedes empezar a jugar tus juegos favoritos y ganar potenciadores. Es así de simple. </p>
-<p>Entonces, ¿qué estás esperando? Descargar Buff hoy y empezar a ser recompensado por los juegos! </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí están algunas de las preguntas más frecuentes sobre la descarga de Buff:</p>
-<ol>
-<li><strong>¿Qué es Buff? </strong><br>
-
-<li><strong>¿Cómo funciona Buff? </strong><br>
-Buff funciona corriendo en segundo plano mientras juegas tus juegos favoritos. Rastrea tu juego y logros y te recompensa con potenciadores, que son puntos que puedes canjear por artículos IRL. Cuanto mejor juegas, más potenciadores ganas. </li>
-<li><strong>¿Qué juegos puedo jugar con Buff? </strong><br>
-Puedes jugar a títulos populares como Valorant, LOL, Fortnite, Apex Legends, COD, PUBG, Rocket League y más con Buff. También puede elegir entre diferentes géneros y categorías de juegos. </li>
-<li><strong>¿Qué artículos puedo canjear con Buff? </strong><br>
-Puede canjear sus potenciadores por una variedad de artículos como tarjetas de regalo, equipo de juego, llaves de vapor, boletos de rifa y más. También puedes desbloquear recompensas y beneficios exclusivos con un Buff Pass.</li>
-<li><strong>¿Es seguro usar Buff? </strong><br>
-Sí, Buff es seguro de usar. Es una aplicación autorizada por Overwolf, la mejor plataforma de creación de juegos del mundo. Es libre de malware, seguro contra van, y no afecta el rendimiento de tu juego o FPS. Ni siquiera sentirás que la aplicación Buff se ejecuta en segundo plano. </li>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Cambio De Forma Mod.md

@@ -1,82 +0,0 @@
-<br />
-<h1>Descargar Mod de cambio de forma: Cómo convertirse en cualquier multitud en Minecraft</h1>
-<p>¿Alguna vez te has preguntado cómo sería ser un zombi, un esqueleto, una araña o cualquier otra mafia en Minecraft? ¿Alguna vez has querido usar sus habilidades, como volar, escalar, explotar o disparar flechas? Si respondiste sí a cualquiera de estas preguntas, entonces podrías estar interesado en descargar e instalar el mod de cambio de forma para Minecraft.</p>
-<h2>Introducción</h2>
-<h3>¿Qué es el cambio de forma mod? </h3>
-<p>Shape shifting mod es un mod de Minecraft que te permite cambiar tu modelo presionando la tecla 'U' en el juego y seleccionando un mob. También obtendrás algunos beneficios y desventajas de la mafia elegida, como velocidad, salud, daños y habilidades especiales. Por ejemplo, si te transformas en una enredadera, podrás explotar y dañar bloques y entidades cercanas, pero también tendrás baja salud y serás vulnerable al fuego. El mod de cambio de forma se basa en el mod Changeling por asanetargoss, que es una bifurcación del mod Metamorph por McHorse. El mod de cambio de forma es compatible con la mayoría de mobs de vainilla y algunos mobs modded también. </p>
-<h2>descargar cambio de forma mod</h2><br /><p><b><b>DOWNLOAD</b> &#9675;&#9675;&#9675; <a href="https://bltlly.com/2v6Knq">https://bltlly.com/2v6Knq</a></b></p><br /><br />
-<h3>¿Por qué querrías usar mod de cambio de forma? </h3>
-<p>Hay muchas razones por las que es posible que desee utilizar mod cambio de forma en su mundo Minecraft. Estos son algunos de ellos:</p>
-<ul>
-<li>Puedes divertirte explorando el mundo desde diferentes perspectivas y usando diferentes habilidades. </li>
-<li>Puedes jugar como diferentes personajes o criaturas. </li>
-<li> Puedes obtener una ventaja en situaciones de combate o supervivencia usando la multitud adecuada para la ocasión correcta. </li>
-<li>Puedes bromear con tus amigos o enemigos disfrazándote como una turba hostil o amistosa. </li>
-<li>Puedes desafiarte jugando con diferentes limitaciones o dificultades. </li>
-</ul>
-<h2>Cómo descargar e instalar mod de cambio de forma</h2>
-<h3>Requisitos</h3>
-<p>Para descargar e instalar mod de cambio de forma, necesitará lo siguiente:</p>
-<ul>
-
-<li>Una versión compatible de Minecraft (actualmente 1.16.5). </li>
-<li>Una versión compatible de Forge (actualmente 36.2.0). </li>
-<li>El archivo mod de cambio de forma (actualmente 1.0.0). </li>
-<li>El archivo DominionLib (actualmente 1.0.4). </li>
-</ul>
-<h3>Pasos</h3>
-<p>Aquí están los pasos para descargar e instalar mod cambio de forma:</p>
-<ol>
-<li>Descargar Forge desde [aquí] y ejecutar el instalador. Asegúrese de seleccionar "Instalar cliente" y elegir la versión correcta de Minecraft. </li>
-<li>Descargar mod de cambio de forma desde [aquí]( 1 ) y DominionLib desde [aquí] y guardarlos en su carpeta de mods (por lo general ubicado en C: Users YourName AppData Roaming .minecraft mods). </li>
-<li>Iniciar Minecraft con el perfil de Forge y disfrutar! </li>
-</ol>
-<h2>Cómo usar el cambio de forma mod</h2>
-<h3>Controles</h3>
-<p>Para usar mod de cambio de forma, necesitará conocer los siguientes controles:</p>
-<ul>
-<li>Presione 'U' para abrir el menú morph, donde puede seleccionar un mob para transformarse. También puede utilizar la rueda del ratón para desplazarse a través de sus morfos disponibles. </li>
-<li>Presione '[' y ']' para cambiar entre sus morfos favoritos. Puede agregar o eliminar morphs de sus favoritos presionando 'P' mientras está en el menú morph. </li>
-<li>Presione 'R' para volver a su forma original. </li>
-<li> <li>Presione 'H' para alternar el morph HUD, que muestra su morph actual y sus habilidades. </li>
-</ul>
-<h3>Habilidades</h3>
-<p>Dependiendo de la mafia en la que te conviertas, obtendrás algunas habilidades que son únicas para esa mafia. Aquí hay algunos ejemplos de habilidades:</p>
-<ul>
-<li>Fly: Te permite volar en el aire tocando dos veces la barra espaciadora. Ejemplos de turbas que tienen esta habilidad son los murciélagos, las abejas y los ghasts. </li>
-<li>Subir: Le permite subir a las paredes y techos manteniendo la tecla de cambio. Ejemplos de turbas que tienen esta habilidad son arañas, peces plateados y endermites. </li>
-
-<li>Inmunidad al fuego: Te hace inmune al fuego y al daño de la lava. Ejemplos de turbas que tienen esta habilidad son llamas, cubos de magma y estrías. </li>
-<li>Nadar: Te permite nadar más rápido y respirar bajo el agua. Ejemplos de turbas que tienen esta habilidad son delfines, calamares y tortugas. </li>
-</ul>
-<h3>Ventajas y desventajas</h3>
-<p>Si bien el uso de cambio de forma mod puede ser divertido y útil, también viene con algunas compensaciones. Aquí están algunas ventajas y desventajas de usar el cambio de forma mod:</p>
-<tabla>
-<tr><th>Ventajas</th><th>Desventajas</th></tr>
-<tr><td>Puede acceder a áreas que normalmente son inaccesibles o difíciles de alcanzar mediante el uso de la multitud adecuada. </td><td>Puede perder parte de su espacio de inventario o ranuras de equipo transformándose en una turba de forma más pequeña o diferente. </td></tr>
-<tr><td>Puede mezclarse con otras turbas y evitar la detección o agresión por parte de turbas hostiles o neutrales. </td><td>También puede atraer atención no deseada o ataques por parte de mobs amistosos o pasivos. </td></tr>
-<tr><td>Puedes causar más daño o tener más salud transformándote en una multitud más fuerte o más grande. </td><td>También puede recibir más daño o tener menos salud al transformarse en una turba más débil o más pequeña. </td></tr>
-<tr><td>Usted puede tener más diversión y variedad probando diferentes mobs y sus habilidades. </td><td>También puede encontrar más errores o fallos mediante el uso de un mod que altera la mecánica del juego. </td></tr>
-</tabla>
-<h2>Ejemplos de cambio de forma mod en acción</h2>
-<h3>Convertirse en una enredadera y explotar cosas</h3>
-
-<h3>Conviértete en un murciélago y vuela</h3>
-<p>Otra mafia divertida para transformarse es el murciélago, que es uno de los pocos mobs que pueden volar en Minecraft. Al transformarte en un murciélago, puedes explorar el mundo desde arriba, alcanzar lugares altos o escapar del peligro. También puede caber en espacios pequeños y esconderse en esquinas oscuras. Para convertirse en un murciélago, debe matar a uno y luego seleccionarlo en el menú morph. Para volar, debe pulsar dos veces la barra espaciadora y luego usar las teclas de movimiento normales. También puede usar la rueda del ratón para ajustar su altitud. </p>
-<h3>Conviértete en una araña y trepa paredes</h3>
-<p>Un tercer ejemplo de una multitud genial para transformarse es la araña, que es conocida por su capacidad para escalar paredes y techos. Al transformarte en una araña, puedes acceder a áreas que normalmente son inalcanzables o difíciles de navegar. También puedes sorprender a tus enemigos o amigos bajando desde arriba o arrastrándote desde abajo. Para convertirte en una araña, necesitas matar a una y luego seleccionarla del menú morph. Para subir, debe mantener pulsada la tecla shift mientras se enfrenta a una pared o un techo. También puede usar la barra espaciadora para saltar. </p>
-<p></p>
-<h2>Conclusión</h2>
-<h3>Resumen</h3>
-<p>En este artículo, hemos aprendido cómo descargar e instalar mod de cambio de forma para Minecraft, cómo usarlo, qué habilidades nos da, qué ventajas y desventajas tiene, y algunos ejemplos de ello en acción. El mod de cambio de forma es un mod divertido y versátil que nos permite convertirnos en cualquier mafia en Minecraft y usar sus habilidades, como volar, escalar, explotar y más. Cambio de forma mod es una gran manera de añadir más diversión y variedad a su experiencia Minecraft. </p>
-<h3>Preguntas frecuentes</h3>
-<p>Aquí hay algunas preguntas frecuentes sobre el cambio de forma mod:</p>
-<ul>
-<li>P: ¿Cómo puedo obtener más morfos? <br>A: Puedes obtener más morfos matando más turbas, ya sea por ti mismo o con la ayuda de otros jugadores o entidades. También puedes usar comandos o trucos para obtener morphs sin matar mobs. </li>
-
-<li>Q: ¿Cómo puedo personalizar la configuración mod? <br>A: Puede personalizar la configuración mod presionando la tecla 'O' mientras está en el menú morph. También puede editar el archivo de configuración ubicado en C: Users YourName AppData Roaming . minecraft config shapeshiftingmod-common.toml. </li>
-<li>Q: ¿Cómo actualizo el mod? <br>A: Puede actualizar el mod descargando la última versión desde [aquí] y reemplazando el archivo antiguo en su carpeta mods. También puede ser necesario actualizar Forge y DominionLib si no son compatibles con la nueva versión. </li>
-<li>Q: ¿Cómo puedo reportar errores o problemas? <br>A: Puedes reportar errores o problemas creando un problema en la página GitHub del mod [aquí]. También puede ponerse en contacto con el autor del mod a través de Discord o Twitter.</li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Ganador Eleven 2019 Apk.md

@@ -1,74 +0,0 @@
-
-<h1>Descargar Ganar Once 2019 Apk: Una guía para los aficionados al fútbol</h1>
-<p>Si eres un fan de los juegos de fútbol, es posible que hayas oído hablar de Winning Eleven 2019, también conocido como WE 19. Es un popular juego de simulación de fútbol desarrollado por Konami, la misma compañía que creó la famosa serie Pro Evolution Soccer (PES). Winning Eleven 2019 es un mod no oficial de PES 2019, lo que significa que tiene algunas características y mejoras que no están disponibles en el juego original. En este artículo, le mostraremos cómo descargar e instalar Winning Eleven 2019 apk en su dispositivo Android, así como algunos consejos y trucos para jugarlo. </p>
-<h2>descargar ganador eleven 2019 apk</h2><br /><p><b><b>Download Zip</b> &middot;&middot;&middot;&middot;&middot; <a href="https://bltlly.com/2v6LPm">https://bltlly.com/2v6LPm</a></b></p><br /><br />
- <h2>Características de ganar once 2019 Apk</h2>
-<p>Ganar once 2019 apk tiene muchas características que lo convierten en uno de los mejores juegos de fútbol para Android. Estos son algunos de ellos:</p>
-<ul>
-<li><b>Gráficos y animaciones realistas</b>: El juego tiene gráficos impresionantes que hacen que los jugadores, estadios y multitudes se vean realistas. Las animaciones también son suaves y realistas, mostrando cada movimiento y gesto de los jugadores. </li>
-<li><b>Listas y equipos actualizados</b>: El juego tiene listas y equipos actualizados que reflejan las últimas transferencias y cambios en el mundo del fútbol. Puedes jugar con tus jugadores y equipos favoritos de varias ligas y competiciones, como Ronaldo, Messi, Neymar, Mbappe, Salah, Barcelona, Real Madrid, Liverpool, Juventus, PSG, Manchester City, Bayern Munich, etc.</li>
-<li><b>Varios modos de juego y desafíos</b>: El juego tiene diferentes modos de juego y desafíos que se adaptan a sus preferencias y habilidades. Puedes jugar en modo de exhibición, modo liga, modo copa, modo liga maestra o modo online. También puedes personalizar tus propios torneos y partidos con varias opciones y ajustes. </li>
-</ul>
- <h2>Cómo descargar e instalar ganar once 2019 Apk en Android</h2>
-<p>Para descargar e instalar Winning Eleven 2019 apk en su dispositivo Android, es necesario seguir estos pasos:</p>
-<ol>
-
-<li><b>Descargar los archivos apk y de datos de una fuente de confianza</b>: Es necesario descargar dos archivos para jugar Ganar Once 2019 apk: el archivo apk y el archivo de datos. El archivo apk es el archivo de aplicación que contiene el juego en sí, mientras que el archivo de datos es el archivo que contiene los datos del juego, como los gráficos, sonidos y listas. Puede descargar ambos archivos desde una fuente de confianza, como <a href="">este sitio web</a>. Asegúrate de tener suficiente espacio de almacenamiento en tu dispositivo antes de descargar los archivos. </li>
-<li><b>Extraiga el archivo de datos y cópielo a la carpeta obb</b>: Después de descargar los archivos, necesita extraer el archivo de datos usando una aplicación de administrador de archivos, como <a href="">ZArchiver</a>. Puede descargarlo de Google Play Store de forma gratuita. Para extraer el archivo de datos, abra ZArchiver y localice el archivo denominado <code>WE19.zip</code>. Toque en él y seleccione <code>Extraer aquí</code>. Obtendrá una carpeta llamada <code>jp.konami.we2019</code>. Copie esta carpeta y péguela a la carpeta obb en el almacenamiento interno de su dispositivo. La carpeta obb generalmente se encuentra en <code>Android > obb</code>. Si no tiene una carpeta obb, puede crear una. </li>
-<li><b>Instalar el archivo apk y lanzar el juego</b>: Después de copiar el archivo de datos a la carpeta obb, puede instalar el archivo apk tocando en él y siguiendo las instrucciones. Una vez completada la instalación, puede iniciar el juego desde el cajón de la aplicación o la pantalla de inicio. Disfrutar jugando Winning Eleven 2019 apk en su dispositivo Android! </li>
-</ol>
- <h2>Consejos y trucos para jugar ganar once 2019 Apk</h2>
-<p>Ganar once 2019 apk es un juego divertido y desafiante que requiere habilidad y estrategia. Aquí hay algunos consejos y trucos que pueden ayudarte a mejorar tu juego y ganar más partidos:</p>
-<p></p>
-<ul>
-
-<li><b>Domina las habilidades y tácticas</b>: El juego tiene varias habilidades y tácticas que puedes usar para superar a tus oponentes y anotar más goles. Puedes realizar dribbles, pases, tiros, encabezados, tackles, fintas, etc. usando diferentes combinaciones de botones y gestos. También puedes cambiar tu formación, estrategia y roles de jugador antes o durante un partido. Para aprender más sobre las habilidades y tácticas, puedes usar el modo de entrenamiento y los tutoriales que están disponibles en el juego. </li>
-<li><b>Usa el modo de entrenamiento y tutoriales</b>: El juego tiene un modo de entrenamiento y tutoriales que pueden ayudarte a practicar tus habilidades y aprender otras nuevas. El modo de entrenamiento te permite jugar en diferentes escenarios, como tiros libres, penaltis, esquinas, etc. Los tutoriales explican cómo realizar diversas acciones, como pasar, disparar, defender, etc. Puedes acceder al modo de entrenamiento y tutoriales desde el menú principal. </li>
-</ul>
- <h2>Pros y contras de ganar once 2019 Apk</h2>
-<p>Ganar once 2019 apk es un gran juego para los aficionados al fútbol, pero también tiene algunos pros y contras que usted debe ser consciente de antes de descargarlo. Estos son algunos de ellos:</p>
-<tabla>
-<tr>
-<th>Pros</th>
-<th>Contras</th>
-</tr>
-<tr>
-<td><ul>
-<li><b>Juego de alta calidad</b>: El juego tiene gráficos realistas, animaciones, física y sonidos que lo hacen inmersivo y agradable. </li>
-<li><b>Modo sin conexión</b>: El juego no requiere una conexión a Internet para jugar, lo que significa que puedes jugar en cualquier momento y en cualquier lugar. </li>
-<li><b>Descarga gratuita</b>: El juego es gratis para descargar de fuentes de terceros, lo que significa que no tienes que pagar nada para jugarlo. </li>
-</ul></td>
-<td><ul>
-<li><b>Tamaño de archivo grande</b>: El juego tiene un tamaño de archivo grande de aproximadamente 1.5 GB, lo que significa que ocupa mucho espacio de almacenamiento en su dispositivo. </li>
-
-<li><b>Puede no ser compatible con algunos dispositivos</b>: El juego puede no funcionar correctamente en algunos dispositivos debido a limitaciones de hardware o software. </li>
-</ul></td>
-</tr>
-</tabla>
- <h2>Conclusión</h2>
-<p>Ganar once 2019 apk es un juego que todos los fanáticos del fútbol deben probar. Tiene características sorprendentes, como gráficos realistas, listas actualizadas, varios modos de juego y modo fuera de línea. También es gratis para descargar de fuentes de terceros. Sin embargo, también tiene algunos inconvenientes, como el gran tamaño del archivo, la extracción de datos y problemas de compatibilidad. Si desea descargar e instalar Winning Eleven 2019 apk en su dispositivo Android, es necesario seguir los pasos que hemos proporcionado en este artículo. También es necesario dominar las habilidades y tácticas para jugar bien el juego. Esperamos que disfrute jugando Winning Eleven 2019 apk y divertirse! <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre ganar once 2019 apk:</p>
-<ol>
-<li><b>¿Cuál es la diferencia entre Winning Eleven 2019 y PES 2019? </b><br>
-Winning Eleven 2019 es un mod no oficial de PES 2019, lo que significa que tiene algunas características y mejoras que no están disponibles en el juego original. Por ejemplo, Winning Eleven 2019 tiene listas y equipos más actualizados, gráficos y animaciones más realistas, y más modos de juego y desafíos. </li>
-<li><b>¿Cómo puedo actualizar el juego a la última versión? </b><br>
-Para actualizar el juego a la última versión, es necesario descargar el nuevo apk y archivos de datos de una fuente de confianza y repetir el proceso de instalación. También debe eliminar el archivo de datos antiguo de la carpeta obb antes de copiar el nuevo. </li>
-<li><b>¿Cómo puedo jugar online con otros jugadores? </b><br>
-
-<li><b>¿Cómo puedo arreglar el juego si se bloquea o se congela? </b><br>
-Si el juego se bloquea o se congela, puedes probar algunas de estas soluciones: <ul>
-<li>Reiniciar el dispositivo y lanzar el juego de nuevo. </li>
-<li>Borra la caché y los datos del juego de la configuración de tu dispositivo. </li>
-<li> Reinstalar el juego y copiar el archivo de datos de nuevo. </li>
-<li>Compruebe la compatibilidad y el rendimiento de su dispositivo. </li>
-</ul></li>
-<li><b>¿Dónde puedo encontrar más información y soporte para Winning Eleven 2019? </b><br>
-Puedes encontrar más información y soporte para Winning Eleven 2019 en estas fuentes: <ul>
-<li>El sitio web oficial de Konami: <a href="">https://www.konami.com/</a></li>
-<li>La página oficial de Facebook de PES: <a href="">https://www.facebook.com/PES/</a></li>
-<li>La cuenta oficial de Twitter de PES: <a href="">https://twitter.com/officialpes</a></li>
-<li>El canal oficial de YouTube de PES: <a href="">https://www.youtube.com/user/officialpes</a></li>
-</ul></li>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/BernardoOlisan/vqganclip/taming-transformers/taming/data/base.py

@@ -1,70 +0,0 @@
-import bisect
-import numpy as np
-import albumentations
-from PIL import Image
-from torch.utils.data import Dataset, ConcatDataset
-
-
-class ConcatDatasetWithIndex(ConcatDataset):
-    """Modified from original pytorch code to return dataset idx"""
-    def __getitem__(self, idx):
-        if idx < 0:
-            if -idx > len(self):
-                raise ValueError("absolute value of index should not exceed dataset length")
-            idx = len(self) + idx
-        dataset_idx = bisect.bisect_right(self.cumulative_sizes, idx)
-        if dataset_idx == 0:
-            sample_idx = idx
-        else:
-            sample_idx = idx - self.cumulative_sizes[dataset_idx - 1]
-        return self.datasets[dataset_idx][sample_idx], dataset_idx
-
-
-class ImagePaths(Dataset):
-    def __init__(self, paths, size=None, random_crop=False, labels=None):
-        self.size = size
-        self.random_crop = random_crop
-
-        self.labels = dict() if labels is None else labels
-        self.labels["file_path_"] = paths
-        self._length = len(paths)
-
-        if self.size is not None and self.size > 0:
-            self.rescaler = albumentations.SmallestMaxSize(max_size = self.size)
-            if not self.random_crop:
-                self.cropper = albumentations.CenterCrop(height=self.size,width=self.size)
-            else:
-                self.cropper = albumentations.RandomCrop(height=self.size,width=self.size)
-            self.preprocessor = albumentations.Compose([self.rescaler, self.cropper])
-        else:
-            self.preprocessor = lambda **kwargs: kwargs
-
-    def __len__(self):
-        return self._length
-
-    def preprocess_image(self, image_path):
-        image = Image.open(image_path)
-        if not image.mode == "RGB":
-            image = image.convert("RGB")
-        image = np.array(image).astype(np.uint8)
-        image = self.preprocessor(image=image)["image"]
-        image = (image/127.5 - 1.0).astype(np.float32)
-        return image
-
-    def __getitem__(self, i):
-        example = dict()
-        example["image"] = self.preprocess_image(self.labels["file_path_"][i])
-        for k in self.labels:
-            example[k] = self.labels[k][i]
-        return example
-
-
-class NumpyPaths(ImagePaths):
-    def preprocess_image(self, image_path):
-        image = np.load(image_path).squeeze(0)  # 3 x 1024 x 1024
-        image = np.transpose(image, (1,2,0))
-        image = Image.fromarray(image, mode="RGB")
-        image = np.array(image).astype(np.uint8)
-        image = self.preprocessor(image=image)["image"]
-        image = (image/127.5 - 1.0).astype(np.float32)
-        return image

spaces/CVPR/LIVE/thrust/thrust/detail/tuple_algorithms.h

@@ -1,111 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/detail/cpp11_required.h>
-
-#if THRUST_CPP_DIALECT >= 2011
-
-#include <thrust/detail/type_deduction.h>
-#include <thrust/type_traits/integer_sequence.h>
-
-#include <tuple>
-
-namespace thrust
-{
-
-template <typename Tuple, std::size_t... Is>
-auto tuple_subset(Tuple&& t, index_sequence<Is...>)
-THRUST_DECLTYPE_RETURNS(std::make_tuple(std::get<Is>(THRUST_FWD(t))...));
-
-namespace detail
-{
-
-template <typename Tuple, typename F, std::size_t... Is>
-void tuple_for_each_impl(Tuple&& t, F&& f, index_sequence<Is...>)
-{
-  auto l = { (f(std::get<Is>(t)), 0)... };
-  THRUST_UNUSED_VAR(l);
-}
-
-template <typename Tuple, typename F, std::size_t... Is>
-auto tuple_transform_impl(Tuple&& t, F&& f, index_sequence<Is...>)
-THRUST_DECLTYPE_RETURNS(std::make_tuple(f(std::get<Is>(t))...));
-
-} // namespace detail
-
-template <typename... Ts, typename F>
-auto tuple_for_each(std::tuple<Ts...>& t, F&& f)
-THRUST_DECLTYPE_RETURNS(
-  detail::tuple_for_each_impl(
-    t
-  , THRUST_FWD(f)
-  , make_index_sequence<sizeof...(Ts)>{}
-  )
-);
-template <typename... Ts, typename F>
-auto tuple_for_each(std::tuple<Ts...> const& t, F&& f)
-THRUST_DECLTYPE_RETURNS(
-  detail::tuple_for_each_impl(
-    t
-  , THRUST_FWD(f)
-  , make_index_sequence<sizeof...(Ts)>{}
-  )
-);
-template <typename... Ts, typename F>
-auto tuple_for_each(std::tuple<Ts...>&& t, F&& f)
-THRUST_DECLTYPE_RETURNS(
-  detail::tuple_for_each_impl(
-    std::move(t)
-  , THRUST_FWD(f)
-  , make_index_sequence<sizeof...(Ts)>{}
-  )
-);
-
-template <typename... Ts, typename F>
-auto tuple_transform(std::tuple<Ts...>& t, F&& f)
-THRUST_DECLTYPE_RETURNS(
-  detail::tuple_transform_impl(
-    t
-  , THRUST_FWD(f)
-  , make_index_sequence<sizeof...(Ts)>{}
-  )
-);
-template <typename... Ts, typename F>
-auto tuple_transform(std::tuple<Ts...> const& t, F&& f)
-THRUST_DECLTYPE_RETURNS(
-  detail::tuple_transform_impl(
-    t
-  , THRUST_FWD(f)
-  , make_index_sequence<sizeof...(Ts)>{}
-  )
-);
-template <typename... Ts, typename F>
-auto tuple_transform(std::tuple<Ts...>&& t, F&& f)
-THRUST_DECLTYPE_RETURNS(
-  detail::tuple_transform_impl(
-    std::move(t)
-  , THRUST_FWD(f)
-  , make_index_sequence<sizeof...(Ts)>{}
-  )
-);
-
-} // end namespace thrust
-
-#endif // THRUST_CPP_DIALECT >= 2011
-

spaces/CVPR/LIVE/thrust/thrust/detail/type_traits/has_trivial_assign.h

@@ -1,54 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-
-/*! \file type_traits.h
- *  \brief Temporarily define some type traits
- *         until nvcc can compile tr1::type_traits.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/detail/type_traits.h>
-
-namespace thrust
-{
-
-namespace detail
-{
-
-template<typename T> struct has_trivial_assign
-  : public integral_constant<
-      bool,
-      (is_pod<T>::value && !is_const<T>::value)
-#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
-      || __has_trivial_assign(T)
-#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
-// only use the intrinsic for >= 4.3
-#if (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 3)
-      || __has_trivial_assign(T)
-#endif // GCC VERSION
-#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
-      || __has_trivial_assign(T)
-#endif // THRUST_HOST_COMPILER
-    >
-{};
-
-} // end detail
-
-} // end thrust
-

spaces/CVPR/Leaderboard/README.md

@@ -1,12 +0,0 @@
----
-title: Leaderboard
-emoji: 📈
-colorFrom: indigo
-colorTo: gray
-sdk: gradio
-sdk_version: 3.0.15
-app_file: app.py
-pinned: false
----
-
-This Demo is the TokenCut demo, the original demo is from https://huggingface.co/spaces/akhaliq/TokenCut. Thanks for Ahsen Khaliq's nicely contribution.

spaces/CVPR/WALT/mmdet/datasets/samplers/group_sampler.py

@@ -1,148 +0,0 @@
-from __future__ import division
-import math
-
-import numpy as np
-import torch
-from mmcv.runner import get_dist_info
-from torch.utils.data import Sampler
-
-
-class GroupSampler(Sampler):
-
-    def __init__(self, dataset, samples_per_gpu=1):
-        assert hasattr(dataset, 'flag')
-        self.dataset = dataset
-        self.samples_per_gpu = samples_per_gpu
-        self.flag = dataset.flag.astype(np.int64)
-        self.group_sizes = np.bincount(self.flag)
-        self.num_samples = 0
-        for i, size in enumerate(self.group_sizes):
-            self.num_samples += int(np.ceil(
-                size / self.samples_per_gpu)) * self.samples_per_gpu
-
-    def __iter__(self):
-        indices = []
-        for i, size in enumerate(self.group_sizes):
-            if size == 0:
-                continue
-            indice = np.where(self.flag == i)[0]
-            assert len(indice) == size
-            np.random.shuffle(indice)
-            num_extra = int(np.ceil(size / self.samples_per_gpu)
-                            ) * self.samples_per_gpu - len(indice)
-            indice = np.concatenate(
-                [indice, np.random.choice(indice, num_extra)])
-            indices.append(indice)
-        indices = np.concatenate(indices)
-        indices = [
-            indices[i * self.samples_per_gpu:(i + 1) * self.samples_per_gpu]
-            for i in np.random.permutation(
-                range(len(indices) // self.samples_per_gpu))
-        ]
-        indices = np.concatenate(indices)
-        indices = indices.astype(np.int64).tolist()
-        assert len(indices) == self.num_samples
-        return iter(indices)
-
-    def __len__(self):
-        return self.num_samples
-
-
-class DistributedGroupSampler(Sampler):
-    """Sampler that restricts data loading to a subset of the dataset.
-
-    It is especially useful in conjunction with
-    :class:`torch.nn.parallel.DistributedDataParallel`. In such case, each
-    process can pass a DistributedSampler instance as a DataLoader sampler,
-    and load a subset of the original dataset that is exclusive to it.
-
-    .. note::
-        Dataset is assumed to be of constant size.
-
-    Arguments:
-        dataset: Dataset used for sampling.
-        num_replicas (optional): Number of processes participating in
-            distributed training.
-        rank (optional): Rank of the current process within num_replicas.
-        seed (int, optional): random seed used to shuffle the sampler if
-            ``shuffle=True``. This number should be identical across all
-            processes in the distributed group. Default: 0.
-    """
-
-    def __init__(self,
-                 dataset,
-                 samples_per_gpu=1,
-                 num_replicas=None,
-                 rank=None,
-                 seed=0):
-        _rank, _num_replicas = get_dist_info()
-        if num_replicas is None:
-            num_replicas = _num_replicas
-        if rank is None:
-            rank = _rank
-        self.dataset = dataset
-        self.samples_per_gpu = samples_per_gpu
-        self.num_replicas = num_replicas
-        self.rank = rank
-        self.epoch = 0
-        self.seed = seed if seed is not None else 0
-
-        assert hasattr(self.dataset, 'flag')
-        self.flag = self.dataset.flag
-        self.group_sizes = np.bincount(self.flag)
-
-        self.num_samples = 0
-        for i, j in enumerate(self.group_sizes):
-            self.num_samples += int(
-                math.ceil(self.group_sizes[i] * 1.0 / self.samples_per_gpu /
-                          self.num_replicas)) * self.samples_per_gpu
-        self.total_size = self.num_samples * self.num_replicas
-
-    def __iter__(self):
-        # deterministically shuffle based on epoch
-        g = torch.Generator()
-        g.manual_seed(self.epoch + self.seed)
-
-        indices = []
-        for i, size in enumerate(self.group_sizes):
-            if size > 0:
-                indice = np.where(self.flag == i)[0]
-                assert len(indice) == size
-                # add .numpy() to avoid bug when selecting indice in parrots.
-                # TODO: check whether torch.randperm() can be replaced by
-                # numpy.random.permutation().
-                indice = indice[list(
-                    torch.randperm(int(size), generator=g).numpy())].tolist()
-                extra = int(
-                    math.ceil(
-                        size * 1.0 / self.samples_per_gpu / self.num_replicas)
-                ) * self.samples_per_gpu * self.num_replicas - len(indice)
-                # pad indice
-                tmp = indice.copy()
-                for _ in range(extra // size):
-                    indice.extend(tmp)
-                indice.extend(tmp[:extra % size])
-                indices.extend(indice)
-
-        assert len(indices) == self.total_size
-
-        indices = [
-            indices[j] for i in list(
-                torch.randperm(
-                    len(indices) // self.samples_per_gpu, generator=g))
-            for j in range(i * self.samples_per_gpu, (i + 1) *
-                           self.samples_per_gpu)
-        ]
-
-        # subsample
-        offset = self.num_samples * self.rank
-        indices = indices[offset:offset + self.num_samples]
-        assert len(indices) == self.num_samples
-
-        return iter(indices)
-
-    def __len__(self):
-        return self.num_samples
-
-    def set_epoch(self, epoch):
-        self.epoch = epoch

spaces/Cloudy1225/stackoverflow-sentiment-analysis/sentiment_analyser.py

@@ -1,84 +0,0 @@
-import time
-import openai
-import random
-from transformers import pipeline
-
-
-class RandomAnalyser:
-    def __init__(self):
-        self.LABELS = ['negative', 'neutral', 'positive']
-
-    def predict(self, X: list):
-        return [random.choice(self.LABELS) for x in X]
-
-
-class RoBERTaAnalyser:
-    def __init__(self):
-        self.analyser = pipeline(task="sentiment-analysis", model="Cloudy1225/stackoverflow-roberta-base-sentiment")
-
-    def predict(self, X: list):
-        sentiments = []
-        for x in X:
-            x = RoBERTaAnalyser.preprocess(x)
-            prediction = self.analyser(x)
-            sentiments.append(prediction[0]['label'])
-        return sentiments
-
-    @staticmethod
-    def preprocess(text):
-        """Preprocess text (username and link placeholders, remove line breaks)"""
-        new_text = []
-        for t in text.split(' '):
-            t = '@user' if t.startswith('@') and len(t) > 1 else t
-            t = 'http' if t.startswith('http') else t
-            new_text.append(t)
-        return ' '.join(new_text).strip()
-
-
-class ChatGPTAnalyser:
-    def __init__(self):
-        # import os
-        # os.environ["http_proxy"] = "http://127.0.0.1:10080"
-        # os.environ["https_proxy"] = "http://127.0.0.1:10080"
-        self.MODEL = "gpt-3.5-turbo"
-        self.KEYs = [
-            "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",
-            "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",
-            "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",
-            "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",
-            "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",
-            "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"
-        ]
-        self.TASK_NAME = 'Sentiment Classification'
-        self.TASK_DEFINITION = 'Given the sentence, assign a sentiment label from [negative, neutral, positive].'
-        self.OUT_FORMAT = 'Return label only without any other text.'
-        self.PROMPT_PREFIX = f"Please perform {self.TASK_NAME} task.{self.TASK_DEFINITION}{self.OUT_FORMAT}\nSentence:\n{{}}\nLabel:"
-
-    def predict(self, X: list):
-        sentiments = []
-        for i in range(len(X)):
-            prompt = self.PROMPT_PREFIX.format(X[i])
-            messages = [{"role": "user", "content": prompt}]
-            # openai.api_key = self.KEYs[i % len(self.KEYs)]
-            openai.api_key = random.choice(self.KEYs)
-            while True:
-                try:
-                    response = openai.ChatCompletion.create(
-                        model=self.MODEL,
-                        messages=messages,
-                        temperature=0,
-                        n=1,
-                        stop=None
-                    )
-                    sentiment = response.choices[0].message.content
-                    sentiments.append(sentiment.strip().lower())
-                    break
-                except openai.error.RateLimitError:
-                    sleep_snds = 60
-                    time.sleep(sleep_snds)
-                    continue
-                except openai.error.APIError:
-                    sleep_snds = 60
-                    time.sleep(sleep_snds)
-                    continue
-        return sentiments

spaces/CofAI/chat/client/css/typing.css

@@ -1,15 +0,0 @@
-.typing {
-	position: absolute;
-	top: -25px;
-	left: 0;
-	font-size: 14px;
-	animation: show_popup 0.4s;
-}
-
-.typing-hiding {
-	animation: hide_popup 0.4s;
-}
-
-.typing-hidden {
-	display: none;
-}

spaces/CorvaeOboro/gen_ability_icon/torch_utils/ops/upfirdn2d.py

@@ -1,384 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Custom PyTorch ops for efficient resampling of 2D images."""
-
-import os
-import warnings
-import numpy as np
-import torch
-import traceback
-
-from .. import custom_ops
-from .. import misc
-from . import conv2d_gradfix
-
-#----------------------------------------------------------------------------
-
-_inited = False
-_plugin = None
-
-def _init():
-    global _inited, _plugin
-    if not _inited:
-        sources = ['upfirdn2d.cpp', 'upfirdn2d.cu']
-        sources = [os.path.join(os.path.dirname(__file__), s) for s in sources]
-        try:
-            _plugin = custom_ops.get_plugin('upfirdn2d_plugin', sources=sources, extra_cuda_cflags=['--use_fast_math'])
-        except:
-            warnings.warn('Failed to build CUDA kernels for upfirdn2d. Falling back to slow reference implementation. Details:\n\n' + traceback.format_exc())
-    return _plugin is not None
-
-def _parse_scaling(scaling):
-    if isinstance(scaling, int):
-        scaling = [scaling, scaling]
-    assert isinstance(scaling, (list, tuple))
-    assert all(isinstance(x, int) for x in scaling)
-    sx, sy = scaling
-    assert sx >= 1 and sy >= 1
-    return sx, sy
-
-def _parse_padding(padding):
-    if isinstance(padding, int):
-        padding = [padding, padding]
-    assert isinstance(padding, (list, tuple))
-    assert all(isinstance(x, int) for x in padding)
-    if len(padding) == 2:
-        padx, pady = padding
-        padding = [padx, padx, pady, pady]
-    padx0, padx1, pady0, pady1 = padding
-    return padx0, padx1, pady0, pady1
-
-def _get_filter_size(f):
-    if f is None:
-        return 1, 1
-    assert isinstance(f, torch.Tensor) and f.ndim in [1, 2]
-    fw = f.shape[-1]
-    fh = f.shape[0]
-    with misc.suppress_tracer_warnings():
-        fw = int(fw)
-        fh = int(fh)
-    misc.assert_shape(f, [fh, fw][:f.ndim])
-    assert fw >= 1 and fh >= 1
-    return fw, fh
-
-#----------------------------------------------------------------------------
-
-def setup_filter(f, device=torch.device('cpu'), normalize=True, flip_filter=False, gain=1, separable=None):
-    r"""Convenience function to setup 2D FIR filter for `upfirdn2d()`.
-
-    Args:
-        f:           Torch tensor, numpy array, or python list of the shape
-                     `[filter_height, filter_width]` (non-separable),
-                     `[filter_taps]` (separable),
-                     `[]` (impulse), or
-                     `None` (identity).
-        device:      Result device (default: cpu).
-        normalize:   Normalize the filter so that it retains the magnitude
-                     for constant input signal (DC)? (default: True).
-        flip_filter: Flip the filter? (default: False).
-        gain:        Overall scaling factor for signal magnitude (default: 1).
-        separable:   Return a separable filter? (default: select automatically).
-
-    Returns:
-        Float32 tensor of the shape
-        `[filter_height, filter_width]` (non-separable) or
-        `[filter_taps]` (separable).
-    """
-    # Validate.
-    if f is None:
-        f = 1
-    f = torch.as_tensor(f, dtype=torch.float32)
-    assert f.ndim in [0, 1, 2]
-    assert f.numel() > 0
-    if f.ndim == 0:
-        f = f[np.newaxis]
-
-    # Separable?
-    if separable is None:
-        separable = (f.ndim == 1 and f.numel() >= 8)
-    if f.ndim == 1 and not separable:
-        f = f.ger(f)
-    assert f.ndim == (1 if separable else 2)
-
-    # Apply normalize, flip, gain, and device.
-    if normalize:
-        f /= f.sum()
-    if flip_filter:
-        f = f.flip(list(range(f.ndim)))
-    f = f * (gain ** (f.ndim / 2))
-    f = f.to(device=device)
-    return f
-
-#----------------------------------------------------------------------------
-
-def upfirdn2d(x, f, up=1, down=1, padding=0, flip_filter=False, gain=1, impl='cuda'):
-    r"""Pad, upsample, filter, and downsample a batch of 2D images.
-
-    Performs the following sequence of operations for each channel:
-
-    1. Upsample the image by inserting N-1 zeros after each pixel (`up`).
-
-    2. Pad the image with the specified number of zeros on each side (`padding`).
-       Negative padding corresponds to cropping the image.
-
-    3. Convolve the image with the specified 2D FIR filter (`f`), shrinking it
-       so that the footprint of all output pixels lies within the input image.
-
-    4. Downsample the image by keeping every Nth pixel (`down`).
-
-    This sequence of operations bears close resemblance to scipy.signal.upfirdn().
-    The fused op is considerably more efficient than performing the same calculation
-    using standard PyTorch ops. It supports gradients of arbitrary order.
-
-    Args:
-        x:           Float32/float64/float16 input tensor of the shape
-                     `[batch_size, num_channels, in_height, in_width]`.
-        f:           Float32 FIR filter of the shape
-                     `[filter_height, filter_width]` (non-separable),
-                     `[filter_taps]` (separable), or
-                     `None` (identity).
-        up:          Integer upsampling factor. Can be a single int or a list/tuple
-                     `[x, y]` (default: 1).
-        down:        Integer downsampling factor. Can be a single int or a list/tuple
-                     `[x, y]` (default: 1).
-        padding:     Padding with respect to the upsampled image. Can be a single number
-                     or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]`
-                     (default: 0).
-        flip_filter: False = convolution, True = correlation (default: False).
-        gain:        Overall scaling factor for signal magnitude (default: 1).
-        impl:        Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`).
-
-    Returns:
-        Tensor of the shape `[batch_size, num_channels, out_height, out_width]`.
-    """
-    assert isinstance(x, torch.Tensor)
-    assert impl in ['ref', 'cuda']
-    if impl == 'cuda' and x.device.type == 'cuda' and _init():
-        return _upfirdn2d_cuda(up=up, down=down, padding=padding, flip_filter=flip_filter, gain=gain).apply(x, f)
-    return _upfirdn2d_ref(x, f, up=up, down=down, padding=padding, flip_filter=flip_filter, gain=gain)
-
-#----------------------------------------------------------------------------
-
-@misc.profiled_function
-def _upfirdn2d_ref(x, f, up=1, down=1, padding=0, flip_filter=False, gain=1):
-    """Slow reference implementation of `upfirdn2d()` using standard PyTorch ops.
-    """
-    # Validate arguments.
-    assert isinstance(x, torch.Tensor) and x.ndim == 4
-    if f is None:
-        f = torch.ones([1, 1], dtype=torch.float32, device=x.device)
-    assert isinstance(f, torch.Tensor) and f.ndim in [1, 2]
-    assert f.dtype == torch.float32 and not f.requires_grad
-    batch_size, num_channels, in_height, in_width = x.shape
-    upx, upy = _parse_scaling(up)
-    downx, downy = _parse_scaling(down)
-    padx0, padx1, pady0, pady1 = _parse_padding(padding)
-
-    # Upsample by inserting zeros.
-    x = x.reshape([batch_size, num_channels, in_height, 1, in_width, 1])
-    x = torch.nn.functional.pad(x, [0, upx - 1, 0, 0, 0, upy - 1])
-    x = x.reshape([batch_size, num_channels, in_height * upy, in_width * upx])
-
-    # Pad or crop.
-    x = torch.nn.functional.pad(x, [max(padx0, 0), max(padx1, 0), max(pady0, 0), max(pady1, 0)])
-    x = x[:, :, max(-pady0, 0) : x.shape[2] - max(-pady1, 0), max(-padx0, 0) : x.shape[3] - max(-padx1, 0)]
-
-    # Setup filter.
-    f = f * (gain ** (f.ndim / 2))
-    f = f.to(x.dtype)
-    if not flip_filter:
-        f = f.flip(list(range(f.ndim)))
-
-    # Convolve with the filter.
-    f = f[np.newaxis, np.newaxis].repeat([num_channels, 1] + [1] * f.ndim)
-    if f.ndim == 4:
-        x = conv2d_gradfix.conv2d(input=x, weight=f, groups=num_channels)
-    else:
-        x = conv2d_gradfix.conv2d(input=x, weight=f.unsqueeze(2), groups=num_channels)
-        x = conv2d_gradfix.conv2d(input=x, weight=f.unsqueeze(3), groups=num_channels)
-
-    # Downsample by throwing away pixels.
-    x = x[:, :, ::downy, ::downx]
-    return x
-
-#----------------------------------------------------------------------------
-
-_upfirdn2d_cuda_cache = dict()
-
-def _upfirdn2d_cuda(up=1, down=1, padding=0, flip_filter=False, gain=1):
-    """Fast CUDA implementation of `upfirdn2d()` using custom ops.
-    """
-    # Parse arguments.
-    upx, upy = _parse_scaling(up)
-    downx, downy = _parse_scaling(down)
-    padx0, padx1, pady0, pady1 = _parse_padding(padding)
-
-    # Lookup from cache.
-    key = (upx, upy, downx, downy, padx0, padx1, pady0, pady1, flip_filter, gain)
-    if key in _upfirdn2d_cuda_cache:
-        return _upfirdn2d_cuda_cache[key]
-
-    # Forward op.
-    class Upfirdn2dCuda(torch.autograd.Function):
-        @staticmethod
-        def forward(ctx, x, f): # pylint: disable=arguments-differ
-            assert isinstance(x, torch.Tensor) and x.ndim == 4
-            if f is None:
-                f = torch.ones([1, 1], dtype=torch.float32, device=x.device)
-            assert isinstance(f, torch.Tensor) and f.ndim in [1, 2]
-            y = x
-            if f.ndim == 2:
-                y = _plugin.upfirdn2d(y, f, upx, upy, downx, downy, padx0, padx1, pady0, pady1, flip_filter, gain)
-            else:
-                y = _plugin.upfirdn2d(y, f.unsqueeze(0), upx, 1, downx, 1, padx0, padx1, 0, 0, flip_filter, np.sqrt(gain))
-                y = _plugin.upfirdn2d(y, f.unsqueeze(1), 1, upy, 1, downy, 0, 0, pady0, pady1, flip_filter, np.sqrt(gain))
-            ctx.save_for_backward(f)
-            ctx.x_shape = x.shape
-            return y
-
-        @staticmethod
-        def backward(ctx, dy): # pylint: disable=arguments-differ
-            f, = ctx.saved_tensors
-            _, _, ih, iw = ctx.x_shape
-            _, _, oh, ow = dy.shape
-            fw, fh = _get_filter_size(f)
-            p = [
-                fw - padx0 - 1,
-                iw * upx - ow * downx + padx0 - upx + 1,
-                fh - pady0 - 1,
-                ih * upy - oh * downy + pady0 - upy + 1,
-            ]
-            dx = None
-            df = None
-
-            if ctx.needs_input_grad[0]:
-                dx = _upfirdn2d_cuda(up=down, down=up, padding=p, flip_filter=(not flip_filter), gain=gain).apply(dy, f)
-
-            assert not ctx.needs_input_grad[1]
-            return dx, df
-
-    # Add to cache.
-    _upfirdn2d_cuda_cache[key] = Upfirdn2dCuda
-    return Upfirdn2dCuda
-
-#----------------------------------------------------------------------------
-
-def filter2d(x, f, padding=0, flip_filter=False, gain=1, impl='cuda'):
-    r"""Filter a batch of 2D images using the given 2D FIR filter.
-
-    By default, the result is padded so that its shape matches the input.
-    User-specified padding is applied on top of that, with negative values
-    indicating cropping. Pixels outside the image are assumed to be zero.
-
-    Args:
-        x:           Float32/float64/float16 input tensor of the shape
-                     `[batch_size, num_channels, in_height, in_width]`.
-        f:           Float32 FIR filter of the shape
-                     `[filter_height, filter_width]` (non-separable),
-                     `[filter_taps]` (separable), or
-                     `None` (identity).
-        padding:     Padding with respect to the output. Can be a single number or a
-                     list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]`
-                     (default: 0).
-        flip_filter: False = convolution, True = correlation (default: False).
-        gain:        Overall scaling factor for signal magnitude (default: 1).
-        impl:        Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`).
-
-    Returns:
-        Tensor of the shape `[batch_size, num_channels, out_height, out_width]`.
-    """
-    padx0, padx1, pady0, pady1 = _parse_padding(padding)
-    fw, fh = _get_filter_size(f)
-    p = [
-        padx0 + fw // 2,
-        padx1 + (fw - 1) // 2,
-        pady0 + fh // 2,
-        pady1 + (fh - 1) // 2,
-    ]
-    return upfirdn2d(x, f, padding=p, flip_filter=flip_filter, gain=gain, impl=impl)
-
-#----------------------------------------------------------------------------
-
-def upsample2d(x, f, up=2, padding=0, flip_filter=False, gain=1, impl='cuda'):
-    r"""Upsample a batch of 2D images using the given 2D FIR filter.
-
-    By default, the result is padded so that its shape is a multiple of the input.
-    User-specified padding is applied on top of that, with negative values
-    indicating cropping. Pixels outside the image are assumed to be zero.
-
-    Args:
-        x:           Float32/float64/float16 input tensor of the shape
-                     `[batch_size, num_channels, in_height, in_width]`.
-        f:           Float32 FIR filter of the shape
-                     `[filter_height, filter_width]` (non-separable),
-                     `[filter_taps]` (separable), or
-                     `None` (identity).
-        up:          Integer upsampling factor. Can be a single int or a list/tuple
-                     `[x, y]` (default: 1).
-        padding:     Padding with respect to the output. Can be a single number or a
-                     list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]`
-                     (default: 0).
-        flip_filter: False = convolution, True = correlation (default: False).
-        gain:        Overall scaling factor for signal magnitude (default: 1).
-        impl:        Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`).
-
-    Returns:
-        Tensor of the shape `[batch_size, num_channels, out_height, out_width]`.
-    """
-    upx, upy = _parse_scaling(up)
-    padx0, padx1, pady0, pady1 = _parse_padding(padding)
-    fw, fh = _get_filter_size(f)
-    p = [
-        padx0 + (fw + upx - 1) // 2,
-        padx1 + (fw - upx) // 2,
-        pady0 + (fh + upy - 1) // 2,
-        pady1 + (fh - upy) // 2,
-    ]
-    return upfirdn2d(x, f, up=up, padding=p, flip_filter=flip_filter, gain=gain*upx*upy, impl=impl)
-
-#----------------------------------------------------------------------------
-
-def downsample2d(x, f, down=2, padding=0, flip_filter=False, gain=1, impl='cuda'):
-    r"""Downsample a batch of 2D images using the given 2D FIR filter.
-
-    By default, the result is padded so that its shape is a fraction of the input.
-    User-specified padding is applied on top of that, with negative values
-    indicating cropping. Pixels outside the image are assumed to be zero.
-
-    Args:
-        x:           Float32/float64/float16 input tensor of the shape
-                     `[batch_size, num_channels, in_height, in_width]`.
-        f:           Float32 FIR filter of the shape
-                     `[filter_height, filter_width]` (non-separable),
-                     `[filter_taps]` (separable), or
-                     `None` (identity).
-        down:        Integer downsampling factor. Can be a single int or a list/tuple
-                     `[x, y]` (default: 1).
-        padding:     Padding with respect to the input. Can be a single number or a
-                     list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]`
-                     (default: 0).
-        flip_filter: False = convolution, True = correlation (default: False).
-        gain:        Overall scaling factor for signal magnitude (default: 1).
-        impl:        Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`).
-
-    Returns:
-        Tensor of the shape `[batch_size, num_channels, out_height, out_width]`.
-    """
-    downx, downy = _parse_scaling(down)
-    padx0, padx1, pady0, pady1 = _parse_padding(padding)
-    fw, fh = _get_filter_size(f)
-    p = [
-        padx0 + (fw - downx + 1) // 2,
-        padx1 + (fw - downx) // 2,
-        pady0 + (fh - downy + 1) // 2,
-        pady1 + (fh - downy) // 2,
-    ]
-    return upfirdn2d(x, f, down=down, padding=p, flip_filter=flip_filter, gain=gain, impl=impl)
-
-#----------------------------------------------------------------------------

spaces/CosmicSage/Linaqruf-anything-v3.0pruned/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/Linaqruf/anything-v3.0").launch()

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/httpx/_compat.py

@@ -1,43 +0,0 @@
-"""
-The _compat module is used for code which requires branching between different
-Python environments. It is excluded from the code coverage checks.
-"""
-import ssl
-import sys
-
-# Brotli support is optional
-# The C bindings in `brotli` are recommended for CPython.
-# The CFFI bindings in `brotlicffi` are recommended for PyPy and everything else.
-try:
-    import brotlicffi as brotli
-except ImportError:  # pragma: no cover
-    try:
-        import brotli
-    except ImportError:
-        brotli = None
-
-if sys.version_info >= (3, 10) or (
-    sys.version_info >= (3, 7) and ssl.OPENSSL_VERSION_INFO >= (1, 1, 0, 7)
-):
-
-    def set_minimum_tls_version_1_2(context: ssl.SSLContext) -> None:
-        # The OP_NO_SSL* and OP_NO_TLS* become deprecated in favor of
-        # 'SSLContext.minimum_version' from Python 3.7 onwards, however
-        # this attribute is not available unless the ssl module is compiled
-        # with OpenSSL 1.1.0g or newer.
-        # https://docs.python.org/3.10/library/ssl.html#ssl.SSLContext.minimum_version
-        # https://docs.python.org/3.7/library/ssl.html#ssl.SSLContext.minimum_version
-        context.minimum_version = ssl.TLSVersion.TLSv1_2
-
-else:
-
-    def set_minimum_tls_version_1_2(context: ssl.SSLContext) -> None:
-        # If 'minimum_version' isn't available, we configure these options with
-        # the older deprecated variants.
-        context.options |= ssl.OP_NO_SSLv2
-        context.options |= ssl.OP_NO_SSLv3
-        context.options |= ssl.OP_NO_TLSv1
-        context.options |= ssl.OP_NO_TLSv1_1
-
-
-__all__ = ["brotli", "set_minimum_tls_version_1_2"]

spaces/DVLH/consciousAI-question-answering-roberta-vsgshshshsbase-s-v2/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/consciousAI/question-answering-roberta-base-s-v2").launch()

spaces/Dao3/MBTI_Test/README.md

@@ -1,14 +0,0 @@
----
-title: MBTI_Test
-emoji: 🐨
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 3.20.1
-app_file: app.py
-pinned: false
-license: cc-by-4.0
-duplicated_from: Dao3/XiaoZhaoZhao
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Datasculptor/MusicGen/CHANGELOG.md

@@ -1,23 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
-
-## [0.0.2a] - TBD
-
-Improved demo, fixed top p (thanks @jnordberg).
-
-Compressor tanh on output to avoid clipping with some style (especially piano).
-Now repeating the conditioning periodically if it is too short.
-
-More options when launching Gradio app locally (thanks @ashleykleynhans).
-
-Testing out PyTorch 2.0 memory efficient attention.
-
-Added extended generation (infinite length) by slowly moving the windows.
-Note that other implementations exist: https://github.com/camenduru/MusicGen-colab.
-
-## [0.0.1] - 2023-06-09
-
-Initial release, with model evaluation only.

spaces/DaweiZ/toy-gpt/Dockerfile

@@ -1,28 +0,0 @@
-# read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-# you will also find guides on how best to write your Dockerfile
-
-FROM python:3.11
-
-# Set up a new user named "user" with user ID 1000
-RUN useradd -m -u 1000 user
-
-# Switch to the "user" user
-USER user
-
-# Set home to the user's home directory
-ENV HOME=/home/user \
-	PATH=/home/user/.local/bin:$PATH
-
-# Set the working directory to the user's home directory
-WORKDIR $HOME/app
-
-# Try and run pip command after setting the user with `USER user` to avoid permission issues with Python
-RUN pip install --no-cache-dir --upgrade pip
-
-# Copy the current directory contents into the container at $HOME/app setting the owner to the user
-COPY --chown=user . $HOME/app
-
-RUN pip install --no-cache-dir --upgrade -r $HOME/app/requirements.txt
-
-
-CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

spaces/Deevyankar/Deep-AD/README.md

@@ -1,13 +0,0 @@
----
-title: Deep-AD
-emoji: 🧠
-colorFrom: red
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-python_version: 3.8.15
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/EdBianchi/Social_Toximeter/app.py

@@ -1,156 +0,0 @@
-from tkinter.ttk import setup_master
-from turtle import color
-from sklearn.model_selection import PredefinedSplit
-import streamlit as st
-# UTILITY
-import joblib
-import pickle
-from joblib import load
-# NLP
-import re
-import nltk
-from nltk.corpus import stopwords
-from nltk.tokenize import word_tokenize
-from nltk import SnowballStemmer
-from gensim.models.doc2vec import Doc2Vec
-import numpy as np
-
-comment = ""
-tresh1 = 0.500
-tresh2 = 0.937
-tresh3 = 0.999
-
-
-# set page setting
-st.set_page_config(page_title='Toxic Comments')
-
-# set history var
-if 'history' not in st.session_state:
-    st.session_state.history = []
-
-# import similarity (to be cached)
-@st.cache(persist=True)
-def importModel(filename):
-    model = load(filename)
-    return model
-
-@st.cache(persist=True, allow_output_mutation=True)
-def importD2V(filename):
-    model = Doc2Vec.load(filename)
-    return model
-
-@st.cache(persist=True)
-def loadPickle(filename):
-    file = pickle.load(open(filename, 'rb'))
-    return file
-
-@st.cache(persist=True)
-def loadPunkt():
-    nltk.download('punkt')
-
-with st.spinner('Loading the models, this could take some time...'):
-    loadPunkt()
-    normalizer = importModel("normalizerD2V.joblib")
-    classifier = importModel("toxicCommModel.joblib")
-    model_d2v = importD2V("d2v_comments.model")
-
-
-# REGEX
-def apply_regex(corpus):
-    corpus = re.sub("\S*\d\S*"," ", corpus) 
-    corpus = re.sub("\S*@\S*\s?"," ", corpus)
-    corpus = re.sub("\S*#\S*\s?"," ", corpus)
-    corpus = re.sub(r'http\S+', ' ', corpus)
-    corpus = re.sub(r'[^a-zA-Z0-9 ]', ' ',corpus)
-    corpus = corpus.replace(u'\ufffd', '8')
-    corpus = re.sub(' +', ' ', corpus)
-    return corpus
-
-# TOKENIZE TEXT - we use the Spacy library stopwords
-stop_words = loadPickle("stop_words.pkl")
-
-# TOKENIZE TEXT and STOP WORDS REMOVAL - execution (removes also the words shorter than 2 and longer than 15 chars)
-def tokenize(doc):
-    tokens_1 = word_tokenize(str(doc))
-    return [word.lower() for word in tokens_1 if len(word) > 1 and len(word) < 15 and word not in stop_words and not word.isdigit()]
-
-# STEMMING
-stemmer = SnowballStemmer(language="english")
-def applyStemming(listOfTokens):
-    return [stemmer.stem(token) for token in listOfTokens]
-
-# PROBS TO CLASS
-def probs_to_prediction(probs, threshold):
-    pred=[]
-    for x in probs[:,1]:
-        if x>=threshold:
-            pred = 1
-        else:
-            pred = 0
-    return pred
-
-
-# PROCESSING
-def compute(comment, tresh):
-    global preds
-    global probs
-    global stems
-    stems = ""
-    preds = []
-    comment = apply_regex(comment)
-    comment = tokenize(comment)
-    comment = applyStemming(comment)
-    stems = comment
-
-    vectorizedComment =  model_d2v.infer_vector(comment, epochs=70)
-    normComment = normalizer.transform([vectorizedComment])
-    probs = classifier.predict_proba(normComment)
-    for t in tresh:
-        preds.append(probs_to_prediction(probs, t))
-
-    with st.container():
-        col1, col2, col6 = st.columns(3)
-        #col1.metric("Toxic", round(preds[0][1], 4))
-        #col2.metric("Non Toxic", round(1-preds[0][1], 4))
-        col1.metric("Toxic", round(probs[0][1], 4))
-        col2.metric("", "")
-        col6.metric("Non Toxic", round(probs[0][0], 4))
-    st.markdown("""---""") 
-    display()
-    return None
-
-def display():
-    with st.container():
-        st.write("#### Different classification outputs at different threshold values:")
-        col3, col4, col5 = st.columns(3)
-        col3.metric("", "TOXIC" if preds[0]==1 else "NON TOXIC", delta = 0.500)
-        col4.metric("", "TOXIC" if preds[1]==1 else "NON TOXIC", delta = 0.937)
-        col5.metric("", "TOXIC" if preds[2]==1 else "NON TOXIC", delta = 0.999)
-    st.markdown("""---""")
-    with st.container():
-        st.write("#### Result of the NLP Pipeline:")
-        st.write(stems)
-    return None
-
-# TITLE
-st.write("# ☢️ Toxic Comments Classification ☢️")
-st.write("#### Drop a comment and wait for toxicity.")
-
-# INPUT TEXTBOX
-comment = st.text_area('', "Drop your comment here! 😎")
-    
-# IMPUT THRESHOLD
-#tresh = st.slider('Set the Threshold, default 0.5', 0.000, 1.000, step=0.0001, value=0.500)
-compute(comment, [tresh1, tresh2, tresh3])
-
-# sidebar
-st.sidebar.write("""
-This is a Toxic Comment Classifier that uses tokenization, stemming, Doc2Vec encoding and tuned logistic regression model.
-It's been trained on a large corpus of comments.
-
-A threshold is used to convert the predicted probability of toxicity into a categorical class [toxic, non toxic]. 
-
-The value of the threshold can be chosen accordingly to the final application of the classifier. 
-
-Here are presented three sample thresholds to see the differences on the final output.
-""")

spaces/Elbhnasy/Eye-Tracking-Diagnosis/app.py

@@ -1,78 +0,0 @@
-### 1. Imports and class names setup ###
-import gradio as gr
-import os
-import torch
-
-from model import create_ResNetb34_model
-from timeit import default_timer as timer
-from typing import Tuple, Dict
-
-# Setup class names
-class_names = ["Autistic", "Non_Autistic"]
-
-### 2. Model and transforms preparation ###
-
-
-resnet34, resnet34_transforms = create_ResNetb34_model(num_classes=len(class_names) )
-
-# Load saved weights
-resnet34.load_state_dict(torch.load(f="eyetracking_model.pth",
-                                    map_location=torch.device("cpu"),))
-### 3. Predict function ###
-# Create predict function
-def predict(img)-> Tuple[Dict, float]:
-    """
-    Transforms and performs a prediction on img.
-    :param img: target image .
-    :return: prediction and time taken.
-    """
-    # Start the timer
-    start_time=timer()
-    # Transform the target image and add a batch dimension
-    img=img.convert('RGB')
-    img = resnet34_transforms(img).unsqueeze(0)
-    # put model into evaluation mode and turn infarance mode
-    resnet34.eval()
-    with torch.inference_mode():
-
-        # Pass the transformed image through the model and turn the prediction logits into prediction probabilities
-        pred_probs=torch.softmax(resnet34(img),dim=1)
-    # Create a prediction label and prediction probability dictionary for each prediction class (this is the required format for Gradio's output parameter)
-
-    pred_labels_and_probs={class_names[i]:float(pred_probs[0][i]) for i in range(len(class_names))}
-    # Calculate the prediction time
-    pred_time = round(timer() - start_time, 5)
-
-    # Return the prediction dictionary and prediction time
-    return pred_labels_and_probs, pred_time
-
-### 4. Gradio app ###
-example_list = [["examples/" + example] for example in os.listdir("examples")]
-
-# Create title, description and article strings
-import gradio as gr
-
-# Create title, description and article strings
-title = "Eye Tracking diagnosis"
-description = """A feature extractor computer vision model to Identification of Autism in Children Using visualization of eyetracking records and Deep Neural Networks."""
-
-
-article = """Eye-tracking is the process of capturing, tracking and measuring eye movements or the absolute point of gaze (POG), which refers to the point where the eye gaze is focused in the visual scene. 
- **Visualization of Eye-tracking Scanpaths** represents the sequence of consecutive fixations and saccades as a trace through time and space that may overlap itself.
-  We used pre-trained CNN model ResNet34 as feature extractors and a DNN model as a binary classifier to identify autism in children accurately.
-We used a publicly available dataset to train the suggested models, which consisted of Visualization of Eye-tracking Scanpaths of children diagnosed with autism and controls classed as autistic and non-autistic. The Resnet34
-model outperformed the others, with an accuracy of 95.41%."""
-
-# Create the Gradio demo
-demo = gr.Interface(fn=predict, # mapping function from input to output
-                    inputs=gr.Image(type="pil",source="upload"), # what are the inputs?
-                    outputs=[gr.Label(num_top_classes=2, label="Predictions"), # what are the outputs?
-                             gr.Number(label="Prediction time (s)")], # our fn has two outputs, therefore we have two outputs
-                    examples=example_list,
-                    title=title,
-                    description=description,
-                    article=article)
-
-
-# Launch the demo!
-demo.launch()

spaces/EleutherAI/VQGAN_CLIP/CLIP/tests/test_consistency.py

@@ -1,25 +0,0 @@
-import numpy as np
-import pytest
-import torch
-from PIL import Image
-
-import clip
-
-
-@pytest.mark.parametrize('model_name', clip.available_models())
-def test_consistency(model_name):
-    device = "cpu"
-    jit_model, transform = clip.load(model_name, device=device, jit=True)
-    py_model, _ = clip.load(model_name, device=device, jit=False)
-
-    image = transform(Image.open("CLIP.png")).unsqueeze(0).to(device)
-    text = clip.tokenize(["a diagram", "a dog", "a cat"]).to(device)
-
-    with torch.no_grad():
-        logits_per_image, _ = jit_model(image, text)
-        jit_probs = logits_per_image.softmax(dim=-1).cpu().numpy()
-
-        logits_per_image, _ = py_model(image, text)
-        py_probs = logits_per_image.softmax(dim=-1).cpu().numpy()
-
-    assert np.allclose(jit_probs, py_probs, atol=0.01, rtol=0.1)

spaces/EleutherAI/VQGAN_CLIP/taming-transformers/setup.py

@@ -1,13 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name='taming-transformers',
-    version='0.0.1',
-    description='Taming Transformers for High-Resolution Image Synthesis',
-    packages=find_packages(),
-    install_requires=[
-        'torch',
-        'numpy',
-        'tqdm',
-    ],
-)

spaces/Enderfga/mtCNN_sysu/utils/tool.py

@@ -1,117 +0,0 @@
-import numpy as np
-import time
-
-def IoU(box, boxes):
-    """Compute IoU between detect box and gt boxes
-
-    Parameters:
-    ----------
-    box: numpy array , shape (5, ): x1, y1, x2, y2, score
-        input box
-    boxes: numpy array, shape (n, 4): x1, y1, x2, y2
-        input ground truth boxes
-
-    Returns:
-    -------
-    ovr: numpy.array, shape (n, )
-        IoU
-    """
-    box_area = (box[2] - box[0] + 1) * (box[3] - box[1] + 1)
-    area = (boxes[:, 2] - boxes[:, 0] + 1) * (boxes[:, 3] - boxes[:, 1] + 1)
-    xx1 = np.maximum(box[0], boxes[:, 0])
-    yy1 = np.maximum(box[1], boxes[:, 1])
-    xx2 = np.minimum(box[2], boxes[:, 2])
-    yy2 = np.minimum(box[3], boxes[:, 3])
-
-    # compute the width and height of the bounding box
-    w = np.maximum(0, xx2 - xx1 + 1)
-    h = np.maximum(0, yy2 - yy1 + 1)
-
-    inter = w * h
-    ovr = np.true_divide(inter,(box_area + area - inter))
-    #ovr = inter / (box_area + area - inter)
-    return ovr
-
-
-def convert_to_square(bbox):
-    """Convert bbox to square
-
-    Parameters:
-    ----------
-    bbox: numpy array , shape n x 5
-        input bbox
-
-    Returns:
-    -------
-    square bbox
-    """
-    square_bbox = bbox.copy()
-
-    h = bbox[:, 3] - bbox[:, 1] + 1
-    w = bbox[:, 2] - bbox[:, 0] + 1
-    max_side = np.maximum(h,w)
-    square_bbox[:, 0] = bbox[:, 0] + w*0.5 - max_side*0.5
-    square_bbox[:, 1] = bbox[:, 1] + h*0.5 - max_side*0.5
-    square_bbox[:, 2] = square_bbox[:, 0] + max_side - 1
-    square_bbox[:, 3] = square_bbox[:, 1] + max_side - 1
-    return square_bbox
-
-# non-maximum suppression: eleminates the box which have large interception with the box which have the largest score
-def nms(dets, thresh, mode="Union"):
-    """
-    greedily select boxes with high confidence
-    keep boxes overlap <= thresh
-    rule out overlap > thresh
-    :param dets: [[x1, y1, x2, y2 score]]
-    :param thresh: retain overlap <= thresh
-    :return: indexes to keep
-    """
-    x1 = dets[:, 0]
-    y1 = dets[:, 1]
-    x2 = dets[:, 2]
-    y2 = dets[:, 3]
-    scores = dets[:, 4]
-
-    # shape of x1 = (454,), shape of scores = (454,)
-    # print("shape of x1 = {0}, shape of scores = {1}".format(x1.shape, scores.shape))
-    # time.sleep(5)
-
-    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
-    order = scores.argsort()[::-1] # argsort: ascending order then [::-1] reverse the order --> descending order
-    # print("shape of order {0}".format(order.size)) # (454,)
-    # time.sleep(5)
-
-    # eleminates the box which have large interception with the box which have the largest score in order
-    # matain the box with largest score and boxes don't have large interception with it
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(i)
-        xx1 = np.maximum(x1[i], x1[order[1:]])
-        yy1 = np.maximum(y1[i], y1[order[1:]])
-        xx2 = np.minimum(x2[i], x2[order[1:]])
-        yy2 = np.minimum(y2[i], y2[order[1:]])
-
-        w = np.maximum(0.0, xx2 - xx1 + 1)
-        h = np.maximum(0.0, yy2 - yy1 + 1)
-        inter = w * h
-
-        # cacaulate the IOU between box which have largest score with other boxes
-        if mode == "Union":
-            # area[i]: the area of largest score
-            ovr = inter / (areas[i] + areas[order[1:]] - inter)
-        elif mode == "Minimum":
-            ovr = inter / np.minimum(areas[i], areas[order[1:]])
-        
-
-        inds = np.where(ovr <= thresh)[0]
-        order = order[inds + 1] # +1: eliminates the first element in order
-        # print(inds)
-        # print("shape of order {0}".format(order.shape))  # (454,)
-        # time.sleep(2)
-
-    return keep
-
-
-
-

spaces/EronSamez/RVC_HFmeu/lib/uvr5_pack/lib_v5/nets_123812KB.py

@@ -1,122 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-from . import layers_123821KB as layers
-
-
-class BaseASPPNet(nn.Module):
-    def __init__(self, nin, ch, dilations=(4, 8, 16)):
-        super(BaseASPPNet, self).__init__()
-        self.enc1 = layers.Encoder(nin, ch, 3, 2, 1)
-        self.enc2 = layers.Encoder(ch, ch * 2, 3, 2, 1)
-        self.enc3 = layers.Encoder(ch * 2, ch * 4, 3, 2, 1)
-        self.enc4 = layers.Encoder(ch * 4, ch * 8, 3, 2, 1)
-
-        self.aspp = layers.ASPPModule(ch * 8, ch * 16, dilations)
-
-        self.dec4 = layers.Decoder(ch * (8 + 16), ch * 8, 3, 1, 1)
-        self.dec3 = layers.Decoder(ch * (4 + 8), ch * 4, 3, 1, 1)
-        self.dec2 = layers.Decoder(ch * (2 + 4), ch * 2, 3, 1, 1)
-        self.dec1 = layers.Decoder(ch * (1 + 2), ch, 3, 1, 1)
-
-    def __call__(self, x):
-        h, e1 = self.enc1(x)
-        h, e2 = self.enc2(h)
-        h, e3 = self.enc3(h)
-        h, e4 = self.enc4(h)
-
-        h = self.aspp(h)
-
-        h = self.dec4(h, e4)
-        h = self.dec3(h, e3)
-        h = self.dec2(h, e2)
-        h = self.dec1(h, e1)
-
-        return h
-
-
-class CascadedASPPNet(nn.Module):
-    def __init__(self, n_fft):
-        super(CascadedASPPNet, self).__init__()
-        self.stg1_low_band_net = BaseASPPNet(2, 32)
-        self.stg1_high_band_net = BaseASPPNet(2, 32)
-
-        self.stg2_bridge = layers.Conv2DBNActiv(34, 16, 1, 1, 0)
-        self.stg2_full_band_net = BaseASPPNet(16, 32)
-
-        self.stg3_bridge = layers.Conv2DBNActiv(66, 32, 1, 1, 0)
-        self.stg3_full_band_net = BaseASPPNet(32, 64)
-
-        self.out = nn.Conv2d(64, 2, 1, bias=False)
-        self.aux1_out = nn.Conv2d(32, 2, 1, bias=False)
-        self.aux2_out = nn.Conv2d(32, 2, 1, bias=False)
-
-        self.max_bin = n_fft // 2
-        self.output_bin = n_fft // 2 + 1
-
-        self.offset = 128
-
-    def forward(self, x, aggressiveness=None):
-        mix = x.detach()
-        x = x.clone()
-
-        x = x[:, :, : self.max_bin]
-
-        bandw = x.size()[2] // 2
-        aux1 = torch.cat(
-            [
-                self.stg1_low_band_net(x[:, :, :bandw]),
-                self.stg1_high_band_net(x[:, :, bandw:]),
-            ],
-            dim=2,
-        )
-
-        h = torch.cat([x, aux1], dim=1)
-        aux2 = self.stg2_full_band_net(self.stg2_bridge(h))
-
-        h = torch.cat([x, aux1, aux2], dim=1)
-        h = self.stg3_full_band_net(self.stg3_bridge(h))
-
-        mask = torch.sigmoid(self.out(h))
-        mask = F.pad(
-            input=mask,
-            pad=(0, 0, 0, self.output_bin - mask.size()[2]),
-            mode="replicate",
-        )
-
-        if self.training:
-            aux1 = torch.sigmoid(self.aux1_out(aux1))
-            aux1 = F.pad(
-                input=aux1,
-                pad=(0, 0, 0, self.output_bin - aux1.size()[2]),
-                mode="replicate",
-            )
-            aux2 = torch.sigmoid(self.aux2_out(aux2))
-            aux2 = F.pad(
-                input=aux2,
-                pad=(0, 0, 0, self.output_bin - aux2.size()[2]),
-                mode="replicate",
-            )
-            return mask * mix, aux1 * mix, aux2 * mix
-        else:
-            if aggressiveness:
-                mask[:, :, : aggressiveness["split_bin"]] = torch.pow(
-                    mask[:, :, : aggressiveness["split_bin"]],
-                    1 + aggressiveness["value"] / 3,
-                )
-                mask[:, :, aggressiveness["split_bin"] :] = torch.pow(
-                    mask[:, :, aggressiveness["split_bin"] :],
-                    1 + aggressiveness["value"],
-                )
-
-            return mask * mix
-
-    def predict(self, x_mag, aggressiveness=None):
-        h = self.forward(x_mag, aggressiveness)
-
-        if self.offset > 0:
-            h = h[:, :, :, self.offset : -self.offset]
-            assert h.size()[3] > 0
-
-        return h