Update parquet files (step 118 of 249)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download and Install QuickBooks Desktop Pro 2021 with These Easy Steps.md

@@ -1,59 +0,0 @@
-
-<h1>How to Download and Install QuickBooks Desktop Pro 2021</h1>
-<p>QuickBooks Desktop Pro 2021 is the latest version of the popular accounting software for small and medium-sized businesses. It offers new features and improvements that can help you manage your finances more efficiently and effectively. In this article, we will show you how to download and install QuickBooks Desktop Pro 2021 on your computer.</p>
-<h2>2021 quickbooks desktop pro download</h2><br /><p><b><b>Download Zip</b> &raquo; <a href="https://byltly.com/2uKvfV">https://byltly.com/2uKvfV</a></b></p><br /><br />
-<h2>Step 1: Download QuickBooks Desktop Pro 2021</h2>
-<p>To download QuickBooks Desktop Pro 2021, you need to have a valid license or subscription from Intuit. You can purchase one from their official website or from a trusted reseller. Once you have your license or subscription, you can follow these steps to download the software:</p>
-<ul>
-<li>Go to <a href="https://downloads.quickbooks.com/app/qbdt/products">https://downloads.quickbooks.com/app/qbdt/products</a> and select your country.</li>
-<li>Enter your product and license number in the fields provided and click <b>Search</b>.</li>
-<li>Select <b>QuickBooks Desktop Pro 2021</b> from the list of products and click <b>Download</b>.</li>
-<li>Save the file to a convenient location on your computer.</li>
-</ul>
-<h2>Step 2: Install QuickBooks Desktop Pro 2021</h2>
-<p>After downloading the file, you can install QuickBooks Desktop Pro 2021 by following these steps:</p>
-<ul>
-<li>Double-click the file you downloaded to launch the installer.</li>
-<li>Click <b>Yes</b> to allow the program to make changes to your computer.</li>
-<li>Select <b>I accept the terms in the license agreement</b> and click <b>Next</b>.</li>
-<li>Enter your license and product number in the fields provided and click <b>Next</b>.</li>
-<li>Select <b>Express</b> as the installation type and click <b>Next</b>.</li>
-<li>Select where you want to install QuickBooks Desktop Pro 2021 and click <b>Install</b>.</li>
-<li>Wait for the installation to complete and click <b>Open QuickBooks</b>.</li>
-</ul>
-<h2>Congratulations! You have successfully downloaded and installed QuickBooks Desktop Pro 2021 on your computer.</h2>
-<p>You can now start using the software to manage your business finances. If you need any help or support, you can visit the official website of Intuit or contact their customer service team. You can also check out their online community forums and tutorials for more tips and tricks on how to use QuickBooks Desktop Pro 2021.</p>
-
-<h2>What's New in QuickBooks Desktop Pro 2021?</h2>
-<p>QuickBooks Desktop Pro 2021 comes with several new features and enhancements that can make your accounting tasks easier and faster. Some of the highlights include:</p>
-<ul>
-<li><b>Improved bank feeds</b>: You can now connect your bank accounts and credit cards to QuickBooks Desktop Pro 2021 and automatically download and categorize your transactions. You can also customize the rules for matching and adding transactions to save time and reduce errors.</li>
-<li><b>Receipt management</b>: You can now scan and upload your receipts to QuickBooks Desktop Pro 2021 and attach them to your transactions. You can also use the QuickBooks Desktop mobile app to capture and upload receipts on the go. This can help you track your expenses and prepare for tax time.</li>
-<li><b>Data level permissions</b>: You can now set up different levels of access for your users based on the data they need to see and work with. You can also assign specific roles and permissions to your employees, contractors, and accountants. This can help you protect your sensitive data and prevent unauthorized changes.</li>
-<li><b>Automated statements</b>: You can now schedule and send recurring statements to your customers automatically. You can also customize the frequency, format, and content of your statements. This can help you improve your cash flow and customer satisfaction.</li>
-</ul>
-<h2>How to Upgrade to QuickBooks Desktop Pro 2021?</h2>
-<p>If you are already using an older version of QuickBooks Desktop Pro, you can easily upgrade to QuickBooks Desktop Pro 2021 without losing any of your data or settings. You just need to follow these steps:</p>
-<p></p>
-<ul>
-<li>Make sure you have a backup of your company file before upgrading.</li>
-<li>Download QuickBooks Desktop Pro 2021 from the link provided in Step 1 above.</li>
-<li>Run the installer and follow the instructions on the screen.</li>
-<li>Select <b>Upgrade</b> as the installation type and choose the version of QuickBooks Desktop Pro you are currently using.</li>
-<li>Click <b>Next</b> and follow the prompts to complete the upgrade process.</li>
-<li>Open QuickBooks Desktop Pro 2021 and verify that your company file is updated and working properly.</li>
-</ul>
-<h2>How to Get Started with QuickBooks Desktop Pro 2021?</h2>
-<p>If you are new to QuickBooks Desktop Pro, you can get started with QuickBooks Desktop Pro 2021 by following these steps:</p>
-<ul>
-<li>Create a new company file or use the sample company file provided by QuickBooks Desktop Pro 2021.</li>
-<li>Set up your company information, preferences, chart of accounts, products and services, customers, vendors, employees, etc.</li>
-<li>Connect your bank accounts and credit cards to QuickBooks Desktop Pro 2021 and download your transactions.</li>
-<li>Scan and upload your receipts to QuickBooks Desktop Pro 2021 and attach them to your transactions.</li>
-<li>Create invoices, bills, estimates, sales receipts, payments, etc. for your customers and vendors.</li>
-<li>Record deposits, transfers, checks, etc. for your bank accounts and credit cards.</li>
-<li>Reconcile your bank accounts and credit cards with QuickBooks Desktop Pro 2021.</li>
-<li>Run reports and statements to monitor your business performance and financial health.</li>
-</ul></p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Forza Horizon 5 Download Ios.md

@@ -1,31 +0,0 @@
-
-<h1>How to Download and Play Forza Horizon 5 on iOS Devices</h1>
-<p>Forza Horizon 5 is the latest installment of the popular racing game series developed by Playground Games and published by Microsoft. The game is set in Mexico, where you can explore a diverse and stunning open world with hundreds of cars to choose from. You can race, drift, stunt, and customize your vehicles as you compete in various events and challenges.</p>
-<h2>forza horizon 5 download ios</h2><br /><p><b><b>Download Zip</b> &#10002; &#10002; &#10002; <a href="https://byltly.com/2uKA7b">https://byltly.com/2uKA7b</a></b></p><br /><br />
-<p>If you are an iOS user, you might be wondering if you can play Forza Horizon 5 on your iPhone or iPad. The good news is that you can, thanks to a mobile version of the game that is available on the App Store. The mobile version of Forza Horizon 5 offers the same gameplay and graphics as the console and PC versions, but with some optimizations and adjustments for touch controls and smaller screens.</p>
-<p>In this article, we will show you how to download and play Forza Horizon 5 on your iOS devices in a few simple steps.</p>
-<h2>Step 1: Go to the App Store</h2>
-<p>The first step is to go to the App Store on your iOS device and search for Forza Horizon 5. You can also use this link to access the game page directly. You will see a screen with some information and screenshots of the game, as well as a download button.</p>
-<h2>Step 2: Download the game</h2>
-<p>The next step is to tap on the download button and wait for the game to be installed on your device. The game size is about 345 MB, so make sure you have enough space and a stable internet connection. You might also need to enter your Apple ID and password to confirm the download.</p>
-<h2>Step 3: Launch the game</h2>
-<p>Once the download is complete, you can launch the game from your home screen or app library. You will see a splash screen with the Forza Horizon 5 logo and some loading animations. The game might take some time to load depending on your device performance and network speed.</p>
-<p></p>
-<h2>Step 4: Enjoy the game</h2>
-<p>After the game loads, you will see a main menu with some options to start playing. You can choose between solo or online modes, customize your profile and settings, view your achievements and leaderboards, and more. You can also access a tutorial that will teach you the basics of the game controls and mechanics.</p>
-<p>To play the game, you will need to use touch gestures on your screen to steer, accelerate, brake, drift, and activate special features. You can also tilt your device to use motion controls if you prefer. The game will adapt to your skill level and preferences as you progress through the game.</p>
-<h2>Conclusion</h2>
-<p>In this article, we have shown you how to download and play Forza Horizon 5 on your iOS devices. We hope this guide was helpful and easy to follow. Now you can enjoy one of the best racing games ever made on your iPhone or iPad anytime and anywhere.</p>
-
-<h2>Some Tips and Tricks for Forza Horizon 5 on iOS</h2>
-<p>If you want to get the most out of Forza Horizon 5 on your iOS devices, here are some tips and tricks that might help you:</p>
-<ul>
-<li>Use the photo mode to capture and share your best moments in the game. You can access the photo mode by tapping on the camera icon on the top right corner of the screen. You can adjust the camera angle, zoom, focus, filters, and more. You can also save and share your photos with your friends or on social media.</li>
-<li>Complete the seasonal events and challenges to earn rewards and unlock new cars and features. You can view the current season and its objectives by tapping on the calendar icon on the top left corner of the screen. You can also join online events and races with other players around the world.</li>
-<li>Upgrade and customize your cars to improve their performance and appearance. You can access the garage by tapping on the car icon on the bottom left corner of the screen. You can change the paint, wheels, decals, spoilers, and more. You can also tune your car's engine, suspension, brakes, and more.</li>
-<li>Explore the map and discover hidden secrets and locations. You can access the map by tapping on the compass icon on the bottom right corner of the screen. You can zoom in and out, move around, and set waypoints. You can also find collectibles, barn finds, speed traps, danger signs, and more.</li>
-<li>Have fun and experiment with different cars and modes. You can switch between different cars by tapping on the car icon on the top center of the screen. You can also change the difficulty level, weather, time of day, and more by tapping on the settings icon on the top right corner of the screen.</li>
-</ul>
-<p>Forza Horizon 5 is a game that offers endless possibilities and fun for racing fans. Whether you want to race, drift, stunt, or explore, you will find something to enjoy in this game. Download Forza Horizon 5 on your iOS devices today and experience the thrill of driving in Mexico.</p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/5.1 Surround Sound Tamil Mp3 Songs UPD Free Download.md

@@ -1,6 +0,0 @@
-<h2>5.1 surround sound tamil mp3 songs free download</h2><br /><p><b><b>Download Zip</b> > <a href="https://imgfil.com/2uy09I">https://imgfil.com/2uy09I</a></b></p><br /><br />
-
-Welcome to Movie World Tamil Film Flicks YouTube Channel Movie World Entertainments is the leading ... Download Hungama Play app to get access to unlimited free movies, latest music videos, kids ... Manzoor sakhirani all mp3 songs download ... Sec 5.1 geometric and algebra connections linear equations answers. 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Android Oyun Clubs Dark Riddle APK Hile The Most Challenging and Scary Game Ever.md

@@ -1,82 +0,0 @@
-
-<h1>Dark Riddle APK Hile Android Oyun Club: A Review</h1>
-<p>If you are looking for a game that combines escape, adventure and puzzle elements with stealth, humor and mystery, you might want to check out Dark Riddle. This is a popular game on the Android platform that lets you explore your neighbor's house and discover his secrets. But what if you want to enjoy the game without any limitations or interruptions? That's where Dark Riddle APK Hile comes in. This is a modded version of the game that gives you unlimited money and removes ads and in-app purchases. In this article, we will review Dark Riddle APK Hile and tell you how to download and install it from Android Oyun Club. We will also discuss the features, benefits, drawbacks and risks of using this modded version.</p>
-<h2>What is Dark Riddle?</h2>
-<h3>A game of escape, adventure and puzzle</h3>
-<p>Dark Riddle is a game developed by Nika Entertainment that was released in 2019. It is inspired by other games like Hello Neighbor and Granny, where you have to sneak into your neighbor's house and find out what he is hiding. You can use various items and tools to distract, trick or fight your neighbor, who will chase you if he sees you. You can also interact with other characters and objects in the game world, such as animals, cars, plants and more. The game has different levels and modes, each with its own challenges and surprises.</p>
-<h2>dark riddle apk hile android oyun club</h2><br /><p><b><b>Download Zip</b> &#9734;&#9734;&#9734; <a href="https://urlin.us/2uSZ6K">https://urlin.us/2uSZ6K</a></b></p><br /><br />
-<h3>A game of stealth, humor and mystery</h3>
-<p>Dark Riddle is not just a game of escape, adventure and puzzle. It is also a game of stealth, humor and mystery. You have to use your skills and creativity to avoid being detected by your neighbor, who has a lot of traps and cameras in his house. You can also use your sense of humor to prank your neighbor or make him laugh. The game has a lot of funny moments and dialogues that will make you smile. Moreover, the game has a lot of mystery and suspense that will keep you hooked. You will want to know more about your neighbor's secrets and motives, as well as the story behind the game.</p>
-<h2>What is Dark Riddle APK Hile?</h2>
-<h3>A modded version of the game with unlimited money</h3>
-<p>Dark Riddle APK Hile is a modded version of the game that gives you unlimited money. This means that you can buy anything you want in the game without worrying about the cost. You can get all the items, skins and weapons that are available in the game store. You can also upgrade your skills and abilities to make yourself stronger and faster. With unlimited money, you can enjoy the game without any restrictions or limitations.</p>
-<h3>A way to enjoy the game without ads or in-app purchases</h3>
-<p>Dark Riddle APK Hile is also a way to enjoy the game without ads or in-app purchases. This means that you can play the game without any interruptions or annoyances. You don't have to watch any ads or spend any real money to get extra features or resources in the game. You can play the game smoothly and comfortably without any hassle or pressure.</p>
-<h2>How to <h2>How to download and install Dark Riddle APK Hile?</h2>
-<h3>The steps to download the file from Android Oyun Club</h3>
-<p>Dark Riddle APK Hile is available for download from Android Oyun Club, a website that offers modded versions of various Android games. To download the file from Android Oyun Club, you need to follow these steps:</p>
-<ol>
-<li>Go to the official website of Android Oyun Club at <a href="">https://androidoyun.club/</a></li>
-<li>Search for Dark Riddle in the search bar or browse the categories to find the game.</li>
-<li>Click on the game title and scroll down to the download section.</li>
-<li>Choose the version of Dark Riddle APK Hile that you want to download and click on the download button.</li>
-<li>Wait for the download to complete and save the file on your device.</li>
-</ol>
-<h3>The steps to install the file on your device</h3>
-<p>After downloading the file from Android Oyun Club, you need to install it on your device. To install the file on your device, you need to follow these steps:</p>
-<ol>
-<li>Go to the settings of your device and enable the option to install apps from unknown sources.</li>
-<li>Locate the downloaded file on your device and tap on it.</li>
-<li>Follow the instructions on the screen and allow the necessary permissions.</li>
-<li>Wait for the installation to finish and launch the game.</li>
-</ol>
-<h2>What are the features and benefits of Dark Riddle APK Hile?</h2>
-<h3>The features of the modded version, such as unlocked items, skins and weapons</h3>
-<p>Dark Riddle APK Hile has many features that make it different from the original version of the game. Some of these features are:</p>
-<p>This is a first-person adventure thriller with an interactive environment and interesting quests. Solve puzzles and uncover the secrets of a suspicious neighbor who lives across from you.<br />
-Your adventure begins in an unusual city where you can find many useful and unique items. You will meet a police officer and a seller of alien devices, and during the game you will get acquainted with unusual creatures. Each item and character has a huge story behind it.<br />
-The game has a lot of humor, various levels of difficulty and multiple endings - the outcome of the story depends entirely on your actions and decisions. You can use headphones to explore the city in detail and better understand the plot.</p>
-<ul>
-<li>Unlimited money: You can buy anything you want in the game without worrying about the cost.</li>
-<li>Unlocked items: You can access all the items that are available in the game store, such as flashlights, cameras, binoculars, etc.</li>
-<li>Unlocked skins: You can customize your character with different skins, such as clown, pirate, ninja, etc.</li>
-<li>Unlocked weapons: You can use different weapons to fight your neighbor, such as guns, knives, bats, etc.</li>
-</ul>
-<h3>The benefits of the modded version, such as more fun, freedom and challenge</h3>
-<p>Dark Riddle APK Hile has many benefits that make it more fun, freedom and challenge than the original version of the game. Some of these benefits are:</p>
-<ul>
-<li>More fun: You can enjoy the game without any limitations or interruptions. You can prank your neighbor or make him laugh with your humor and creativity.</li>
-<li>More freedom: You can explore your neighbor's house and discover his secrets without any restrictions or limitations. You can use any item or tool you want to solve puzzles and escape.</li>
-<li>More challenge: You can increase the difficulty and excitement of the game by using different weapons and skins. You can also face new challenges and surprises in each level and mode.</li>
-</ul> <h2>What are the drawbacks and risks of Dark Riddle APK Hile?</h2>
-<h3>The drawbacks of the modded version, such as possible bugs, glitches and crashes</h3>
-<p>Dark Riddle APK Hile is not a perfect version of the game. It has some drawbacks that may affect your gaming experience. Some of these drawbacks are:</p>
-<ul>
-<li>Possible bugs: The modded version may have some bugs or errors that may cause the game to malfunction or behave unexpectedly.</li>
-<li>Possible glitches: The modded version may have some glitches or flaws that may affect the graphics, sound or gameplay of the game.</li>
-<li>Possible crashes: The modded version may have some crashes or freezes that may cause the game to stop working or close abruptly.</li>
-</ul>
-<h3>The risks of the modded version, such as malware, viruses and bans</h3>
-<p>Dark Riddle APK Hile is not a safe version of the game. It has some risks that may harm your device or account. Some of these risks are:</p>
-<ul>
-<li>Possible malware: The modded version may have some malware or malicious code that may infect your device or steal your data.</li>
-<li>Possible viruses: The modded version may have some viruses or harmful programs that may damage your device or corrupt your files.</li>
-<li>Possible bans: The modded version may have some bans or penalties that may prevent you from playing the game or accessing your account.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>Dark Riddle APK Hile is a modded version of the game that gives you unlimited money and removes ads and in-app purchases. It also unlocks all the items, skins and weapons in the game. It is a way to enjoy the game without any limitations or interruptions. However, it also has some drawbacks and risks that may affect your gaming experience or harm your device or account. Therefore, you should be careful and responsible when using this modded version. You should also respect the original developers and creators of the game and support them if you like their work.</p>
-<h2>FAQs</h2>
-<ol>
-<li>Q: Is Dark Riddle APK Hile legal?</li>
-<li>A: Dark Riddle APK Hile is not legal. It is a modded version of the game that violates the terms and conditions of the original game. It also infringes the intellectual property rights of the original developers and creators of the game.</li>
-<li>Q: Is Dark Riddle APK Hile safe?</li>
-<li>A: Dark Riddle APK Hile is not safe. It is a modded version of the game that may contain malware, viruses or bans that may harm your device or account. It also may have bugs, glitches or crashes that may affect your gaming experience.</li>
-<li>Q: How to update Dark Riddle APK Hile?</li>
-<li>A: Dark Riddle APK Hile is not easy to update. It is a modded version of the game that may not be compatible with the latest version of the original game. You may need to download and install a new version of Dark Riddle APK Hile from Android Oyun Club whenever there is an update available.</li>
-<li>Q: How to uninstall Dark Riddle APK Hile?</li>
-<li>A: Dark Riddle APK Hile is easy to uninstall. You can simply delete the file from your device or go to the settings of your device and uninstall the app like any other app.</li>
-<li>Q: Where to get more information about Dark Riddle APK Hile?</li>
-<li>A: You can get more information about Dark Riddle APK Hile from Android Oyun Club, the website that offers this modded version of the game. You can also visit the official website or social media pages of Dark Riddle, the original game, to get more information about it.</li>
-</ol></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/8 Ball Pool bitAIM APK A Complete Guide to the Ultimate Pool Game Experience.md

@@ -1,146 +0,0 @@
-<br />
-<h1>What is 8 ball pool bitaim apk?</h1>
-<p>If you are a fan of pool games, you might have heard of or played 8 ball pool, one of the most popular and addictive online multiplayer games on Android. 8 ball pool is a game where you can compete with players from all over the world in various modes and tournaments, using your skills and strategies to pocket balls and win coins and rewards. But what if you want to have an edge over your opponents and improve your game performance? That's where 8 ball pool bitaim apk comes in.</p>
-<h2>8 ball pool bitaim apk</h2><br /><p><b><b>Download File</b> &middot;&middot;&middot;&middot;&middot; <a href="https://jinyurl.com/2uNSOG">https://jinyurl.com/2uNSOG</a></b></p><br /><br />
-<p>8 ball pool bitaim apk is a modded version of 8 ball pool that allows you to hack the aim of your striker and hit the pieces with perfect accuracy. With 8 ball pool bitaim apk, you can win every match and earn more coins and gems. But is 8 ball pool bitaim apk safe and legal to use? How can you download and install it on your device? And what are its features and benefits? In this article, we will answer all these questions and more, so keep reading.</p>
- <h2>How to play 8 ball pool?</h2>
-<p>Before we dive into the details of 8 ball pool bitaim apk, let's first review the basics of how to play 8 ball pool. 8 ball pool is a game played with a cue ball and fifteen object balls, numbered 1 through 15. Balls 1–7 are solid colors and commonly referred to as “low balls”, and balls 9–15 are striped and commonly referred to as “high balls.” One player must pocket balls of solid colors, while the other player must pocket the striped balls. The player who pockets their entire group and then legally pockets the 8-ball wins the game.</p>
-<p>To start the game, one player must break the rack by hitting the cue ball into the triangle of object balls. For the break shot to be legal, the breaker must either pocket a number ball or drive at least four number balls to one or more rails. No ball is called, and the cue ball is not required to hit any particular object ball first. If the breaker fails to make a legal break, the opponent can choose to break again or accept the table as it is.</p>
-<p>After a legal break, if any object ball is pocketed, then that determines whether that player has solids or stripes for that game. If no object ball is pocketed on a legal break or if both a solid and a stripe are pocketed on a legal break then it is an open table until one player pockets either a solid or stripe on their turn. Once solids or stripes have been determined for each player then they must continue shooting at their designated group until they have cleared their group from the table.</p>
-<p>A player's turn continues until they fail to pocket one of their group or <p>commit a foul. A foul occurs when the player fails to hit any ball with the cue ball, hits the wrong group of balls first, pockets the cue ball, pockets the 8-ball before clearing their group, pockets the 8-ball in the wrong pocket, or drives any ball off the table. If a player commits a foul, their opponent gets ball in hand, meaning they can place the cue ball anywhere on the table for their next shot.</p>
-<p>bitAIM app for carrom pool<br />
-bitAIM+ download apk free<br />
-bitAIM AI aim assistance tool<br />
-bitAIM for carrom pool practices<br />
-bitAIM apk latest version 3.6.54<br />
-bitAIM image recognition technique<br />
-bitAIM android app free download<br />
-bitAIM apkcombo apps tools<br />
-bitAIM app.ai.lab.bitaimplus<br />
-bitAIM apk mirror download<br />
-bitAIM carrom pool master shots<br />
-bitAIM apk file size 28 MB<br />
-bitAIM app developer bitAIM+<br />
-bitAIM apk update Aug 12, 2022<br />
-bitAIM app category tools<br />
-bitAIM apk google play id<br />
-bitAIM app installs 500+<br />
-bitAIM apk direct and indirect shot<br />
-bitAIM app description tools advertisement<br />
-bitAIM apk multi-collision of coin<br />
-bitAIM app reviews and ratings<br />
-bitAIM apk how to install<br />
-bitAIM app features and benefits<br />
-bitAIM apk compatible devices<br />
-bitAIM app screenshots and videos<br />
-bitAIM apk mod unlimited coins<br />
-bitAIM app alternatives and similar apps<br />
-bitAIM apk download for pc windows 10<br />
-bitAIM app support and contact information<br />
-bitAIM apk no root required<br />
-bitAIM app privacy policy and terms of service<br />
-bitAIM apk online generator tool<br />
-bitAIM app tips and tricks guide<br />
-bitAIM apk offline mode available<br />
-bitAIM app user feedback and suggestions<br />
-bitAIM apk safe and secure download link<br />
-bitAIM app pros and cons analysis<br />
-bitAIM apk hack version download 2023<br />
-bitAIM app frequently asked questions (FAQs)<br />
-bitAIM apk premium features unlocked</p>
-<p>The game ends when one player legally pockets the 8-ball in a designated pocket after clearing their group. The player must call the pocket for the 8-ball before shooting. If the player pockets the 8-ball in an uncalled pocket, or pockets the 8-ball and the cue ball on the same shot, they lose the game.</p>
- <h2>How to download and install bitaim apk?</h2>
-<p>Now that you know how to play 8 ball pool, you might be wondering how to get bitaim apk on your device. Bitaim apk is not available on the official Google Play Store, so you will need to download it from a third-party source. Here are the steps and requirements for downloading and installing bitaim apk:</p>
-<ol>
-<li>Make sure your device has enough storage space and meets the minimum system requirements for running 8 ball pool. The game requires Android 4.4 or higher and at least 1 GB of RAM.</li>
-<li>Enable unknown sources on your device settings. This will allow you to install apps from sources other than the Google Play Store. To do this, go to Settings > Security > Unknown Sources and toggle it on.</li>
-<li>Download bitaim apk from a reliable and trusted website. You can search for bitaim apk on Google or use this link: (https://bitaimapk.com/). Be careful not to download any fake or malicious files that might harm your device.</li>
-<li>Locate the downloaded file on your device and tap on it to start the installation process. Follow the instructions on the screen and grant the necessary permissions for the app to run.</li>
-<li>Launch 8 ball pool bitaim apk and enjoy playing with unlimited aim and accuracy.</li>
-</ol>
- <h2>What are the features of bitaim apk?</h2>
-<p>Bitaim apk is a modded version of 8 ball pool that offers many features and benefits that can enhance your gaming experience and make you a better player. Here are some of the features of bitaim apk:</p>
-<ul>
-<li><strong>AI assistance:</strong> Bitaim apk uses artificial intelligence to help you aim and shoot with precision. It shows you the trajectory and angle of your shots, as well as the best possible pocket for each ball. You can also adjust the sensitivity and speed of your aim according to your preference.</li>
-<li><strong>Shots recording:</strong> Bitaim apk allows you to record your shots and replay them later. You can use this feature to analyze your mistakes and improve your skills. You can also share your shots with your friends and challenge them to beat your score.</li>
-<li><strong>No ads:</strong> Bitaim apk removes all the annoying ads that interrupt your gameplay and distract you from your focus. You can play without any interruptions and enjoy a smooth and seamless gaming experience.</li>
-<li><strong>No root required:</strong> Bitaim apk does not require root access to work on your device. You can use it without any risk of damaging your device or voiding its warranty.</li>
-<li><strong>Free updates:</strong> Bitaim apk provides free updates for its users, ensuring that they always have access to the latest features and bug fixes.</li>
-</ul>
- <h2>How to use bitaim apk?</h2>
-<p>Using bitaim apk is very easy and simple. All you need to do is follow these steps:</p>
-<ol>
-<li>Launch 8 ball pool bitaim apk on your device and log in with your account or create a new one.</li>
-<li>Select a game mode or tournament that you want to play and join a match.</li>
-<li>When it is your turn to shoot, you will see a green line showing you the direction and angle of your shot. You can also see a yellow circle indicating the best pocket for each ball.</li>
-<li>To adjust your aim, swipe left or right on the screen. To adjust your power, swipe up or down on the screen.</li>
-<li>To shoot, tap on the screen when you are ready.</li>
-<li>Enjoy winning every match with perfect accuracy and skill.</li>
-</ol>
- <h3>How to activate indirect or premium shots?</h3>
-<p>Bitaim apk also offers indirect or premium shots, which are more advanced and challenging shots that require more skill and strategy. Indirect shots are shots that involve hitting one or more rails before pocketing a ball. Premium shots are shots that involve using spin, curve, or jump to pocket a ball. To activate indirect or premium shots, you need to pay a certain amount of coins or gems, depending on the level of difficulty and reward. Here is a table showing the cost and benefit of each type of shot: | Type of shot | Cost | Benefit | | --- | --- | --- | | Indirect shot | 50 coins or 5 gems | Double the coins or gems you win | | Premium shot | 100 coins or 10 gems | Triple the coins or gems you win | To activate indirect or premium shots, you need to tap on the icon that appears on the top right corner of the screen before shooting. You can choose between coins or gems as the payment method. Once you activate the shot, you will see a blue line showing you the trajectory and angle of your shot, as well as a red circle indicating the spin, curve, or jump effect. You can adjust your shot as usual and then shoot when you are ready. <h3>How to use bitaim apk with Lulubox?</h3>
-<p>Lulubox is another popular app that can enhance your gaming experience by providing you with various features and hacks for different games. Lulubox is compatible with 8 ball pool bitaim apk, and you can use them together to get more benefits and advantages. Here are some of the features that Lulubox can offer for 8 ball pool:</p>
-<ul>
-<li><strong>Unlimited coins and gems:</strong> Lulubox can help you get unlimited coins and gems for 8 ball pool, which you can use to buy cues, tables, chat packs, and more. You can also use them to activate indirect or premium shots without any cost.</li>
-<li><strong>Free skins and themes:</strong> Lulubox can help you customize your game with free skins and themes for your cues, tables, and background. You can choose from a variety of options and styles to suit your preference.</li>
-<li><strong>No verification required:</strong> Lulubox can help you bypass the verification process that 8 ball pool requires for some features and functions. You can use Lulubox to access all the features and functions without any hassle.</li>
-</ul>
-<p>To use bitaim apk with Lulubox, you need to follow these steps:</p>
-<ol>
-<li>Download and install Lulubox from a reliable and trusted website. You can search for Lulubox on Google or use this link: (https://www.luluboxapk.com/).</li>
-<li>Launch Lulubox on your device and grant the necessary permissions for the app to run.</li>
-<li>Find 8 ball pool bitaim apk on the list of games that Lulubox supports and tap on it.</li>
-<li>Select the features that you want to activate for 8 ball pool bitaim apk and tap on the launch button.</li>
-<li>Enjoy playing 8 ball pool bitaim apk with Lulubox.</li>
-</ol>
- <h3>How to update bitaim apk?</h3>
-<p>Bitaim apk is constantly updated by its developers to ensure that it works smoothly and efficiently with the latest version of 8 ball pool. To update bitaim apk, you need to follow these steps:</p>
-<ol>
-<li>Check if there is a new version of bitaim apk available on the website where you downloaded it from. You can also check for updates within the app itself by tapping on the menu button and then on the update option.</li>
-<li>If there is a new version available, download it from the website or from the app.</li>
-<li>Delete the old version of bitaim apk from your device.</li>
-<li>Install the new version of bitaim apk following the same steps as before.</li>
-<li>Launch 8 ball pool bitaim apk and enjoy playing with the latest features and bug fixes.</li>
-</ol>
- <h2>What are the pros and cons of bitaim apk?</h2>
-<p>Bitaim apk is a modded version of 8 ball pool that offers many features and benefits that can enhance your gaming experience and make you a better player. However, it also has some drawbacks and risks that you should be aware of before using it. Here are some of the pros and cons of bitaim apk:</p>
- | Pros | Cons | | --- | --- | | It helps you aim and shoot with perfect accuracy. | It takes away some of the challenge and fun of playing 8 ball pool. | | It allows you to win every match and earn more coins and gems. | It may be considered cheating by some players and may ruin their gaming experience. | | It removes all the ads that interrupt your gameplay. | It may not be compatible with some devices or versions of 8 ball pool. | | It does not require root access to work on your device. | It may expose your device to malware or viruses from unknown sources. | | It provides free updates for its users. | It may get detected and banned by the game developers or moderators. | <h2>What are some alternatives to bitaim apk?</h2>
-<p>If you are looking for some alternatives to bitaim apk, you might want to check out these other apps that can provide similar or better features for 8 ball pool:</p>
-<ul>
-<li><strong>8 Ball Pool Mod Menu:</strong> This is another modded version of 8 ball pool that offers unlimited coins and gems, long line, anti-ban, and more. You can download it from this link: (https://8ballpoolmodmenu.com/).</li>
-<li><strong>8 Ball Pool Tool:</strong> This is an app that helps you calculate the angle and power of your shots, as well as the best pocket for each ball. You can download it from this link: (https://play.google.com/store/apps/details?id=com.eivaagames.EightBallPoolToolFree&hl=en_US&gl=US).</li>
-<li><strong>8 Ball Pool Guideline Hack:</strong> This is an app that shows you the guideline of your shots, even in no guideline mode. You can download it from this link: (https://play.google.com/store/apps/details?id=com.guideline.hack&hl=en_US&gl=US).</li>
-</ul>
- <h2>Conclusion</h2>
-<p>8 ball pool bitaim apk is a modded version of 8 ball pool that allows you to hack the aim of your striker and hit the pieces with perfect accuracy. It offers many features and benefits that can enhance your gaming experience and make you a better player, such as AI assistance, shots recording, no ads, no root required, and free updates. However, it also has some drawbacks and risks that you should be aware of before using it, such as cheating, compatibility issues, malware threats, and ban risks. Therefore, you should use it at your own discretion and responsibility.</p>
-<p>If you want to download and install bitaim apk on your device, you can follow the steps and requirements that we have provided in this article. You can also use bitaim apk with Lulubox to get more features and hacks for 8 ball pool. Alternatively, you can check out some other apps that can provide similar or better features for 8 ball pool, such as 8 Ball Pool Mod Menu, 8 Ball Pool Tool, and 8 Ball Pool Guideline Hack.</p>
-<p>We hope that this article has helped you understand what is 8 ball pool bitaim apk and how to use it effectively and safely. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading and happy gaming!</p>
- <h3>FAQs</h3>
-<p>Here are some of the frequently asked questions and answers about 8 ball pool bitaim apk:</p>
-<ol>
-<li><strong>Q: Is 8 ball pool bitaim apk safe and legal to use?</strong></li>
-<li>A: Bitaim apk is not safe or legal to use, as it is a modded version of 8 ball pool that violates the terms and conditions of the game. It may expose your device to malware or viruses from unknown sources, and it may get detected and banned by the game developers or moderators. Therefore, you should use it at your own risk and responsibility.</li>
-<li><strong>Q: How can I avoid getting banned by using bitaim apk?</strong></li>
-<li>A: There is no guarantee that you will not get banned by using bitaim apk, as it is a modded version of 8 ball pool that violates the terms and conditions of the game. However, you can try to reduce the chances of getting banned by following these tips:</li>
-<ul>
-<li>Do not use bitaim apk in ranked or tournament matches, as they are more likely to be monitored by the game developers or moderators.</li>
-<li>Do not use bitaim apk excessively or obviously, as it may arouse suspicion from other players or observers.</li>
-<li>Do not brag or boast about using bitaim apk, as it may attract unwanted attention or reports from other players or observers.</li>
-<li>Do not share your account or device with anyone else who might use bitaim apk, as it may compromise your security and privacy.</li>
-</ul>
-<li><strong>Q: Can I use bitaim apk with other mods or hacks for 8 ball pool?</strong></li>
-<li>A: Bitaim apk is compatible with some other mods or hacks for 8 ball pool, such as Lulubox. However, you should be careful not to use too many mods or hacks at the same time, as they may cause conflicts or errors in your game performance. You should also be aware that using more mods or hacks may increase the risk of getting banned by the game developers or moderators.</li>
-<li><strong>Q: How can I contact the developers of bitaim apk?</strong></li>
-<li>A: Bitaim apk is developed by a team of anonymous and independent developers who do not have an official website or social media account. Therefore, it is difficult to contact them directly or get support from them. However, you can try to leave a comment or feedback on the website where you downloaded bitaim apk from, and hope that they will see it and respond to it.</li>
-<li><strong>Q: What are some tips and tricks for playing 8 ball pool?</strong></li>
-<li>A: 8 ball pool is a game that requires skill, strategy, and practice to master. Here are some tips and tricks that can help you improve your game and win more matches:</li>
-<ul>
-<li>Practice your aim and power by playing in offline mode or practice mode.</li>
-<li>Learn the different types of shots and when to use them, such as straight shots, bank shots, cut shots, spin shots, curve shots, and jump shots.</li>
-<li>Use the right cue for the right situation, and upgrade your cues with coins or gems to increase their attributes, such as aim, power, spin, and time.</li>
-<li>Plan your shots ahead and think about the position of the cue ball and the object balls after each shot.</li>
-<li>Use the chat feature to communicate with your opponent and show your sportsmanship.</li>
-</ul>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Boost Your Brain Power with Mental Arithmetic Techniques.md

@@ -1,111 +0,0 @@
-
-<h1>How to Practice and Improve Your Mental Arithmetic Skills</h1>
-<p>Mental arithmetic is the skill of doing calculations in your head without using any tools or devices, such as a calculator, pen and paper, or abacus. It is a valuable skill that can help you in many everyday situations, such as shopping, cooking, traveling, and more. It can also improve your number sense, logical thinking, memory, and speed of computation.</p>
-<h2>mental aritmetik</h2><br /><p><b><b>DOWNLOAD</b> &bull; <a href="https://jinyurl.com/2uNLX1">https://jinyurl.com/2uNLX1</a></b></p><br /><br />
-<p>But how do you practice and improve your mental arithmetic skills? What are some tips and techniques that can make it easier and faster? And what are some games and resources that can challenge you and make it fun? In this article, we will answer these questions and provide you with some useful information on how to become a master of mental math.</p>
- <h2>Tips and Techniques for Mental Arithmetic</h2>
-<p>There are many tips and techniques that can help you perform mental arithmetic more efficiently and accurately. Here are some of the most common ones:</p>
- <h3>Break down the problems into parts</h3>
-<p>One of the easiest ways to simplify mental arithmetic problems is to break them down into smaller parts that are easier to handle. For example, if you need to add or subtract several numbers, you can group them by their place value (hundreds, tens, ones) and add or subtract them separately. For example:</p>
-<p>712 + 281 = (700 + 200) + (10 + 80) + (2 + 1) = 900 + 90 + 3 = 993</p>
-<p>815 - 521 = (800 - 500) + (10 - 20) + (5 - 1) = 300 - 10 + 4 = 294</p>
-<p>mental aritmetik eğitimi<br />
-mental aritmetik kursu<br />
-mental aritmetik nedir<br />
-mental aritmetik nasıl yapılır<br />
-mental aritmetik faydaları<br />
-mental aritmetik örnekleri<br />
-mental aritmetik kitabı<br />
-mental aritmetik abaküs<br />
-mental aritmetik uygulaması<br />
-mental aritmetik sertifikası<br />
-mental aritmetik beyin gelişimi<br />
-mental aritmetik hafıza teknikleri<br />
-mental aritmetik zeka testi<br />
-mental aritmetik online eğitim<br />
-mental aritmetik ders programı<br />
-mental aritmetik egzersizleri<br />
-mental aritmetik çarpım tablosu<br />
-mental aritmetik matematik oyunları<br />
-mental aritmetik soru bankası<br />
-mental aritmetik öğretmeni<br />
-mental aritmetik franchise<br />
-mental aritmetik yorumları<br />
-mental aritmetik videoları<br />
-mental aritmetik çalışma saatleri<br />
-mental aritmetik fiyatları<br />
-mental aritmetik indirim kuponu<br />
-mental aritmetik başarı hikayeleri<br />
-mental aritmetik sınav soruları<br />
-mental aritmetik öğrenci girişi<br />
-mental aritmetik veli bilgilendirme sistemi<br />
-mental aritmetik iş ilanları<br />
-mental aritmetik bayilik şartları<br />
-mental aritmetik seminerleri<br />
-mental aritmetik yarışması<br />
-mental aritmetik kampı<br />
-mental aritmetik blog yazıları<br />
-mental aritmetik sosyal medya hesapları<br />
-mental aritmetik web sitesi tasarımı<br />
-mental aritmetik logo tasarımı<br />
-mental aritmetik broşür tasarımı</p>
- <h3>Use round numbers and adjust later</h3>
-<p>Another way to make mental arithmetic easier is to use round numbers that are close to the original ones and adjust the answer later by adding or subtracting the difference. For example:</p>
-<p>596 + 380 = (600 + 380) - 4 = 980 - 4 = 976</p>
-<p>38 x 3 = (40 x 3) - (2 x 3) = 120 - 6 = 114</p>
- <h3>Reorder the numbers to make convenient sums</h3>
-<p>Sometimes, you can reorder the numbers in an addition or subtraction problem to make convenient sums that are easy to remember or work with. For example, you can look for numbers that add up to a multiple of 10 or a power of 10. For example:</p>
-<p>7 + 4 + 9 + 13 + 6 + 51 = (7 + 13) + (9 +51) + (6 +4) =20 +60+10=90</p>
-<p>1000+20+1000+30+1000+40+1000+10=4000+100=4100</p>
- <h3>Multiply from left to right</h3> <h3>Use square numbers and roots</h3>
-<p>Square numbers are the result of multiplying a number by itself, such as 4 × 4 = 16 or 9 × 9 = 81. Knowing some common square numbers can help you with mental arithmetic, especially when you need to multiply or divide large numbers. For example:</p>
-<p>48 × 52 = (50 − 2) × (50 + 2) = 50² − 2² = 2500 − 4 = 2496</p>
-<p>Here, we used the identity (a − b) × (a + b) = a² − b² to simplify the problem. We also used the fact that 50² = 2500, which is easy to remember.</p>
-<p>Roots are the opposite of squares. The square root of a number is the number that, when multiplied by itself, gives that number. For example, the square root of 16 is 4, because 4 × 4 = 16. Finding square roots mentally can be tricky, but there are some methods that can help you estimate them or find them exactly. For example:</p>
-<p>To estimate the square root of a number, find the two nearest square numbers and use them as a guide. For example, to estimate the square root of 75, we can use the fact that 64 < 75 < 81, and that the square roots of 64 and 81 are 8 and 9, respectively. Therefore, the square root of 75 is between 8 and 9, closer to 9 than to 8.</p>
-<p>To find the exact square root of a number, use the fact that the difference between two consecutive square numbers is equal to the sum of their square roots. For example, to find the square root of 169, we can use the fact that 169 − 144 = 25, and that the square roots of 169 and 144 are x and 12, respectively. Therefore, x + 12 = 25, and x = 13.</p>
- <h3>Estimate and approximate</h3>
-<p>Sometimes, you don't need to find the exact answer to a mental arithmetic problem, but only an estimate or an approximation. This can save you time and effort, and still give you a reasonable idea of the magnitude of the answer. Estimating and approximating can involve various techniques, such as rounding numbers, using benchmarks or reference points, using fractions or percentages, or using compatible numbers. For example:</p>
-<p>To estimate how much money you will save by buying a shirt that is on sale for $24.99 instead of $29.99, you can round both prices to the nearest dollar and subtract them: $30 − $25 = $5. This is not the exact answer, but it is close enough for most purposes.</p>
-<p>To approximate how many hours are in a year, you can use the benchmark that one year is about 365 days, and multiply it by 24: 365 × 24 = (360 +5) ×24=360×24+5×24=8640+120=8760. This is not the exact answer either, because it does not account for leap years or fractional hours, but it is a good approximation.</p>
- <h2>Games and Resources for Mental Arithmetic</h2>
-<p>If you want to practice and improve your mental arithmetic skills further, there are many games and resources that you can use to challenge yourself and have fun. Here are some examples:</p>
- <h3>Math Trainer</h3>
-<p>Math Trainer is a free online tool that lets you practice mental arithmetic with different types of problems and difficulty levels. You can choose from addition, subtraction, multiplication, division, mixed operations, fractions, decimals, percentages, powers and roots. You can also set a time limit and track your progress and accuracy.</p>
- <h3>Mental Math Cards</h3>
-<p>Mental Math Cards is a free app for iOS and Android devices that helps you practice mental arithmetic with flashcards. You can customize your settings to choose from different operations, number ranges, decimal places and time limits. You can also view your statistics and achievements.</p>
- <h3>Arithmetic Game</h3>
-<p>Arithmetic Game is a free online game that tests your mental arithmetic skills with four basic operations: addition, subtraction, multiplication and division. You have to fill in the blanks with the correct numbers to complete the equations as fast as you can. You can choose from three difficulty levels: easy, normal and hard.</p>
- <h3>Prodigy Game</h3>
-<p>Prodigy Game is a free online game that combines math skills with an adventure story. You have to create your own character and explore a fantasy world where you have to solve math problems to progress and unlock new features. You can choose from different topics and skills, such as mental arithmetic, fractions, geometry, algebra and more. You can also play with your friends and compete with other players. Prodigy Game is available for free on the web, or as an app for iOS and Android devices.</p>
- <h3>Mathnasium</h3>
-<p>Mathnasium is a learning center that offers personalized math tutoring and instruction for students of all ages and levels. Mathnasium uses a unique method that helps students develop their mental arithmetic skills, as well as their conceptual understanding, problem-solving abilities and confidence in math. Mathnasium has over 1,000 locations across the US and Canada, and you can find the nearest one to you on their website.</p>
- <h2>Conclusion</h2>
-<p>Mental arithmetic is a skill that can benefit you in many ways, both in school and in life. It can help you perform calculations faster and more accurately, improve your number sense and logical thinking, enhance your memory and concentration, and save you time and resources. By practicing some tips and techniques, such as breaking down problems, using round numbers, reordering numbers, multiplying from left to right, using square numbers and roots, and estimating and approximating, you can make mental arithmetic easier and more efficient. You can also use some games and resources, such as Math Trainer, Mental Math Cards, Arithmetic Game, Prodigy Game and Mathnasium, to challenge yourself and have fun while learning mental arithmetic.</p>
- <h2>FAQs</h2>
-<p>Here are some common questions and answers about mental arithmetic:</p>
- <h3>Q: How can I improve my mental arithmetic speed?</h3>
-<p>A: To improve your mental arithmetic speed, you need to practice regularly and consistently. You can use some of the games and resources mentioned above to practice different types of problems and difficulty levels. You can also set a time limit for yourself and try to beat your own records. The more you practice, the more familiar you will become with the numbers and the operations, and the faster you will be able to perform them.</p>
- <h3>Q: What are some benefits of mental arithmetic for children?</h3>
-<p>A: Mental arithmetic can help children develop their math skills from an early age. It can help them understand the meaning and relationships of numbers, operations, fractions, decimals, percentages and more. It can also help them improve their logical thinking, reasoning, creativity, memory and concentration. Mental arithmetic can also boost their confidence and motivation in math, as they can see their progress and achievements.</p>
- <h3>Q: What are some challenges of mental arithmetic?</h3>
-<p>A: Mental arithmetic can be challenging for some people because it requires a lot of attention, focus and mental effort. It can also be affected by factors such as stress, anxiety, fatigue or distraction. Some people may also have difficulties with certain types of problems or operations, such as division or fractions. To overcome these challenges, it is important to practice mental arithmetic in a relaxed and positive environment, start with simple problems and gradually increase the complexity, use some tips and techniques to simplify the problems, check your answers for accuracy, and seek help or feedback if needed.</p>
- <h3>Q: What are some applications of mental arithmetic in real life?</h3>
-<p>A: Mental arithmetic can be useful in many real-life situations, such as:</p>
-<ul>
-<li>Shopping: You can use mental arithmetic to compare prices, calculate discounts, taxes or tips, or make a budget.</li>
-<li>Cooking: You can use mental arithmetic to measure ingredients, convert units or temperatures, or adjust recipes.</li>
-<li>Traveling: You can use mental arithmetic to plan your itinerary, convert currencies or distances, or estimate time or costs.</li>
-<li>Gaming: You can use mental arithmetic to keep score, strategize or optimize your moves, or increase your chances of winning.</li>
-<li>Learning: You can use mental arithmetic to reinforce your math skills, learn new concepts or topics, or prepare for exams or tests.</li>
-</ul>
- <h3>Q: How can I make mental arithmetic fun?</h3>
-<p>A: There are many ways to make mental arithmetic fun, such as:</p>
-<ul>
-<li>Playing games: You can play some of the games mentioned above or create your own games with cards, dice, coins, or other objects. You can also play with your friends or family and make it a competition or a collaboration.</li>
-<li>Using real-life scenarios: You can use mental arithmetic to solve problems or answer questions that relate to your interests, hobbies, or goals. For example, you can use mental arithmetic to calculate how much money you need to save for a trip, how many calories you burn in a workout, or how many books you can read in a year.</li>
-<li>Setting goals and rewards: You can set goals for yourself to improve your mental arithmetic skills, such as solving a certain number of problems in a given time, reaching a certain level of difficulty, or learning a new technique or trick. You can also reward yourself for achieving your goals, such as buying yourself a treat, watching your favorite show, or doing something fun.</li>
-</ul>
- <p>I hope you enjoyed this article and learned something new about mental arithmetic. If you have any questions or comments, feel free to leave them below. And don't forget to practice and have fun with mental arithmetic!</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Enjoy Clash of Clans APK with Unlimited Gems Gold and Elixir.md

@@ -1,94 +0,0 @@
-
-<h1>Clash of Clans Orjinal APK: How to Download and Play the Epic Strategy Game</h1>
- <p>Clash of Clans is one of the most popular and addictive strategy games in the world. Millions of players worldwide join forces to build their villages, train their troops, and fight in epic clan wars. If you are looking for a fun and challenging game that will keep you entertained for hours, you should definitely try Clash of Clans. But how can you download and play the game on your Android device? In this article, we will show you how to get the orjinal APK of Clash of Clans, which is the official version of the game from a trusted source. We will also give you some tips and tricks on how to play the game and become a successful clasher.</p>
-<h2>clash of clans orjinal apk</h2><br /><p><b><b>DOWNLOAD</b> &#187;&#187;&#187; <a href="https://jinyurl.com/2uNL75">https://jinyurl.com/2uNL75</a></b></p><br /><br />
- <h2>What is Clash of Clans?</h2>
- <p>Clash of Clans is a strategy game that was released in 2012 by Supercell, a Finnish game developer. The game is set in a fantasy world where you can create your own village, customize it with various buildings and defenses, and collect resources such as gold, elixir, and dark elixir. You can also recruit different types of troops, such as barbarians, archers, wizards, dragons, and more, and use them to attack other players' villages or defend your own. The game also features a multiplayer mode where you can join or create a clan, which is a group of players who can chat, donate troops, and participate in clan wars. Clan wars are special events where two clans face each other in a series of attacks and try to earn more stars than their opponents. The game also has a single-player mode where you can fight against the goblin king and his army in a campaign mode.</p>
- <h2>Why Download the Orjinal APK?</h2>
- <p>The orjinal APK of Clash of Clans is the official version of the game that you can download from Google Play Store or from Supercell's website. There are many advantages of downloading the orjinal APK instead of using unofficial or modded versions of the game. Some of these advantages are:</p>
- <ul>
-<li>You can enjoy the latest updates and features of the game as soon as they are released by Supercell.</li>
-<li>You can avoid any potential risks or problems that may come with using unverified or hacked versions of the game, such as viruses, malware, bans, or loss of data.</li>
-<li>You can support Supercell as a developer and help them continue making great games for their fans.</li>
-</ul>
- <h2>How to Download and Install the Orjinal APK?</h2>
- <p>Downloading and installing the orjinal APK of Clash of Clans is very easy and simple. Just follow these steps:</p>
- <ol>
-<li>Go to Google Play Store on your Android device and search for Clash of Clans. Alternatively, you can go to Supercell's website (https://supercell.com/en/games/clashofclans/) and click on "Download Now".</li>
-<li>Tap on "Install" and wait for the download to finish.</li>
-<li>Once the download is complete, tap on "Open" and enjoy playing Clash of Clans.</li>
-</ol>
- <p>Note: If you have an existing account or village on another device, you can link it to your new device by using Supercell ID or Google Play Games. Just go to Settings > Account > Link Device or Sign In.</p>
- <h2>How to Play Clash of Clans?</h2>
- <p>Playing Clash of Clans is fun and easy once you get the hang of it. Here are some tips and tricks on how to play the game and become a successful clasher:</p>
-<p>clash of clans apk download latest version<br />
-clash of clans mod apk unlimited everything<br />
-clash of clans hack apk free download<br />
-clash of clans apk indir android oyun club<br />
-clash of clans apk update 2023<br />
-clash of clans private server apk download<br />
-clash of clans apk hile nasıl yapılır<br />
-clash of clans apk mirror download<br />
-clash of clans apk pure free download<br />
-clash of clans apk mod menu<br />
-clash of clans apk offline mode<br />
-clash of clans apk no root required<br />
-clash of clans apk yeni sürüm indir<br />
-clash of clans apk for pc windows 10<br />
-clash of clans apk full version download<br />
-clash of clans apk cheat codes<br />
-clash of clans apk hack online generator<br />
-clash of clans apk orjinal kurulumu<br />
-clash of clans apk son sürüm 2023<br />
-clash of clans apk android 4.4.2<br />
-clash of clans apk unlimited gems and coins<br />
-clash of clans apk modded by ihackedit<br />
-clash of clans apk free shopping<br />
-clash of clans apk güncelleme sorunu<br />
-clash of clans apk for ios devices<br />
-clash of clans apk mod offline unlimited money<br />
-clash of clans apk hack tool download<br />
-clash of clans apk orjinal nasıl indirilir<br />
-clash of clans apk eski sürüm indir<br />
-clash of clans apk android 11 support<br />
-clash of clans apk unlimited troops and spells<br />
-clash of clans apk mod anti ban<br />
-clash of clans apk free gems generator<br />
-clash of clans apk hileli indir 2023<br />
-clash of clans apk for fire tablet<br />
-clash of clans apk mod unlimited gold and elixir<br />
-clash of clans apk hack no survey no password<br />
-clash of clans apk orjinal yükleme yöntemi<br />
-clash of clans apk yeni güncelleme ne zaman gelecek<br />
-clash of clans apk android 5.1.1 download<br />
-clash of clans apk unlimited builder base resources<br />
-clash of clans apk mod unlock all heroes and troops<br />
-clash of clans apk free download for laptop<br />
-clash of clans apk hile yapma programı indir<br />
-clash of clans apk for chromebook download<br />
-clash of clans apk mod supercell id login fix<br />
-clash of clans apk free magic items and books<br />
-clash of clans apk hileli oyun indir club</p>
- <ul>
-<li>Build and upgrade your buildings and defenses. You can use gold and elixir to build and upgrade various structures in your village, such as town hall, barracks, army camps, walls, cannons, archer towers, mortars, and more. These structures will help you protect your village from enemy attacks and produce more resources for you.</li>
-<li>Train and upgrade your troops. You can use elixir and dark elixir to train and upgrade different types of troops in your barracks and dark barracks, such as barbarians, archers, giants, goblins, wizards, dragons, pekkas, minions, hog riders, golems, and more. These troops will help you attack other players' villages and loot their resources.</li>
-<li>Join or create a clan. You can join or create a clan by tapping on the clan castle in your village. A clan is a group of players who can chat, donate troops, and participate in clan wars. Being in a clan will give you many benefits, such as getting reinforcements from your clanmates, requesting and receiving clan gifts, earning clan perks, and more.</li>
-<li>Participate in clan wars. Clan wars are special events where two clans face each other in a series of attacks and try to earn more stars than their opponents. To participate in a clan war, you need to be in a clan and have your clan castle rebuilt. You can also opt out of the war if you don't want to participate. To win a clan war, you need to plan your attacks carefully, use your best troops and spells, scout the enemy bases, and coordinate with your clanmates.</li>
-<li>Complete achievements and events. You can earn gems, which are the premium currency of the game, by completing various achievements and events. Achievements are long-term goals that you can accomplish by playing the game regularly, such as reaching a certain town hall level, winning a number of battles, collecting a certain amount of resources, and more. Events are short-term challenges that you can complete by using specific troops or spells in battles, such as using barbarians or rage spells. Gems can be used to speed up building or troop upgrades, buy more resources or shields, or get special items.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>Clash of Clans is an epic strategy game that will keep you hooked for hours. You can download the orjinal APK of the game from Google Play Store or Supercell's website and enjoy the latest updates and features of the game. You can also learn how to play the game and become a successful clasher by following our tips and tricks. So what are you waiting for? Download Clash of Clans today and join the millions of players worldwide who are having fun building their villages, raising their clans, and fighting in clan wars.</p>
- <h2>FAQs</h2>
- <p>Here are some common questions and answers about Clash of Clans:</p>
- <h3>Q: How can I get free gems in Clash of Clans?</h3>
-<p>A: You can get free gems by completing achievements and events, removing obstacles from your village, opening gem boxes or gem mines, or participating in special offers or surveys.</p>
- <h3>Q: How can I change my name in Clash of Clans?</h3>
-<p>A: You can change your name once for free by going to Settings > Change Name. After that, you will need to pay 500 gems to change your name again.</p>
- <h3>Q: How can I transfer my village to another device?</h3>
-<p>A: You can transfer your village to another device by using Supercell ID or Google Play Games. Just go to Settings > Account > Link Device or Sign In on both devices and follow the instructions.</p>
- <h3>Q: How can I contact Supercell for support or feedback?</h3>
-<p>A: You can contact Supercell by going to Settings > Help and Support > Contact Us or by visiting their website (https://supercell.helpshift.com/a/clash-of-clans/).</p>
- <h3>Q: How can I report a bug or a player in Clash of Clans?</h3>
-<p>A: You can report a bug or a player by going to Settings > Help and Support > Report an Issue or Report Player.</p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Enjoy the Festive Season with Daystar Choirs 12 Days of Christmas MP3 Download.md

@@ -1,147 +0,0 @@
-
-<h1>How to Download 12 Days of Christmas by Daystar Choir MP3</h1>
-<p>Christmas is a season of joy, celebration, and music. One of the most festive and cheerful songs that you can listen to during this time is <strong>12 Days of Christmas by Daystar Choir</strong>. This song is a live performance by a Nigerian gospel choir that sings a medley of traditional and modern Christmas carols with a twist. It is a fun and lively song that will make you dance and sing along.</p>
-<h2>download 12 days of christmas by daystar choir mp3</h2><br /><p><b><b>Download</b> &gt;&gt;&gt;&gt;&gt; <a href="https://jinyurl.com/2uNN1z">https://jinyurl.com/2uNN1z</a></b></p><br /><br />
-<p>But how can you download this song as an MP3 file and enjoy it anytime and anywhere? In this article, we will show you where to find this song online and how to download it as an MP3 file. We will also tell you why this song is so popular and what are the benefits of downloading it as an MP3 file.</p>
- <h2>Where to Find 12 Days of Christmas by Daystar Choir MP3</h2>
-<p>There are two main ways to find this song online: online streaming platforms and free music download websites. Here are some examples of each option:</p>
- <h3>Online Streaming Platforms</h3>
-<p>Online streaming platforms are websites or apps that allow you to listen to music online without downloading it. Some of the most popular online streaming platforms that have this song are:</p>
-<ul>
-<li><strong>Spotify</strong>: Spotify is one of the largest and most popular online streaming platforms in the world. It has millions of songs, podcasts, and playlists that you can listen to for free or with a premium subscription. You can find this song on Spotify by searching for "12 Days of Christmas - Live" by Daystar Choir .</li>
-<li><strong>Shazam</strong>: Shazam is an app that can identify any song that is playing around you. It can also show you the lyrics, artist, album, genre, and other information about the song. You can also listen to the song on Shazam or connect it to other streaming platforms like Spotify, Apple Music, YouTube, etc. You can find this song on Shazam by searching for "12 Days of Christmas (Live)" by Daystar Choir.</li>
-<li><strong>YouTube</strong>: YouTube is the most popular video-sharing platform in the world. It has billions of videos, including music videos, live performances, covers, remixes, etc. You can watch and listen to this song on YouTube by searching for "Daystar Carol 2016 Ft Taiwo Tfavored in Glory Halleluyah", "Brooklyn Tabernacle Choir \" Daystar \"", or "Daystar Carol 2019 - Daystar Choir Ministration".</li>
-</ul>
- <h3>Free Music Download Websites</h3 <p>Free music download websites are websites that allow you to download music for free and legally. Some of the free music download websites that have this song are:</p>
-<p>download 12 days of christmas by daystar choir mp3 free<br />
-download 12 days of christmas by daystar choir mp3 online<br />
-download 12 days of christmas by daystar choir mp3 lyrics<br />
-download 12 days of christmas by daystar choir mp3 shazam<br />
-download 12 days of christmas by daystar choir mp3 last.fm<br />
-download 12 days of christmas by daystar choir mp3 album<br />
-download 12 days of christmas by daystar choir mp3 live<br />
-download 12 days of christmas by daystar choir mp3 video<br />
-download 12 days of christmas by daystar choir mp3 song<br />
-download 12 days of christmas by daystar choir mp3 music<br />
-download 12 days of christmas by daystar choir mp3 youtube<br />
-download 12 days of christmas by daystar choir mp3 spotify<br />
-download 12 days of christmas by daystar choir mp3 apple music<br />
-download 12 days of christmas by daystar choir mp3 soundcloud<br />
-download 12 days of christmas by daystar choir mp3 amazon music<br />
-download 12 days of christmas by daystar choir mp3 google play music<br />
-download 12 days of christmas by daystar choir mp3 deezer<br />
-download 12 days of christmas by daystar choir mp3 tidal<br />
-download 12 days of christmas by daystar choir mp3 pandora<br />
-download 12 days of christmas by daystar choir mp3 napster<br />
-download 12 days of christmas by daystar choir mp3 audiomack<br />
-download 12 days of christmas by daystar choir mp3 bandcamp<br />
-download 12 days of christmas by daystar choir mp3 reverbnation<br />
-download 12 days of christmas by daystar choir mp3 datpiff<br />
-download 12 days of christmas by daystar choir mp3 mixcloud<br />
-download 12 days of christmas by daystar choir mp3 nigerian carols<br />
-download 12 days of christmas by daystar choir mp3 ogo ni fun baba<br />
-download 12 days of christmas by daystar choir mp3 jesu yi o iwo l'ologo didan<br />
-download 12 days of christmas by daystar choir mp3 ding-dong feat taiwo oladoye<br />
-download 12 days of christmas by daystar choir mp3 glory halleluyah feat taiwo oladoye<br />
-download 12 days of christmas by daystar choir mp3 gbo ohun <br />
-download 12 days of christmas by daystar choir mp3 dulci jubilo <br />
-download 12 days of christmas by daystar choir mp3 joy festizie <br />
-download 12 days of christmas by daystar choir mp3 nina yesu ne chingtok ishaku <br />
-download 12 days of christmas by daystar choir mp3 almighty god dr pastor paul enenche <br />
-download 12 days of christmas by daystar choir mp3 nagode feat solomon lange worship for change <br />
-download 12 days of christmas by daystar choir mp3 you are the god dr paul enenche <br />
-download 12 days of christmas by daystar choir mp3 solid rock judikay <br />
-download 12 days of christmas by daystar choir mp3 elee dr pastor paul enenche <br />
-download 12 days of christmas by daystar choir mp3 alpha and omega praise and worship <br />
-how to download 12 days of christmas by daystar choir mp3 <br />
-where to download 12 days of christmas by daystar choir mp3 <br />
-best site to download 12 days of christmas by daystar choir mp3 <br />
-best app to download 12 days of christmas by daystar choir mp3 <br />
-best quality to download 12 days of christmas by daystar choir mp3 <br />
-best format to download 12 days of christmas by daystar choir mp3 <br />
-best device to download 12 days of christmas by daystar choir mp3 <br />
-best vpn to download 12 days of christmas by daystar choir mp3 <br />
-best proxy to download 12 days of christmas by daystar choir mp3 </p>
-<ul>
-<li><strong>Chosic</strong>: Chosic is a website that offers free music downloads from various genres and artists. You can also create playlists, discover new music, and share your favorites with others. You can find this song on Chosic by searching for "12 Days of Christmas - Live" by Daystar Choir.</li>
-<li><strong>Pixabay</strong>: Pixabay is a website that offers free images, videos, and music that you can use for any purpose. You can browse through thousands of royalty-free music tracks and download them in MP3 or WAV format. You can find this song on Pixabay by searching for "12 Days of Christmas" by Daystar Choir.</li>
-<li><strong>Free Music Archive</strong>: Free Music Archive is a website that provides a library of high-quality, legal audio downloads. You can explore music by genre, mood, license, or curator. You can also contribute your own music or support the artists you like. You can find this song on Free Music Archive by searching for "12 Days of Christmas - Live" by Daystar Choir.</li>
-</ul>
- <h2>How to Download 12 Days of Christmas by Daystar Choir MP3</h2>
-<p>Now that you know where to find this song online, how can you download it as an MP3 file? The process may vary depending on the source, but here are some general steps that you can follow:</p>
- <h3>From Online Streaming Platforms</h3>
-<p>If you want to download this song from online streaming platforms like Spotify, Shazam, or YouTube, you will need to use a third-party tool or app that can convert the song to MP3 format. There are many tools and apps available online, but some of the most popular ones are:</p>
-<table>
-<tr>
-<th>Tool/App</th>
-<th>Website/Download Link</th>
-<th>Features</th>
-</tr>
-<tr>
-<td><strong>4K Video Downloader</strong></td>
-<td></td>
-<td>- Supports YouTube, Spotify, SoundCloud, Vimeo, TikTok, and more<br>- Allows you to download videos, playlists, channels, subtitles, and 3D/360° videos<br>- Supports MP3, MP4, MKV, FLV, OGG, and more formats<br>- Offers high-quality and fast downloads<br>- Available for Windows, Mac, and Linux</td>
-</tr>
-<tr>
-<td><strong>AudFree Spotify Music Converter</strong></td>
-<td></td>
-<td>- Supports Spotify songs, playlists, albums, podcasts, and radio<br>- Allows you to download Spotify music offline without premium<br>- Supports MP3, FLAC, WAV, AAC, M4A, and M4B formats<br>- Offers lossless quality and 5X speed<br>- Available for Windows and Mac</td>
-</tr>
-<tr>
-<td><strong>Shazam Downloader</strong></td>
-<td></td>
-<td>- Supports Shazam songs and playlists<br>- Allows you to download Shazam music with one click<br>- Supports MP3 format<br>- Offers high-quality downloads<br>- Available for Android devices</td>
-</tr>
-</table>
- <p>To download this song from online streaming platforms using these tools or apps, you need to follow these steps:</p>
-<ol>
-<li>Open the online streaming platform and find the song that you want to download.</li>
-<li>Copy the URL or link of the song.</li>
-<li>Open the tool or app that you have chosen and paste the URL or link into the input box.</li>
-<li>Select the MP3 format and quality that you want.</li>
-<li>Click on the download or convert button and wait for the process to finish.</li>
-<li>Save the MP3 file to your device or cloud storage.</li>
-</ol>
- <h3>From Free Music Download Websites</h3 <p>If you want to download this song from free music download websites like Chosic, Pixabay, or Free Music Archive, you will not need to use any third-party tool or app. You can simply download the song directly from the website. To download this song from free music download websites, you need to follow these steps:</p>
-<ol>
-<li>Open the free music download website and search for the song that you want to download.</li>
-<li>Click on the song title or the download button or link.</li>
-<li>Select the MP3 format and quality that you want.</li>
-<li>Save the MP3 file to your device or cloud storage.</li>
-</ol>
- <h2>Conclusion</h2>
-<p>12 Days of Christmas by Daystar Choir is a wonderful song that will brighten up your Christmas season. It is a live performance by a talented gospel choir that sings a medley of classic and modern Christmas carols with a twist. It is a fun and lively song that will make you dance and sing along.</p>
-<p>You can download this song as an MP3 file and enjoy it anytime and anywhere. You can find this song online on various online streaming platforms and free music download websites. You can also use different tools and apps to convert and download the song as an MP3 file. All you need to do is follow the steps that we have shown you in this article.</p>
-<p>So what are you waiting for? Download 12 Days of Christmas by Daystar Choir MP3 today and have a merry Christmas!</p>
- <h2>FAQs</h2>
-<h4>What is Daystar Choir?</h4>
-<p>Daystar Choir is a gospel choir from Nigeria that is part of the Daystar Christian Centre. The choir is known for its annual Christmas carol concerts that feature various songs, dances, and performances. The choir has also released several albums and singles, such as "Glory Halleluyah", "Hark the Herald", and "Joy to the World".</p>
- <h4>What are some other songs by Daystar Choir?</h4>
-<p>Some other songs by Daystar Choir are:</p>
-<ul>
-<li>"O Come All Ye Faithful"</li>
-<li>"Silent Night"</li>
-<li>"We Wish You a Merry Christmas"</li>
-<li>"Jingle Bells"</li>
-<li>"Feliz Navidad"</li>
-</ul>
- <h4>How can I support Daystar Choir?</h4>
-<p>You can support Daystar Choir by:</p>
-<ul>
-<li>Following them on their social media accounts, such as Facebook, Twitter, Instagram, and YouTube</li>
-<li>Subscribing to their newsletter or blog</li>
-<li>Donating to their ministry or charity projects</li>
-<li>Purchasing their albums or merchandise</li>
-<li>Attending their concerts or events</li>
-</ul>
- <h4>What are some other Christmas songs that I can download for free?</h4 <p>Some other Christmas songs that you can download for free are:</p>
-<ul>
-<li><strong>"O Holy Night" by Josh Groban</strong>: This is a beautiful rendition of the classic Christmas hymn by the famous singer and songwriter. You can download this song for free from Chosic by searching for "O Holy Night" by Josh Groban.</li>
-<li><strong>"All I Want for Christmas Is You" by Mariah Carey</strong>: This is one of the most popular and catchy Christmas songs of all time. It is a love song that expresses the desire to be with someone special for Christmas. You can download this song for free from Pixabay by searching for "All I Want for Christmas Is You" by Mariah Carey.</li>
-<li><strong>"Jingle Bell Rock" by Bobby Helms</strong>: This is a fun and upbeat rock and roll version of the traditional Christmas song. It is a song that will make you want to dance and celebrate. You can download this song for free from Free Music Archive by searching for "Jingle Bell Rock" by Bobby Helms.</li>
-</ul>
- <p>These are just some examples of the many Christmas songs that you can download for free online. You can explore more options by browsing through the websites that we have mentioned or using other sources that you trust. Just make sure that the songs are legal and royalty-free before you download them.</p>
- <p>We hope that this article has helped you learn how to download 12 Days of Christmas by Daystar Choir MP3 and enjoy this wonderful song. We also hope that you have discovered some other Christmas songs that you can download for free and add to your holiday playlist. Have a merry Christmas and a happy new year!</p>
- <h2></h2></p> 197e85843d<br />
-<br />
-<br />

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

@@ -1,317 +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.
-
-import json
-import math
-import os
-import sys
-import time
-from dataclasses import dataclass, field
-
-import torch as th
-from torch import distributed, nn
-from torch.nn.parallel.distributed import DistributedDataParallel
-
-from .augment import FlipChannels, FlipSign, Remix, Scale, Shift
-from .compressed import get_compressed_datasets
-from .model import Demucs
-from .parser import get_name, get_parser
-from .raw import Rawset
-from .repitch import RepitchedWrapper
-from .pretrained import load_pretrained, SOURCES
-from .tasnet import ConvTasNet
-from .test import evaluate
-from .train import train_model, validate_model
-from .utils import (human_seconds, load_model, save_model, get_state,
-                    save_state, sizeof_fmt, get_quantizer)
-from .wav import get_wav_datasets, get_musdb_wav_datasets
-
-
-@dataclass
-class SavedState:
-    metrics: list = field(default_factory=list)
-    last_state: dict = None
-    best_state: dict = None
-    optimizer: dict = None
-
-
-def main():
-    parser = get_parser()
-    args = parser.parse_args()
-    name = get_name(parser, args)
-    print(f"Experiment {name}")
-
-    if args.musdb is None and args.rank == 0:
-        print(
-            "You must provide the path to the MusDB dataset with the --musdb flag. "
-            "To download the MusDB dataset, see https://sigsep.github.io/datasets/musdb.html.",
-            file=sys.stderr)
-        sys.exit(1)
-
-    eval_folder = args.evals / name
-    eval_folder.mkdir(exist_ok=True, parents=True)
-    args.logs.mkdir(exist_ok=True)
-    metrics_path = args.logs / f"{name}.json"
-    eval_folder.mkdir(exist_ok=True, parents=True)
-    args.checkpoints.mkdir(exist_ok=True, parents=True)
-    args.models.mkdir(exist_ok=True, parents=True)
-
-    if args.device is None:
-        device = "cpu"
-        if th.cuda.is_available():
-            device = "cuda"
-    else:
-        device = args.device
-
-    th.manual_seed(args.seed)
-    # Prevents too many threads to be started when running `museval` as it can be quite
-    # inefficient on NUMA architectures.
-    os.environ["OMP_NUM_THREADS"] = "1"
-    os.environ["MKL_NUM_THREADS"] = "1"
-
-    if args.world_size > 1:
-        if device != "cuda" and args.rank == 0:
-            print("Error: distributed training is only available with cuda device", file=sys.stderr)
-            sys.exit(1)
-        th.cuda.set_device(args.rank % th.cuda.device_count())
-        distributed.init_process_group(backend="nccl",
-                                       init_method="tcp://" + args.master,
-                                       rank=args.rank,
-                                       world_size=args.world_size)
-
-    checkpoint = args.checkpoints / f"{name}.th"
-    checkpoint_tmp = args.checkpoints / f"{name}.th.tmp"
-    if args.restart and checkpoint.exists() and args.rank == 0:
-        checkpoint.unlink()
-
-    if args.test or args.test_pretrained:
-        args.epochs = 1
-        args.repeat = 0
-        if args.test:
-            model = load_model(args.models / args.test)
-        else:
-            model = load_pretrained(args.test_pretrained)
-    elif args.tasnet:
-        model = ConvTasNet(audio_channels=args.audio_channels,
-                           samplerate=args.samplerate, X=args.X,
-                           segment_length=4 * args.samples,
-                           sources=SOURCES)
-    else:
-        model = Demucs(
-            audio_channels=args.audio_channels,
-            channels=args.channels,
-            context=args.context,
-            depth=args.depth,
-            glu=args.glu,
-            growth=args.growth,
-            kernel_size=args.kernel_size,
-            lstm_layers=args.lstm_layers,
-            rescale=args.rescale,
-            rewrite=args.rewrite,
-            stride=args.conv_stride,
-            resample=args.resample,
-            normalize=args.normalize,
-            samplerate=args.samplerate,
-            segment_length=4 * args.samples,
-            sources=SOURCES,
-        )
-    model.to(device)
-    if args.init:
-        model.load_state_dict(load_pretrained(args.init).state_dict())
-
-    if args.show:
-        print(model)
-        size = sizeof_fmt(4 * sum(p.numel() for p in model.parameters()))
-        print(f"Model size {size}")
-        return
-
-    try:
-        saved = th.load(checkpoint, map_location='cpu')
-    except IOError:
-        saved = SavedState()
-
-    optimizer = th.optim.Adam(model.parameters(), lr=args.lr)
-
-    quantizer = None
-    quantizer = get_quantizer(model, args, optimizer)
-
-    if saved.last_state is not None:
-        model.load_state_dict(saved.last_state, strict=False)
-    if saved.optimizer is not None:
-        optimizer.load_state_dict(saved.optimizer)
-
-    model_name = f"{name}.th"
-    if args.save_model:
-        if args.rank == 0:
-            model.to("cpu")
-            model.load_state_dict(saved.best_state)
-            save_model(model, quantizer, args, args.models / model_name)
-        return
-    elif args.save_state:
-        model_name = f"{args.save_state}.th"
-        if args.rank == 0:
-            model.to("cpu")
-            model.load_state_dict(saved.best_state)
-            state = get_state(model, quantizer)
-            save_state(state, args.models / model_name)
-        return
-
-    if args.rank == 0:
-        done = args.logs / f"{name}.done"
-        if done.exists():
-            done.unlink()
-
-    augment = [Shift(args.data_stride)]
-    if args.augment:
-        augment += [FlipSign(), FlipChannels(), Scale(),
-                    Remix(group_size=args.remix_group_size)]
-    augment = nn.Sequential(*augment).to(device)
-    print("Agumentation pipeline:", augment)
-
-    if args.mse:
-        criterion = nn.MSELoss()
-    else:
-        criterion = nn.L1Loss()
-
-    # Setting number of samples so that all convolution windows are full.
-    # Prevents hard to debug mistake with the prediction being shifted compared
-    # to the input mixture.
-    samples = model.valid_length(args.samples)
-    print(f"Number of training samples adjusted to {samples}")
-    samples = samples + args.data_stride
-    if args.repitch:
-        # We need a bit more audio samples, to account for potential
-        # tempo change.
-        samples = math.ceil(samples / (1 - 0.01 * args.max_tempo))
-
-    args.metadata.mkdir(exist_ok=True, parents=True)
-    if args.raw:
-        train_set = Rawset(args.raw / "train",
-                           samples=samples,
-                           channels=args.audio_channels,
-                           streams=range(1, len(model.sources) + 1),
-                           stride=args.data_stride)
-
-        valid_set = Rawset(args.raw / "valid", channels=args.audio_channels)
-    elif args.wav:
-        train_set, valid_set = get_wav_datasets(args, samples, model.sources)
-    elif args.is_wav:
-        train_set, valid_set = get_musdb_wav_datasets(args, samples, model.sources)
-    else:
-        train_set, valid_set = get_compressed_datasets(args, samples)
-
-    if args.repitch:
-        train_set = RepitchedWrapper(
-            train_set,
-            proba=args.repitch,
-            max_tempo=args.max_tempo)
-
-    best_loss = float("inf")
-    for epoch, metrics in enumerate(saved.metrics):
-        print(f"Epoch {epoch:03d}: "
-              f"train={metrics['train']:.8f} "
-              f"valid={metrics['valid']:.8f} "
-              f"best={metrics['best']:.4f} "
-              f"ms={metrics.get('true_model_size', 0):.2f}MB "
-              f"cms={metrics.get('compressed_model_size', 0):.2f}MB "
-              f"duration={human_seconds(metrics['duration'])}")
-        best_loss = metrics['best']
-
-    if args.world_size > 1:
-        dmodel = DistributedDataParallel(model,
-                                         device_ids=[th.cuda.current_device()],
-                                         output_device=th.cuda.current_device())
-    else:
-        dmodel = model
-
-    for epoch in range(len(saved.metrics), args.epochs):
-        begin = time.time()
-        model.train()
-        train_loss, model_size = train_model(
-            epoch, train_set, dmodel, criterion, optimizer, augment,
-            quantizer=quantizer,
-            batch_size=args.batch_size,
-            device=device,
-            repeat=args.repeat,
-            seed=args.seed,
-            diffq=args.diffq,
-            workers=args.workers,
-            world_size=args.world_size)
-        model.eval()
-        valid_loss = validate_model(
-            epoch, valid_set, model, criterion,
-            device=device,
-            rank=args.rank,
-            split=args.split_valid,
-            overlap=args.overlap,
-            world_size=args.world_size)
-
-        ms = 0
-        cms = 0
-        if quantizer and args.rank == 0:
-            ms = quantizer.true_model_size()
-            cms = quantizer.compressed_model_size(num_workers=min(40, args.world_size * 10))
-
-        duration = time.time() - begin
-        if valid_loss < best_loss and ms <= args.ms_target:
-            best_loss = valid_loss
-            saved.best_state = {
-                key: value.to("cpu").clone()
-                for key, value in model.state_dict().items()
-            }
-
-        saved.metrics.append({
-            "train": train_loss,
-            "valid": valid_loss,
-            "best": best_loss,
-            "duration": duration,
-            "model_size": model_size,
-            "true_model_size": ms,
-            "compressed_model_size": cms,
-        })
-        if args.rank == 0:
-            json.dump(saved.metrics, open(metrics_path, "w"))
-
-        saved.last_state = model.state_dict()
-        saved.optimizer = optimizer.state_dict()
-        if args.rank == 0 and not args.test:
-            th.save(saved, checkpoint_tmp)
-            checkpoint_tmp.rename(checkpoint)
-
-        print(f"Epoch {epoch:03d}: "
-              f"train={train_loss:.8f} valid={valid_loss:.8f} best={best_loss:.4f} ms={ms:.2f}MB "
-              f"cms={cms:.2f}MB "
-              f"duration={human_seconds(duration)}")
-
-    if args.world_size > 1:
-        distributed.barrier()
-
-    del dmodel
-    model.load_state_dict(saved.best_state)
-    if args.eval_cpu:
-        device = "cpu"
-        model.to(device)
-    model.eval()
-    evaluate(model, args.musdb, eval_folder,
-             is_wav=args.is_wav,
-             rank=args.rank,
-             world_size=args.world_size,
-             device=device,
-             save=args.save,
-             split=args.split_valid,
-             shifts=args.shifts,
-             overlap=args.overlap,
-             workers=args.eval_workers)
-    model.to("cpu")
-    if args.rank == 0:
-        if not (args.test or args.test_pretrained):
-            save_model(model, quantizer, args, args.models / model_name)
-        print("done")
-        done.write_text("done")
-
-
-if __name__ == "__main__":
-    main()

spaces/A666sxr/Genshin_TTS/text/__init__.py

@@ -1,56 +0,0 @@
-""" from https://github.com/keithito/tacotron """
-from text import cleaners
-from text.symbols import symbols
-
-
-# Mappings from symbol to numeric ID and vice versa:
-_symbol_to_id = {s: i for i, s in enumerate(symbols)}
-_id_to_symbol = {i: s for i, s in enumerate(symbols)}
-
-
-def text_to_sequence(text, cleaner_names):
-  '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
-    Args:
-      text: string to convert to a sequence
-      cleaner_names: names of the cleaner functions to run the text through
-    Returns:
-      List of integers corresponding to the symbols in the text
-  '''
-  sequence = []
-
-  clean_text = _clean_text(text, cleaner_names)
-  for symbol in clean_text:
-    if symbol not in _symbol_to_id.keys():
-      continue
-    symbol_id = _symbol_to_id[symbol]
-    sequence += [symbol_id]
-  return sequence
-
-
-def cleaned_text_to_sequence(cleaned_text):
-  '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
-    Args:
-      text: string to convert to a sequence
-    Returns:
-      List of integers corresponding to the symbols in the text
-  '''
-  sequence = [_symbol_to_id[symbol] for symbol in cleaned_text if symbol in _symbol_to_id.keys()]
-  return sequence
-
-
-def sequence_to_text(sequence):
-  '''Converts a sequence of IDs back to a string'''
-  result = ''
-  for symbol_id in sequence:
-    s = _id_to_symbol[symbol_id]
-    result += s
-  return result
-
-
-def _clean_text(text, cleaner_names):
-  for name in cleaner_names:
-    cleaner = getattr(cleaners, name)
-    if not cleaner:
-      raise Exception('Unknown cleaner: %s' % name)
-    text = cleaner(text)
-  return text

spaces/AI-Hobbyist/Hoyo-RVC/trainset_preprocess_pipeline_print.py

@@ -1,139 +0,0 @@
-import sys, os, multiprocessing
-from scipy import signal
-
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-
-inp_root = sys.argv[1]
-sr = int(sys.argv[2])
-n_p = int(sys.argv[3])
-exp_dir = sys.argv[4]
-noparallel = sys.argv[5] == "True"
-import numpy as np, os, traceback
-from slicer2 import Slicer
-import librosa, traceback
-from scipy.io import wavfile
-import multiprocessing
-from my_utils import load_audio
-
-mutex = multiprocessing.Lock()
-f = open("%s/preprocess.log" % exp_dir, "a+")
-
-
-def println(strr):
-    mutex.acquire()
-    print(strr)
-    f.write("%s\n" % strr)
-    f.flush()
-    mutex.release()
-
-
-class PreProcess:
-    def __init__(self, sr, exp_dir):
-        self.slicer = Slicer(
-            sr=sr,
-            threshold=-42,
-            min_length=1500,
-            min_interval=400,
-            hop_size=15,
-            max_sil_kept=500,
-        )
-        self.sr = sr
-        self.bh, self.ah = signal.butter(N=5, Wn=48, btype="high", fs=self.sr)
-        self.per = 3.7
-        self.overlap = 0.3
-        self.tail = self.per + self.overlap
-        self.max = 0.9
-        self.alpha = 0.75
-        self.exp_dir = exp_dir
-        self.gt_wavs_dir = "%s/0_gt_wavs" % exp_dir
-        self.wavs16k_dir = "%s/1_16k_wavs" % exp_dir
-        os.makedirs(self.exp_dir, exist_ok=True)
-        os.makedirs(self.gt_wavs_dir, exist_ok=True)
-        os.makedirs(self.wavs16k_dir, exist_ok=True)
-
-    def norm_write(self, tmp_audio, idx0, idx1):
-        tmp_max = np.abs(tmp_audio).max()
-        if tmp_max > 2.5:
-            print("%s-%s-%s-filtered" % (idx0, idx1, tmp_max))
-            return
-        tmp_audio = (tmp_audio / tmp_max * (self.max * self.alpha)) + (
-            1 - self.alpha
-        ) * tmp_audio
-        wavfile.write(
-            "%s/%s_%s.wav" % (self.gt_wavs_dir, idx0, idx1),
-            self.sr,
-            tmp_audio.astype(np.float32),
-        )
-        tmp_audio = librosa.resample(
-            tmp_audio, orig_sr=self.sr, target_sr=16000
-        )  # , res_type="soxr_vhq"
-        wavfile.write(
-            "%s/%s_%s.wav" % (self.wavs16k_dir, idx0, idx1),
-            16000,
-            tmp_audio.astype(np.float32),
-        )
-
-    def pipeline(self, path, idx0):
-        try:
-            audio = load_audio(path, self.sr)
-            # zero phased digital filter cause pre-ringing noise...
-            # audio = signal.filtfilt(self.bh, self.ah, audio)
-            audio = signal.lfilter(self.bh, self.ah, audio)
-
-            idx1 = 0
-            for audio in self.slicer.slice(audio):
-                i = 0
-                while 1:
-                    start = int(self.sr * (self.per - self.overlap) * i)
-                    i += 1
-                    if len(audio[start:]) > self.tail * self.sr:
-                        tmp_audio = audio[start : start + int(self.per * self.sr)]
-                        self.norm_write(tmp_audio, idx0, idx1)
-                        idx1 += 1
-                    else:
-                        tmp_audio = audio[start:]
-                        idx1 += 1
-                        break
-                self.norm_write(tmp_audio, idx0, idx1)
-            println("%s->Suc." % path)
-        except:
-            println("%s->%s" % (path, traceback.format_exc()))
-
-    def pipeline_mp(self, infos):
-        for path, idx0 in infos:
-            self.pipeline(path, idx0)
-
-    def pipeline_mp_inp_dir(self, inp_root, n_p):
-        try:
-            infos = [
-                ("%s/%s" % (inp_root, name), idx)
-                for idx, name in enumerate(sorted(list(os.listdir(inp_root))))
-            ]
-            if noparallel:
-                for i in range(n_p):
-                    self.pipeline_mp(infos[i::n_p])
-            else:
-                ps = []
-                for i in range(n_p):
-                    p = multiprocessing.Process(
-                        target=self.pipeline_mp, args=(infos[i::n_p],)
-                    )
-                    ps.append(p)
-                    p.start()
-                for i in range(n_p):
-                    ps[i].join()
-        except:
-            println("Fail. %s" % traceback.format_exc())
-
-
-def preprocess_trainset(inp_root, sr, n_p, exp_dir):
-    pp = PreProcess(sr, exp_dir)
-    println("start preprocess")
-    println(sys.argv)
-    pp.pipeline_mp_inp_dir(inp_root, n_p)
-    println("end preprocess")
-
-
-if __name__ == "__main__":
-    preprocess_trainset(inp_root, sr, n_p, exp_dir)

spaces/AIConsultant/MusicGen/audiocraft/grids/musicgen/musicgen_pretrained_32khz_eval.py

@@ -1,99 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Evaluation with objective metrics for the pretrained MusicGen models.
-This grid takes signature from the training grid and runs evaluation-only stage.
-
-When running the grid for the first time, please use:
-REGEN=1 dora grid musicgen.musicgen_pretrained_32khz_eval
-and re-use the REGEN=1 option when the grid is changed to force regenerating it.
-
-Note that you need the proper metrics external libraries setup to use all
-the objective metrics activated in this grid. Refer to the README for more information.
-"""
-
-import os
-
-from ._explorers import GenerationEvalExplorer
-from ...environment import AudioCraftEnvironment
-from ... import train
-
-
-def eval(launcher, batch_size: int = 32, eval_melody: bool = False):
-    opts = {
-        'dset': 'audio/musiccaps_32khz',
-        'solver/musicgen/evaluation': 'objective_eval',
-        'execute_only': 'evaluate',
-        '+dataset.evaluate.batch_size': batch_size,
-        '+metrics.fad.tf.batch_size': 16,
-    }
-    # chroma-specific evaluation
-    chroma_opts = {
-        'dset': 'internal/music_400k_32khz',
-        'dataset.evaluate.segment_duration': 30,
-        'dataset.evaluate.num_samples': 1000,
-        'evaluate.metrics.chroma_cosine': True,
-        'evaluate.metrics.fad': False,
-        'evaluate.metrics.kld': False,
-        'evaluate.metrics.text_consistency': False,
-    }
-    # binary for FAD computation: replace this path with your own path
-    metrics_opts = {
-        'metrics.fad.tf.bin': '/data/home/jadecopet/local/usr/opt/google-research'
-    }
-    opt1 = {'generate.lm.use_sampling': True, 'generate.lm.top_k': 250, 'generate.lm.top_p': 0.}
-    opt2 = {'transformer_lm.two_step_cfg': True}
-
-    sub = launcher.bind(opts)
-    sub.bind_(metrics_opts)
-
-    # base objective metrics
-    sub(opt1, opt2)
-
-    if eval_melody:
-        # chroma-specific metrics
-        sub(opt1, opt2, chroma_opts)
-
-
-@GenerationEvalExplorer
-def explorer(launcher):
-    partitions = AudioCraftEnvironment.get_slurm_partitions(['team', 'global'])
-    launcher.slurm_(gpus=4, partition=partitions)
-
-    if 'REGEN' not in os.environ:
-        folder = train.main.dora.dir / 'grids' / __name__.split('.', 2)[-1]
-        with launcher.job_array():
-            for sig in folder.iterdir():
-                if not sig.is_symlink():
-                    continue
-                xp = train.main.get_xp_from_sig(sig.name)
-                launcher(xp.argv)
-        return
-
-    with launcher.job_array():
-        musicgen_base = launcher.bind(solver="musicgen/musicgen_base_32khz")
-        musicgen_base.bind_({'autocast': False, 'fsdp.use': True})
-
-        # base musicgen models
-        musicgen_base_small = musicgen_base.bind({'continue_from': '//pretrained/facebook/musicgen-small'})
-        eval(musicgen_base_small, batch_size=128)
-
-        musicgen_base_medium = musicgen_base.bind({'continue_from': '//pretrained/facebook/musicgen-medium'})
-        musicgen_base_medium.bind_({'model/lm/model_scale': 'medium'})
-        eval(musicgen_base_medium, batch_size=128)
-
-        musicgen_base_large = musicgen_base.bind({'continue_from': '//pretrained/facebook/musicgen-large'})
-        musicgen_base_large.bind_({'model/lm/model_scale': 'large'})
-        eval(musicgen_base_large, batch_size=128)
-
-        # melody musicgen model
-        musicgen_melody = launcher.bind(solver="musicgen/musicgen_melody_32khz")
-        musicgen_melody.bind_({'autocast': False, 'fsdp.use': True})
-
-        musicgen_melody_medium = musicgen_melody.bind({'continue_from': '//pretrained/facebook/musicgen-melody'})
-        musicgen_melody_medium.bind_({'model/lm/model_scale': 'medium'})
-        eval(musicgen_melody_medium, batch_size=128, eval_melody=True)

spaces/AIFILMS/StyleGANEX/models/bisenet/resnet.py

@@ -1,109 +0,0 @@
-#!/usr/bin/python
-# -*- encoding: utf-8 -*-
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.model_zoo as modelzoo
-
-# from modules.bn import InPlaceABNSync as BatchNorm2d
-
-resnet18_url = 'https://download.pytorch.org/models/resnet18-5c106cde.pth'
-
-
-def conv3x3(in_planes, out_planes, stride=1):
-    """3x3 convolution with padding"""
-    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
-                     padding=1, bias=False)
-
-
-class BasicBlock(nn.Module):
-    def __init__(self, in_chan, out_chan, stride=1):
-        super(BasicBlock, self).__init__()
-        self.conv1 = conv3x3(in_chan, out_chan, stride)
-        self.bn1 = nn.BatchNorm2d(out_chan)
-        self.conv2 = conv3x3(out_chan, out_chan)
-        self.bn2 = nn.BatchNorm2d(out_chan)
-        self.relu = nn.ReLU(inplace=True)
-        self.downsample = None
-        if in_chan != out_chan or stride != 1:
-            self.downsample = nn.Sequential(
-                nn.Conv2d(in_chan, out_chan,
-                          kernel_size=1, stride=stride, bias=False),
-                nn.BatchNorm2d(out_chan),
-                )
-
-    def forward(self, x):
-        residual = self.conv1(x)
-        residual = F.relu(self.bn1(residual))
-        residual = self.conv2(residual)
-        residual = self.bn2(residual)
-
-        shortcut = x
-        if self.downsample is not None:
-            shortcut = self.downsample(x)
-
-        out = shortcut + residual
-        out = self.relu(out)
-        return out
-
-
-def create_layer_basic(in_chan, out_chan, bnum, stride=1):
-    layers = [BasicBlock(in_chan, out_chan, stride=stride)]
-    for i in range(bnum-1):
-        layers.append(BasicBlock(out_chan, out_chan, stride=1))
-    return nn.Sequential(*layers)
-
-
-class Resnet18(nn.Module):
-    def __init__(self):
-        super(Resnet18, self).__init__()
-        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
-                               bias=False)
-        self.bn1 = nn.BatchNorm2d(64)
-        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-        self.layer1 = create_layer_basic(64, 64, bnum=2, stride=1)
-        self.layer2 = create_layer_basic(64, 128, bnum=2, stride=2)
-        self.layer3 = create_layer_basic(128, 256, bnum=2, stride=2)
-        self.layer4 = create_layer_basic(256, 512, bnum=2, stride=2)
-        self.init_weight()
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = F.relu(self.bn1(x))
-        x = self.maxpool(x)
-
-        x = self.layer1(x)
-        feat8 = self.layer2(x) # 1/8
-        feat16 = self.layer3(feat8) # 1/16
-        feat32 = self.layer4(feat16) # 1/32
-        return feat8, feat16, feat32
-
-    def init_weight(self):
-        state_dict = modelzoo.load_url(resnet18_url)
-        self_state_dict = self.state_dict()
-        for k, v in state_dict.items():
-            if 'fc' in k: continue
-            self_state_dict.update({k: v})
-        self.load_state_dict(self_state_dict)
-
-    def get_params(self):
-        wd_params, nowd_params = [], []
-        for name, module in self.named_modules():
-            if isinstance(module, (nn.Linear, nn.Conv2d)):
-                wd_params.append(module.weight)
-                if not module.bias is None:
-                    nowd_params.append(module.bias)
-            elif isinstance(module,  nn.BatchNorm2d):
-                nowd_params += list(module.parameters())
-        return wd_params, nowd_params
-
-
-if __name__ == "__main__":
-    net = Resnet18()
-    x = torch.randn(16, 3, 224, 224)
-    out = net(x)
-    print(out[0].size())
-    print(out[1].size())
-    print(out[2].size())
-    net.get_params()

spaces/AIGC-Audio/Make_An_Audio/ldm/models/diffusion/ddpm.py

@@ -1,1444 +0,0 @@
-"""
-wild mixture of
-https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
-https://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py
-https://github.com/CompVis/taming-transformers
--- merci
-"""
-import torch
-import torch.nn as nn
-import numpy as np
-import pytorch_lightning as pl
-from torch.optim.lr_scheduler import LambdaLR
-from einops import rearrange, repeat
-from contextlib import contextmanager
-from functools import partial
-from tqdm import tqdm
-from torchvision.utils import make_grid
-from pytorch_lightning.utilities.distributed import rank_zero_only
-
-from ldm.util import log_txt_as_img, exists, default, ismap, isimage, mean_flat, count_params, instantiate_from_config
-from ldm.modules.ema import LitEma
-from ldm.modules.distributions.distributions import normal_kl, DiagonalGaussianDistribution
-from ldm.models.autoencoder import IdentityFirstStage, AutoencoderKL
-from ldm.modules.diffusionmodules.util import make_beta_schedule, extract_into_tensor, noise_like
-from ldm.models.diffusion.ddim import DDIMSampler
-
-
-__conditioning_keys__ = {'concat': 'c_concat',
-                         'crossattn': 'c_crossattn',
-                         'adm': 'y'}
-
-
-def disabled_train(self, mode=True):
-    """Overwrite model.train with this function to make sure train/eval mode
-    does not change anymore."""
-    return self
-
-
-def uniform_on_device(r1, r2, shape, device):
-    return (r1 - r2) * torch.rand(*shape, device=device) + r2
-
-
-class DDPM(pl.LightningModule):
-    # classic DDPM with Gaussian diffusion, in image space
-    def __init__(self,
-                 unet_config,
-                 timesteps=1000,
-                 beta_schedule="linear",
-                 loss_type="l2",
-                 ckpt_path=None,
-                 ignore_keys=[],
-                 load_only_unet=False,
-                 monitor="val/loss",
-                 use_ema=True,
-                 first_stage_key="image",
-                 image_size=256,
-                 channels=3,
-                 log_every_t=100,
-                 clip_denoised=True,
-                 linear_start=1e-4,
-                 linear_end=2e-2,
-                 cosine_s=8e-3,
-                 given_betas=None,
-                 original_elbo_weight=0.,
-                 v_posterior=0.,  # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta
-                 l_simple_weight=1.,
-                 conditioning_key=None,
-                 parameterization="eps",  # all config files uses "eps"
-                 scheduler_config=None,
-                 use_positional_encodings=False,
-                 learn_logvar=False,
-                 logvar_init=0.,
-                 ):
-        super().__init__()
-        assert parameterization in ["eps", "x0"], 'currently only supporting "eps" and "x0"'
-        self.parameterization = parameterization
-        print(f"{self.__class__.__name__}: Running in {self.parameterization}-prediction mode")
-        self.cond_stage_model = None
-        self.clip_denoised = clip_denoised
-        self.log_every_t = log_every_t
-        self.first_stage_key = first_stage_key
-        self.image_size = image_size  # try conv?
-        self.channels = channels
-        self.use_positional_encodings = use_positional_encodings
-        self.model = DiffusionWrapper(unet_config, conditioning_key)
-        count_params(self.model, verbose=True)
-        self.use_ema = use_ema
-        if self.use_ema:
-            self.model_ema = LitEma(self.model)
-            print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
-
-        self.use_scheduler = scheduler_config is not None
-        if self.use_scheduler:
-            self.scheduler_config = scheduler_config
-
-        self.v_posterior = v_posterior
-        self.original_elbo_weight = original_elbo_weight
-        self.l_simple_weight = l_simple_weight
-
-        if monitor is not None:
-            self.monitor = monitor
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)
-
-        self.register_schedule(given_betas=given_betas, beta_schedule=beta_schedule, timesteps=timesteps,
-                               linear_start=linear_start, linear_end=linear_end, cosine_s=cosine_s)
-
-        self.loss_type = loss_type
-
-        self.learn_logvar = learn_logvar
-        self.logvar = torch.full(fill_value=logvar_init, size=(self.num_timesteps,))
-        if self.learn_logvar:
-            self.logvar = nn.Parameter(self.logvar, requires_grad=True)
-
-    def register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000,
-                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
-        if exists(given_betas):
-            betas = given_betas
-        else:
-            betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end,
-                                       cosine_s=cosine_s)
-        alphas = 1. - betas
-        alphas_cumprod = np.cumprod(alphas, axis=0)
-        alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1])
-
-        timesteps, = betas.shape
-        self.num_timesteps = int(timesteps)
-        self.linear_start = linear_start
-        self.linear_end = linear_end
-        assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep'
-
-        to_torch = partial(torch.tensor, dtype=torch.float32)
-
-        self.register_buffer('betas', to_torch(betas))
-        self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
-        self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev))
-
-        # calculations for diffusion q(x_t | x_{t-1}) and others
-        self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod)))
-        self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod)))
-        self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod)))
-        self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod)))
-        self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1)))
-
-        # calculations for posterior q(x_{t-1} | x_t, x_0)
-        posterior_variance = (1 - self.v_posterior) * betas * (1. - alphas_cumprod_prev) / (
-                    1. - alphas_cumprod) + self.v_posterior * betas
-        # above: equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t)
-        self.register_buffer('posterior_variance', to_torch(posterior_variance))
-        # below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain
-        self.register_buffer('posterior_log_variance_clipped', to_torch(np.log(np.maximum(posterior_variance, 1e-20))))
-        self.register_buffer('posterior_mean_coef1', to_torch(
-            betas * np.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod)))
-        self.register_buffer('posterior_mean_coef2', to_torch(
-            (1. - alphas_cumprod_prev) * np.sqrt(alphas) / (1. - alphas_cumprod)))
-
-        if self.parameterization == "eps":
-            lvlb_weights = self.betas ** 2 / (
-                        2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod))
-        elif self.parameterization == "x0":
-            lvlb_weights = 0.5 * np.sqrt(torch.Tensor(alphas_cumprod)) / (2. * 1 - torch.Tensor(alphas_cumprod))
-        else:
-            raise NotImplementedError("mu not supported")
-        # TODO how to choose this term
-        lvlb_weights[0] = lvlb_weights[1]
-        self.register_buffer('lvlb_weights', lvlb_weights, persistent=False)
-        assert not torch.isnan(self.lvlb_weights).all()
-
-    @contextmanager
-    def ema_scope(self, context=None):
-        if self.use_ema:
-            self.model_ema.store(self.model.parameters())
-            self.model_ema.copy_to(self.model)
-            if context is not None:
-                print(f"{context}: Switched to EMA weights")
-        try:
-            yield None
-        finally:
-            if self.use_ema:
-                self.model_ema.restore(self.model.parameters())
-                if context is not None:
-                    print(f"{context}: Restored training weights")
-
-    def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
-        sd = torch.load(path, map_location="cpu")
-        if "state_dict" in list(sd.keys()):
-            sd = sd["state_dict"]
-        keys = list(sd.keys())
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-        missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(
-            sd, strict=False)
-        print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
-        if len(missing) > 0:
-            print(f"Missing Keys: {missing}")
-        if len(unexpected) > 0:
-            print(f"Unexpected Keys: {unexpected}")
-
-    def q_mean_variance(self, x_start, t):
-        """
-        Get the distribution q(x_t | x_0).
-        :param x_start: the [N x C x ...] tensor of noiseless inputs.
-        :param t: the number of diffusion steps (minus 1). Here, 0 means one step.
-        :return: A tuple (mean, variance, log_variance), all of x_start's shape.
-        """
-        mean = (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start)
-        variance = extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape)
-        log_variance = extract_into_tensor(self.log_one_minus_alphas_cumprod, t, x_start.shape)
-        return mean, variance, log_variance
-
-    def predict_start_from_noise(self, x_t, t, noise):
-        return (
-                extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t -
-                extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise
-        )
-
-    def q_posterior(self, x_start, x_t, t):
-        posterior_mean = (
-                extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start +
-                extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t
-        )
-        posterior_variance = extract_into_tensor(self.posterior_variance, t, x_t.shape)
-        posterior_log_variance_clipped = extract_into_tensor(self.posterior_log_variance_clipped, t, x_t.shape)
-        return posterior_mean, posterior_variance, posterior_log_variance_clipped
-
-    def p_mean_variance(self, x, t, clip_denoised: bool):
-        model_out = self.model(x, t)
-        if self.parameterization == "eps":
-            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
-        elif self.parameterization == "x0":
-            x_recon = model_out
-        if clip_denoised:
-            x_recon.clamp_(-1., 1.)
-
-        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
-        return model_mean, posterior_variance, posterior_log_variance
-
-    @torch.no_grad()
-    def p_sample(self, x, t, clip_denoised=True, repeat_noise=False):
-        b, *_, device = *x.shape, x.device
-        model_mean, _, model_log_variance = self.p_mean_variance(x=x, t=t, clip_denoised=clip_denoised)
-        noise = noise_like(x.shape, device, repeat_noise)
-        # no noise when t == 0
-        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
-        return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
-
-    @torch.no_grad()
-    def p_sample_loop(self, shape, return_intermediates=False):
-        device = self.betas.device
-        b = shape[0]
-        img = torch.randn(shape, device=device)
-        intermediates = [img]
-        for i in tqdm(reversed(range(0, self.num_timesteps)), desc='Sampling t', total=self.num_timesteps):
-            img = self.p_sample(img, torch.full((b,), i, device=device, dtype=torch.long),
-                                clip_denoised=self.clip_denoised)
-            if i % self.log_every_t == 0 or i == self.num_timesteps - 1:
-                intermediates.append(img)
-        if return_intermediates:
-            return img, intermediates
-        return img
-
-    @torch.no_grad()
-    def sample(self, batch_size=16, return_intermediates=False):
-        image_size = self.image_size
-        channels = self.channels
-        return self.p_sample_loop((batch_size, channels, image_size, image_size),
-                                  return_intermediates=return_intermediates)
-
-    def q_sample(self, x_start, t, noise=None):
-        noise = default(noise, lambda: torch.randn_like(x_start))
-        return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start +
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise)
-
-    def get_loss(self, pred, target, mean=True):
-        if self.loss_type == 'l1':
-            loss = (target - pred).abs()
-            if mean:
-                loss = loss.mean()
-        elif self.loss_type == 'l2':
-            if mean:
-                loss = torch.nn.functional.mse_loss(target, pred)
-            else:
-                loss = torch.nn.functional.mse_loss(target, pred, reduction='none')
-        else:
-            raise NotImplementedError("unknown loss type '{loss_type}'")
-
-        return loss
-
-    def p_losses(self, x_start, t, noise=None):
-        noise = default(noise, lambda: torch.randn_like(x_start))
-        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
-        model_out = self.model(x_noisy, t)
-
-        loss_dict = {}
-        if self.parameterization == "eps":
-            target = noise
-        elif self.parameterization == "x0":
-            target = x_start
-        else:
-            raise NotImplementedError(f"Paramterization {self.parameterization} not yet supported")
-
-        loss = self.get_loss(model_out, target, mean=False).mean(dim=[1, 2, 3])
-
-        log_prefix = 'train' if self.training else 'val'
-
-        loss_dict.update({f'{log_prefix}/loss_simple': loss.mean()})
-        loss_simple = loss.mean() * self.l_simple_weight
-
-        loss_vlb = (self.lvlb_weights[t] * loss).mean()
-        loss_dict.update({f'{log_prefix}/loss_vlb': loss_vlb})
-
-        loss = loss_simple + self.original_elbo_weight * loss_vlb
-
-        loss_dict.update({f'{log_prefix}/loss': loss})
-
-        return loss, loss_dict
-
-    def forward(self, x, *args, **kwargs):
-        # b, c, h, w, device, img_size, = *x.shape, x.device, self.image_size
-        # assert h == img_size and w == img_size, f'height and width of image must be {img_size}'
-        t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
-        return self.p_losses(x, t, *args, **kwargs)
-
-    def get_input(self, batch, k):
-        x = batch[k]
-        if len(x.shape) == 3:
-            x = x[..., None]
-        x = rearrange(x, 'b h w c -> b c h w')
-        x = x.to(memory_format=torch.contiguous_format).float()
-        return x
-
-    def shared_step(self, batch):
-        x = self.get_input(batch, self.first_stage_key)
-        loss, loss_dict = self(x)
-        return loss, loss_dict
-
-    def training_step(self, batch, batch_idx):
-        loss, loss_dict = self.shared_step(batch)
-
-        self.log_dict(loss_dict, prog_bar=True,
-                      logger=True, on_step=True, on_epoch=True)
-
-        self.log("global_step", self.global_step,
-                 prog_bar=True, logger=True, on_step=True, on_epoch=False)
-
-        if self.use_scheduler:
-            lr = self.optimizers().param_groups[0]['lr']
-            self.log('lr_abs', lr, prog_bar=True, logger=True, on_step=True, on_epoch=False)
-
-        return loss
-
-    @torch.no_grad()
-    def validation_step(self, batch, batch_idx):
-        _, loss_dict_no_ema = self.shared_step(batch)
-        with self.ema_scope():
-            _, loss_dict_ema = self.shared_step(batch)
-            loss_dict_ema = {key + '_ema': loss_dict_ema[key] for key in loss_dict_ema}
-        self.log_dict(loss_dict_no_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
-        self.log_dict(loss_dict_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
-
-    def on_train_batch_end(self, *args, **kwargs):
-        if self.use_ema:
-            self.model_ema(self.model)
-
-    def _get_rows_from_list(self, samples):
-        n_imgs_per_row = len(samples)
-        denoise_grid = rearrange(samples, 'n b c h w -> b n c h w')
-        denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
-        denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
-        return denoise_grid
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=2, sample=True, return_keys=None, **kwargs):
-        log = dict()
-        x = self.get_input(batch, self.first_stage_key)
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        x = x.to(self.device)[:N]
-        log["inputs"] = x
-
-        # get diffusion row
-        diffusion_row = list()
-        x_start = x[:n_row]
-
-        for t in range(self.num_timesteps):
-            if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                t = t.to(self.device).long()
-                noise = torch.randn_like(x_start)
-                x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
-                diffusion_row.append(x_noisy)
-
-        log["diffusion_row"] = self._get_rows_from_list(diffusion_row)
-
-        if sample:
-            # get denoise row
-            with self.ema_scope("Plotting"):
-                samples, denoise_row = self.sample(batch_size=N, return_intermediates=True)
-
-            log["samples"] = samples
-            log["denoise_row"] = self._get_rows_from_list(denoise_row)
-
-        if return_keys:
-            if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
-                return log
-            else:
-                return {key: log[key] for key in return_keys}
-        return log
-
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        params = list(self.model.parameters())
-        if self.learn_logvar:
-            params = params + [self.logvar]
-        opt = torch.optim.AdamW(params, lr=lr)
-        return opt
-
-
-class LatentDiffusion(DDPM):
-    """main class"""
-    def __init__(self,
-                 first_stage_config,
-                 cond_stage_config,
-                 num_timesteps_cond=None,
-                 cond_stage_key="image",# 'caption' for txt2image, 'masked_image' for inpainting 
-                 cond_stage_trainable=False,
-                 concat_mode=True,# true for inpainting
-                 cond_stage_forward=None,
-                 conditioning_key=None, # 'crossattn' for txt2image, None for inpainting
-                 scale_factor=1.0,
-                 scale_by_std=False,
-                 *args, **kwargs):
-        self.num_timesteps_cond = default(num_timesteps_cond, 1)
-        self.scale_by_std = scale_by_std
-        assert self.num_timesteps_cond <= kwargs['timesteps']
-        # for backwards compatibility after implementation of DiffusionWrapper
-        if conditioning_key is None:
-            conditioning_key = 'concat' if concat_mode else 'crossattn'
-        if cond_stage_config == '__is_unconditional__':
-            conditioning_key = None
-        ckpt_path = kwargs.pop("ckpt_path", None)
-        ignore_keys = kwargs.pop("ignore_keys", [])
-        super().__init__(conditioning_key=conditioning_key, *args, **kwargs)
-        self.concat_mode = concat_mode
-        self.cond_stage_trainable = cond_stage_trainable
-        self.cond_stage_key = cond_stage_key 
-        try:
-            self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1
-        except:
-            self.num_downs = 0
-        if not scale_by_std:
-            self.scale_factor = scale_factor
-        else:
-            self.register_buffer('scale_factor', torch.tensor(scale_factor))
-        self.instantiate_first_stage(first_stage_config)
-        self.instantiate_cond_stage(cond_stage_config)
-        self.cond_stage_forward = cond_stage_forward
-        self.clip_denoised = False
-        self.bbox_tokenizer = None  
-
-        self.restarted_from_ckpt = False
-        if ckpt_path is not None:
-            self.init_from_ckpt(ckpt_path, ignore_keys)
-            self.restarted_from_ckpt = True
-
-    def make_cond_schedule(self, ):
-        self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long)
-        ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long()
-        self.cond_ids[:self.num_timesteps_cond] = ids
-
-    @rank_zero_only
-    @torch.no_grad()
-    def on_train_batch_start(self, batch, batch_idx, dataloader_idx):
-        # only for very first batch
-        if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt:
-            assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously'
-            # set rescale weight to 1./std of encodings
-            print("### USING STD-RESCALING ###")
-            x = super().get_input(batch, self.first_stage_key)
-            x = x.to(self.device)
-            encoder_posterior = self.encode_first_stage(x)
-            z = self.get_first_stage_encoding(encoder_posterior).detach()
-            del self.scale_factor
-            self.register_buffer('scale_factor', 1. / z.flatten().std())
-            print(f"setting self.scale_factor to {self.scale_factor}")
-            print("### USING STD-RESCALING ###")
-
-    def register_schedule(self,
-                          given_betas=None, beta_schedule="linear", timesteps=1000,
-                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
-        super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s)
-
-        self.shorten_cond_schedule = self.num_timesteps_cond > 1
-        if self.shorten_cond_schedule:
-            self.make_cond_schedule()
-
-    def instantiate_first_stage(self, config):
-        model = instantiate_from_config(config)
-        self.first_stage_model = model.eval()
-        self.first_stage_model.train = disabled_train
-        for param in self.first_stage_model.parameters():
-            param.requires_grad = False
-
-    def instantiate_cond_stage(self, config):
-        if not self.cond_stage_trainable:
-            if config == "__is_first_stage__":# inpaint
-                print("Using first stage also as cond stage.")
-                self.cond_stage_model = self.first_stage_model
-            elif config == "__is_unconditional__":
-                print(f"Training {self.__class__.__name__} as an unconditional model.")
-                self.cond_stage_model = None
-                # self.be_unconditional = True
-            else:
-                model = instantiate_from_config(config)
-                self.cond_stage_model = model.eval()
-                self.cond_stage_model.train = disabled_train
-                for param in self.cond_stage_model.parameters():
-                    param.requires_grad = False
-        else:
-            assert config != '__is_first_stage__'
-            assert config != '__is_unconditional__'
-            model = instantiate_from_config(config)
-            self.cond_stage_model = model
-
-    def _get_denoise_row_from_list(self, samples, desc='', force_no_decoder_quantization=False):
-        denoise_row = []
-        for zd in tqdm(samples, desc=desc):
-            denoise_row.append(self.decode_first_stage(zd.to(self.device),
-                                                            force_not_quantize=force_no_decoder_quantization))
-        n_imgs_per_row = len(denoise_row)
-        denoise_row = torch.stack(denoise_row)  # n_log_step, n_row, C, H, W
-        denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w')
-        denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
-        denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
-        return denoise_grid
-
-    def get_first_stage_encoding(self, encoder_posterior):
-        if isinstance(encoder_posterior, DiagonalGaussianDistribution):
-            z = encoder_posterior.sample()
-        elif isinstance(encoder_posterior, torch.Tensor):
-            z = encoder_posterior
-        else:
-            raise NotImplementedError(f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented")
-        return self.scale_factor * z
-
-    def get_learned_conditioning(self, c):
-        if self.cond_stage_forward is None:
-            if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode):
-                c = self.cond_stage_model.encode(c)
-                if isinstance(c, DiagonalGaussianDistribution):
-                    c = c.mode()
-            else:
-                c = self.cond_stage_model(c)
-        else:
-            assert hasattr(self.cond_stage_model, self.cond_stage_forward)
-            c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)
-        return c
-
-    def meshgrid(self, h, w):
-        y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1)
-        x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1)
-
-        arr = torch.cat([y, x], dim=-1)
-        return arr
-
-    def delta_border(self, h, w):
-        """
-        :param h: height
-        :param w: width
-        :return: normalized distance to image border,
-         wtith min distance = 0 at border and max dist = 0.5 at image center
-        """
-        lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2)
-        arr = self.meshgrid(h, w) / lower_right_corner
-        dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0]
-        dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0]
-        edge_dist = torch.min(torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0]
-        return edge_dist
-
-    def get_weighting(self, h, w, Ly, Lx, device):
-        weighting = self.delta_border(h, w)
-        weighting = torch.clip(weighting, self.split_input_params["clip_min_weight"],
-                               self.split_input_params["clip_max_weight"], )
-        weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device)
-
-        if self.split_input_params["tie_braker"]:
-            L_weighting = self.delta_border(Ly, Lx)
-            L_weighting = torch.clip(L_weighting,
-                                     self.split_input_params["clip_min_tie_weight"],
-                                     self.split_input_params["clip_max_tie_weight"])
-
-            L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device)
-            weighting = weighting * L_weighting
-        return weighting
-
-    def get_fold_unfold(self, x, kernel_size, stride, uf=1, df=1):  # todo load once not every time, shorten code
-        """
-        :param x: img of size (bs, c, h, w)
-        :return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1])
-        """
-        bs, nc, h, w = x.shape
-
-        # number of crops in image
-        Ly = (h - kernel_size[0]) // stride[0] + 1
-        Lx = (w - kernel_size[1]) // stride[1] + 1
-
-        if uf == 1 and df == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params)
-
-            weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h, w)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx))
-
-        elif uf > 1 and df == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold_params2 = dict(kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf),
-                                dilation=1, padding=0,
-                                stride=(stride[0] * uf, stride[1] * uf))
-            fold = torch.nn.Fold(output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2)
-
-            weighting = self.get_weighting(kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h * uf, w * uf)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx))
-
-        elif df > 1 and uf == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold_params2 = dict(kernel_size=(kernel_size[0] // df, kernel_size[0] // df),
-                                dilation=1, padding=0,
-                                stride=(stride[0] // df, stride[1] // df))
-            fold = torch.nn.Fold(output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2)
-
-            weighting = self.get_weighting(kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h // df, w // df)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx))
-
-        else:
-            raise NotImplementedError
-
-        return fold, unfold, normalization, weighting
-
-    @torch.no_grad()
-    def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False,
-                  cond_key=None, return_original_cond=False, bs=None):
-        x = super().get_input(batch, k)
-        if bs is not None:
-            x = x[:bs]
-        x = x.to(self.device)
-        encoder_posterior = self.encode_first_stage(x)
-        z = self.get_first_stage_encoding(encoder_posterior).detach()
-
-        if self.model.conditioning_key is not None:
-            if cond_key is None:
-                cond_key = self.cond_stage_key
-            if cond_key != self.first_stage_key:# cond_key is not image. for inapint it's masked_img
-                if cond_key in ['caption', 'coordinates_bbox']:
-                    xc = batch[cond_key]
-                elif cond_key == 'class_label':
-                    xc = batch
-                else:
-                    xc = super().get_input(batch, cond_key).to(self.device)
-            else:
-                xc = x
-            if not self.cond_stage_trainable or force_c_encode:
-                if isinstance(xc, dict) or isinstance(xc, list):
-                    # import pudb; pudb.set_trace()
-                    c = self.get_learned_conditioning(xc)
-                else:
-                    c = self.get_learned_conditioning(xc.to(self.device))
-            else:
-                c = xc
-            if bs is not None:
-                c = c[:bs]
-
-            if self.use_positional_encodings:
-                pos_x, pos_y = self.compute_latent_shifts(batch)
-                ckey = __conditioning_keys__[self.model.conditioning_key]
-                c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y}
-
-        else:
-            c = None
-            xc = None
-            if self.use_positional_encodings:
-                pos_x, pos_y = self.compute_latent_shifts(batch)
-                c = {'pos_x': pos_x, 'pos_y': pos_y}
-        out = [z, c]
-        if return_first_stage_outputs:
-            xrec = self.decode_first_stage(z)
-            out.extend([x, xrec])
-        if return_original_cond:
-            out.append(xc)
-        return out
-
-    @torch.no_grad()
-    def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):
-        if predict_cids:
-            if z.dim() == 4:
-                z = torch.argmax(z.exp(), dim=1).long()
-            z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)
-            z = rearrange(z, 'b h w c -> b c h w').contiguous()
-
-        z = 1. / self.scale_factor * z
-
-        if hasattr(self, "split_input_params"):
-            if self.split_input_params["patch_distributed_vq"]:
-                ks = self.split_input_params["ks"]  # eg. (128, 128)
-                stride = self.split_input_params["stride"]  # eg. (64, 64)
-                uf = self.split_input_params["vqf"]
-                bs, nc, h, w = z.shape
-                if ks[0] > h or ks[1] > w:
-                    ks = (min(ks[0], h), min(ks[1], w))
-                    print("reducing Kernel")
-
-                if stride[0] > h or stride[1] > w:
-                    stride = (min(stride[0], h), min(stride[1], w))
-                    print("reducing stride")
-
-                fold, unfold, normalization, weighting = self.get_fold_unfold(z, ks, stride, uf=uf)
-
-                z = unfold(z)  # (bn, nc * prod(**ks), L)
-                # 1. Reshape to img shape
-                z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-
-                # 2. apply model loop over last dim
-                if isinstance(self.first_stage_model, VQModelInterface):
-                    output_list = [self.first_stage_model.decode(z[:, :, :, :, i],
-                                                                 force_not_quantize=predict_cids or force_not_quantize)
-                                   for i in range(z.shape[-1])]
-                else:
-
-                    output_list = [self.first_stage_model.decode(z[:, :, :, :, i])
-                                   for i in range(z.shape[-1])]
-
-                o = torch.stack(output_list, axis=-1)  # # (bn, nc, ks[0], ks[1], L)
-                o = o * weighting
-                # Reverse 1. reshape to img shape
-                o = o.view((o.shape[0], -1, o.shape[-1]))  # (bn, nc * ks[0] * ks[1], L)
-                # stitch crops together
-                decoded = fold(o)
-                decoded = decoded / normalization  # norm is shape (1, 1, h, w)
-                return decoded
-            else:
-                if isinstance(self.first_stage_model, VQModelInterface):
-                    return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
-                else:
-                    return self.first_stage_model.decode(z)
-
-        else:
-            if isinstance(self.first_stage_model, VQModelInterface):
-                return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
-            else:
-                return self.first_stage_model.decode(z)
-
-    # same as above but without decorator
-    def differentiable_decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):
-        if predict_cids:
-            if z.dim() == 4:
-                z = torch.argmax(z.exp(), dim=1).long()
-            z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)
-            z = rearrange(z, 'b h w c -> b c h w').contiguous()
-
-        z = 1. / self.scale_factor * z
-
-        if hasattr(self, "split_input_params"):
-            if self.split_input_params["patch_distributed_vq"]:
-                ks = self.split_input_params["ks"]  # eg. (128, 128)
-                stride = self.split_input_params["stride"]  # eg. (64, 64)
-                uf = self.split_input_params["vqf"]
-                bs, nc, h, w = z.shape
-                if ks[0] > h or ks[1] > w:
-                    ks = (min(ks[0], h), min(ks[1], w))
-                    print("reducing Kernel")
-
-                if stride[0] > h or stride[1] > w:
-                    stride = (min(stride[0], h), min(stride[1], w))
-                    print("reducing stride")
-
-                fold, unfold, normalization, weighting = self.get_fold_unfold(z, ks, stride, uf=uf)
-
-                z = unfold(z)  # (bn, nc * prod(**ks), L)
-                # 1. Reshape to img shape
-                z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-
-                # 2. apply model loop over last dim
-                if isinstance(self.first_stage_model, VQModelInterface):  
-                    output_list = [self.first_stage_model.decode(z[:, :, :, :, i],
-                                                                 force_not_quantize=predict_cids or force_not_quantize)
-                                   for i in range(z.shape[-1])]
-                else:
-
-                    output_list = [self.first_stage_model.decode(z[:, :, :, :, i])
-                                   for i in range(z.shape[-1])]
-
-                o = torch.stack(output_list, axis=-1)  # # (bn, nc, ks[0], ks[1], L)
-                o = o * weighting
-                # Reverse 1. reshape to img shape
-                o = o.view((o.shape[0], -1, o.shape[-1]))  # (bn, nc * ks[0] * ks[1], L)
-                # stitch crops together
-                decoded = fold(o)
-                decoded = decoded / normalization  # norm is shape (1, 1, h, w)
-                return decoded
-            else:
-                if isinstance(self.first_stage_model, VQModelInterface):
-                    return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
-                else:
-                    return self.first_stage_model.decode(z)
-
-        else:
-            if isinstance(self.first_stage_model, VQModelInterface):
-                return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
-            else:
-                return self.first_stage_model.decode(z)
-
-    @torch.no_grad()
-    def encode_first_stage(self, x):
-        if hasattr(self, "split_input_params"):
-            if self.split_input_params["patch_distributed_vq"]:
-                ks = self.split_input_params["ks"]  # eg. (128, 128)
-                stride = self.split_input_params["stride"]  # eg. (64, 64)
-                df = self.split_input_params["vqf"]
-                self.split_input_params['original_image_size'] = x.shape[-2:]
-                bs, nc, h, w = x.shape
-                if ks[0] > h or ks[1] > w:
-                    ks = (min(ks[0], h), min(ks[1], w))
-                    print("reducing Kernel")
-
-                if stride[0] > h or stride[1] > w:
-                    stride = (min(stride[0], h), min(stride[1], w))
-                    print("reducing stride")
-
-                fold, unfold, normalization, weighting = self.get_fold_unfold(x, ks, stride, df=df)
-                z = unfold(x)  # (bn, nc * prod(**ks), L)
-                # Reshape to img shape
-                z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-
-                output_list = [self.first_stage_model.encode(z[:, :, :, :, i])
-                               for i in range(z.shape[-1])]
-
-                o = torch.stack(output_list, axis=-1)
-                o = o * weighting
-
-                # Reverse reshape to img shape
-                o = o.view((o.shape[0], -1, o.shape[-1]))  # (bn, nc * ks[0] * ks[1], L)
-                # stitch crops together
-                decoded = fold(o)
-                decoded = decoded / normalization
-                return decoded
-
-            else:
-                return self.first_stage_model.encode(x)
-        else:
-            return self.first_stage_model.encode(x)
-
-    def shared_step(self, batch, **kwargs):
-        x, c = self.get_input(batch, self.first_stage_key)
-        loss = self(x, c)
-        return loss
-
-    def forward(self, x, c, *args, **kwargs):
-        t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
-        if self.model.conditioning_key is not None:
-            assert c is not None
-            if self.cond_stage_trainable:# true when use text
-                c = self.get_learned_conditioning(c) # c: string list -> [B, T, Context_dim]
-            if self.shorten_cond_schedule:  # TODO: drop this option
-                tc = self.cond_ids[t].to(self.device)
-                c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))
-        return self.p_losses(x, c, t, *args, **kwargs)
-
-    def _rescale_annotations(self, bboxes, crop_coordinates):  # TODO: move to dataset
-        def rescale_bbox(bbox):
-            x0 = clamp((bbox[0] - crop_coordinates[0]) / crop_coordinates[2])
-            y0 = clamp((bbox[1] - crop_coordinates[1]) / crop_coordinates[3])
-            w = min(bbox[2] / crop_coordinates[2], 1 - x0)
-            h = min(bbox[3] / crop_coordinates[3], 1 - y0)
-            return x0, y0, w, h
-
-        return [rescale_bbox(b) for b in bboxes]
-
-    def apply_model(self, x_noisy, t, cond, return_ids=False):
-
-        if isinstance(cond, dict):
-            # hybrid case, cond is exptected to be a dict
-            pass
-        else:
-            if not isinstance(cond, list):
-                cond = [cond]
-            key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'
-            cond = {key: cond}
-
-        if hasattr(self, "split_input_params"):
-            assert len(cond) == 1  # todo can only deal with one conditioning atm
-            assert not return_ids  
-            ks = self.split_input_params["ks"]  # eg. (128, 128)
-            stride = self.split_input_params["stride"]  # eg. (64, 64)
-
-            h, w = x_noisy.shape[-2:]
-
-            fold, unfold, normalization, weighting = self.get_fold_unfold(x_noisy, ks, stride)
-
-            z = unfold(x_noisy)  # (bn, nc * prod(**ks), L)
-            # Reshape to img shape
-            z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-            z_list = [z[:, :, :, :, i] for i in range(z.shape[-1])]
-
-            if self.cond_stage_key in ["image", "LR_image", "segmentation",
-                                       'bbox_img'] and self.model.conditioning_key:  # todo check for completeness
-                c_key = next(iter(cond.keys()))  # get key
-                c = next(iter(cond.values()))  # get value
-                assert (len(c) == 1)  # todo extend to list with more than one elem
-                c = c[0]  # get element
-
-                c = unfold(c)
-                c = c.view((c.shape[0], -1, ks[0], ks[1], c.shape[-1]))  # (bn, nc, ks[0], ks[1], L )
-
-                cond_list = [{c_key: [c[:, :, :, :, i]]} for i in range(c.shape[-1])]
-
-            elif self.cond_stage_key == 'coordinates_bbox':
-                assert 'original_image_size' in self.split_input_params, 'BoudingBoxRescaling is missing original_image_size'
-
-                # assuming padding of unfold is always 0 and its dilation is always 1
-                n_patches_per_row = int((w - ks[0]) / stride[0] + 1)
-                full_img_h, full_img_w = self.split_input_params['original_image_size']
-                # as we are operating on latents, we need the factor from the original image size to the
-                # spatial latent size to properly rescale the crops for regenerating the bbox annotations
-                num_downs = self.first_stage_model.encoder.num_resolutions - 1
-                rescale_latent = 2 ** (num_downs)
-
-                # get top left postions of patches as conforming for the bbbox tokenizer, therefore we
-                # need to rescale the tl patch coordinates to be in between (0,1)
-                tl_patch_coordinates = [(rescale_latent * stride[0] * (patch_nr % n_patches_per_row) / full_img_w,
-                                         rescale_latent * stride[1] * (patch_nr // n_patches_per_row) / full_img_h)
-                                        for patch_nr in range(z.shape[-1])]
-
-                # patch_limits are tl_coord, width and height coordinates as (x_tl, y_tl, h, w)
-                patch_limits = [(x_tl, y_tl,
-                                 rescale_latent * ks[0] / full_img_w,
-                                 rescale_latent * ks[1] / full_img_h) for x_tl, y_tl in tl_patch_coordinates]
-                # patch_values = [(np.arange(x_tl,min(x_tl+ks, 1.)),np.arange(y_tl,min(y_tl+ks, 1.))) for x_tl, y_tl in tl_patch_coordinates]
-
-                # tokenize crop coordinates for the bounding boxes of the respective patches
-                patch_limits_tknzd = [torch.LongTensor(self.bbox_tokenizer._crop_encoder(bbox))[None].to(self.device)
-                                      for bbox in patch_limits]  # list of length l with tensors of shape (1, 2)
-                print(patch_limits_tknzd[0].shape)
-                # cut tknzd crop position from conditioning
-                assert isinstance(cond, dict), 'cond must be dict to be fed into model'
-                cut_cond = cond['c_crossattn'][0][..., :-2].to(self.device)
-                print(cut_cond.shape)
-
-                adapted_cond = torch.stack([torch.cat([cut_cond, p], dim=1) for p in patch_limits_tknzd])
-                adapted_cond = rearrange(adapted_cond, 'l b n -> (l b) n')
-                print(adapted_cond.shape)
-                adapted_cond = self.get_learned_conditioning(adapted_cond)
-                print(adapted_cond.shape)
-                adapted_cond = rearrange(adapted_cond, '(l b) n d -> l b n d', l=z.shape[-1])
-                print(adapted_cond.shape)
-
-                cond_list = [{'c_crossattn': [e]} for e in adapted_cond]
-
-            else:
-                cond_list = [cond for i in range(z.shape[-1])]  # Todo make this more efficient
-
-            # apply model by loop over crops
-            output_list = [self.model(z_list[i], t, **cond_list[i]) for i in range(z.shape[-1])]
-            assert not isinstance(output_list[0],
-                                  tuple)  # todo cant deal with multiple model outputs check this never happens
-
-            o = torch.stack(output_list, axis=-1)
-            o = o * weighting
-            # Reverse reshape to img shape
-            o = o.view((o.shape[0], -1, o.shape[-1]))  # (bn, nc * ks[0] * ks[1], L)
-            # stitch crops together
-            x_recon = fold(o) / normalization
-
-        else:
-            x_recon = self.model(x_noisy, t, **cond)
-
-        if isinstance(x_recon, tuple) and not return_ids:
-            return x_recon[0]
-        else:
-            return x_recon
-
-    def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
-        return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \
-               extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
-
-    def _prior_bpd(self, x_start):
-        """
-        Get the prior KL term for the variational lower-bound, measured in
-        bits-per-dim.
-        This term can't be optimized, as it only depends on the encoder.
-        :param x_start: the [N x C x ...] tensor of inputs.
-        :return: a batch of [N] KL values (in bits), one per batch element.
-        """
-        batch_size = x_start.shape[0]
-        t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)
-        qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
-        kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0)
-        return mean_flat(kl_prior) / np.log(2.0)
-
-    def p_losses(self, x_start, cond, t, noise=None):
-        noise = default(noise, lambda: torch.randn_like(x_start))
-        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
-        model_output = self.apply_model(x_noisy, t, cond)
-
-        loss_dict = {}
-        prefix = 'train' if self.training else 'val'
-
-        if self.parameterization == "x0":
-            target = x_start
-        elif self.parameterization == "eps":
-            target = noise
-        else:
-            raise NotImplementedError()
-
-        loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3])
-        loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()})
-
-        logvar_t = self.logvar[t].to(self.device)
-        loss = loss_simple / torch.exp(logvar_t) + logvar_t
-        # loss = loss_simple / torch.exp(self.logvar) + self.logvar
-        if self.learn_logvar:
-            loss_dict.update({f'{prefix}/loss_gamma': loss.mean()})
-            loss_dict.update({'logvar': self.logvar.data.mean()})
-
-        loss = self.l_simple_weight * loss.mean()
-
-        loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3))
-        loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()
-        loss_dict.update({f'{prefix}/loss_vlb': loss_vlb})
-        loss += (self.original_elbo_weight * loss_vlb)
-        loss_dict.update({f'{prefix}/loss': loss})
-
-        return loss, loss_dict
-
-    def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False,
-                        return_x0=False, score_corrector=None, corrector_kwargs=None):
-        t_in = t
-        model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)
-
-        if score_corrector is not None:
-            assert self.parameterization == "eps"
-            model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)
-
-        if return_codebook_ids:
-            model_out, logits = model_out
-
-        if self.parameterization == "eps":
-            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
-        elif self.parameterization == "x0":
-            x_recon = model_out
-        else:
-            raise NotImplementedError()
-
-        if clip_denoised:
-            x_recon.clamp_(-1., 1.)
-        if quantize_denoised:
-            x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)
-        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
-        if return_codebook_ids:
-            return model_mean, posterior_variance, posterior_log_variance, logits
-        elif return_x0:
-            return model_mean, posterior_variance, posterior_log_variance, x_recon
-        else:
-            return model_mean, posterior_variance, posterior_log_variance
-
-    @torch.no_grad()
-    def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False,
-                 return_codebook_ids=False, quantize_denoised=False, return_x0=False,
-                 temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None):
-        b, *_, device = *x.shape, x.device
-        outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised,
-                                       return_codebook_ids=return_codebook_ids,
-                                       quantize_denoised=quantize_denoised,
-                                       return_x0=return_x0,
-                                       score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
-        if return_codebook_ids:
-            raise DeprecationWarning("Support dropped.")
-            model_mean, _, model_log_variance, logits = outputs
-        elif return_x0:
-            model_mean, _, model_log_variance, x0 = outputs
-        else:
-            model_mean, _, model_log_variance = outputs
-
-        noise = noise_like(x.shape, device, repeat_noise) * temperature
-        if noise_dropout > 0.:
-            noise = torch.nn.functional.dropout(noise, p=noise_dropout)
-        # no noise when t == 0
-        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
-
-        if return_codebook_ids:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1)
-        if return_x0:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0
-        else:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
-
-    @torch.no_grad()
-    def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False,
-                              img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0.,
-                              score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None,
-                              log_every_t=None):
-        if not log_every_t:
-            log_every_t = self.log_every_t
-        timesteps = self.num_timesteps
-        if batch_size is not None:
-            b = batch_size if batch_size is not None else shape[0]
-            shape = [batch_size] + list(shape)
-        else:
-            b = batch_size = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=self.device)
-        else:
-            img = x_T
-        intermediates = []
-        if cond is not None:
-            if isinstance(cond, dict):
-                cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
-                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
-            else:
-                cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
-
-        if start_T is not None:
-            timesteps = min(timesteps, start_T)
-        iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation',
-                        total=timesteps) if verbose else reversed(
-            range(0, timesteps))
-        if type(temperature) == float:
-            temperature = [temperature] * timesteps
-
-        for i in iterator:
-            ts = torch.full((b,), i, device=self.device, dtype=torch.long)
-            if self.shorten_cond_schedule:
-                assert self.model.conditioning_key != 'hybrid'
-                tc = self.cond_ids[ts].to(cond.device)
-                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
-
-            img, x0_partial = self.p_sample(img, cond, ts,
-                                            clip_denoised=self.clip_denoised,
-                                            quantize_denoised=quantize_denoised, return_x0=True,
-                                            temperature=temperature[i], noise_dropout=noise_dropout,
-                                            score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
-            if mask is not None:
-                assert x0 is not None
-                img_orig = self.q_sample(x0, ts)
-                img = img_orig * mask + (1. - mask) * img
-
-            if i % log_every_t == 0 or i == timesteps - 1:
-                intermediates.append(x0_partial)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
-        return img, intermediates
-
-    @torch.no_grad()
-    def p_sample_loop(self, cond, shape, return_intermediates=False,
-                      x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False,
-                      mask=None, x0=None, img_callback=None, start_T=None,
-                      log_every_t=None):
-
-        if not log_every_t:
-            log_every_t = self.log_every_t
-        device = self.betas.device
-        b = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=device)
-        else:
-            img = x_T
-
-        intermediates = [img]
-        if timesteps is None:
-            timesteps = self.num_timesteps
-
-        if start_T is not None:
-            timesteps = min(timesteps, start_T)
-        iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(
-            range(0, timesteps))
-
-        if mask is not None:
-            assert x0 is not None
-            assert x0.shape[2:3] == mask.shape[2:3]  # spatial size has to match
-
-        for i in iterator:
-            ts = torch.full((b,), i, device=device, dtype=torch.long)
-            if self.shorten_cond_schedule:
-                assert self.model.conditioning_key != 'hybrid'
-                tc = self.cond_ids[ts].to(cond.device)
-                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
-
-            img = self.p_sample(img, cond, ts,
-                                clip_denoised=self.clip_denoised,
-                                quantize_denoised=quantize_denoised)
-            if mask is not None:
-                img_orig = self.q_sample(x0, ts)
-                img = img_orig * mask + (1. - mask) * img
-
-            if i % log_every_t == 0 or i == timesteps - 1:
-                intermediates.append(img)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
-
-        if return_intermediates:
-            return img, intermediates
-        return img
-
-    @torch.no_grad()
-    def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,
-               verbose=True, timesteps=None, quantize_denoised=False,
-               mask=None, x0=None, shape=None,**kwargs):
-        if shape is None:
-            shape = (batch_size, self.channels, self.image_size, self.image_size)
-        if cond is not None:
-            if isinstance(cond, dict):
-                cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
-                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
-            else:
-                cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
-        return self.p_sample_loop(cond,
-                                  shape,
-                                  return_intermediates=return_intermediates, x_T=x_T,
-                                  verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,
-                                  mask=mask, x0=x0)
-
-    @torch.no_grad()
-    def sample_log(self,cond,batch_size,ddim, ddim_steps,**kwargs):
-
-        if ddim:
-            ddim_sampler = DDIMSampler(self)
-            shape = (self.channels, self.image_size, self.image_size)
-            samples, intermediates =ddim_sampler.sample(ddim_steps,batch_size,
-                                                        shape,cond,verbose=False,**kwargs)
-
-        else:
-            samples, intermediates = self.sample(cond=cond, batch_size=batch_size,
-                                                 return_intermediates=True,**kwargs)
-
-        return samples, intermediates
-
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
-                   quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,
-                   plot_diffusion_rows=True, **kwargs):
-
-        use_ddim = ddim_steps is not None
-
-        log = dict()
-        z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,
-                                           return_first_stage_outputs=True,
-                                           force_c_encode=True,
-                                           return_original_cond=True,
-                                           bs=N)
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        log["inputs"] = x
-        log["reconstruction"] = xrec
-        if self.model.conditioning_key is not None:
-            if hasattr(self.cond_stage_model, "decode"):
-                xc = self.cond_stage_model.decode(c)
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ["caption"]:
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["caption"])
-                log["conditioning"] = xc
-            elif self.cond_stage_key == 'class_label':
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"])
-                log['conditioning'] = xc
-            elif isimage(xc):
-                log["conditioning"] = xc
-            if ismap(xc):
-                log["original_conditioning"] = self.to_rgb(xc)
-
-        if plot_diffusion_rows:
-            # get diffusion row
-            diffusion_row = list()
-            z_start = z[:n_row]
-            for t in range(self.num_timesteps):
-                if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                    t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                    t = t.to(self.device).long()
-                    noise = torch.randn_like(z_start)
-                    z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
-                    diffusion_row.append(self.decode_first_stage(z_noisy))
-
-            diffusion_row = torch.stack(diffusion_row)  # n_log_step, n_row, C, H, W
-            diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
-            diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
-            diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
-            log["diffusion_row"] = diffusion_grid
-
-        if sample:
-            # get denoise row
-            with self.ema_scope("Plotting"):
-                samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim,
-                                                         ddim_steps=ddim_steps,eta=ddim_eta)
-                # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
-            x_samples = self.decode_first_stage(samples)
-            log["samples"] = x_samples
-            if plot_denoise_rows:
-                denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
-                log["denoise_row"] = denoise_grid
-
-            if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance(
-                    self.first_stage_model, IdentityFirstStage):
-                # also display when quantizing x0 while sampling
-                with self.ema_scope("Plotting Quantized Denoised"):
-                    samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim,
-                                                             ddim_steps=ddim_steps,eta=ddim_eta,
-                                                             quantize_denoised=True)
-                    # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True,
-                    #                                      quantize_denoised=True)
-                x_samples = self.decode_first_stage(samples.to(self.device))
-                log["samples_x0_quantized"] = x_samples
-
-            if inpaint:
-                # make a simple center square
-                b, h, w = z.shape[0], z.shape[2], z.shape[3]
-                mask = torch.ones(N, h, w).to(self.device)
-                # zeros will be filled in
-                mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0.
-                mask = mask[:, None, ...]
-                with self.ema_scope("Plotting Inpaint"):
-
-                    samples, _ = self.sample_log(cond=c,batch_size=N,ddim=use_ddim, eta=ddim_eta,
-                                                ddim_steps=ddim_steps, x0=z[:N], mask=mask)
-                x_samples = self.decode_first_stage(samples.to(self.device))
-                log["samples_inpainting"] = x_samples
-                log["mask"] = mask
-
-                # outpaint
-                with self.ema_scope("Plotting Outpaint"):
-                    samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,eta=ddim_eta,
-                                                ddim_steps=ddim_steps, x0=z[:N], mask=mask)
-                x_samples = self.decode_first_stage(samples.to(self.device))
-                log["samples_outpainting"] = x_samples
-
-        if plot_progressive_rows:
-            with self.ema_scope("Plotting Progressives"):
-                img, progressives = self.progressive_denoising(c,
-                                                               shape=(self.channels, self.image_size, self.image_size),
-                                                               batch_size=N)
-            prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation")
-            log["progressive_row"] = prog_row
-
-        if return_keys:
-            if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
-                return log
-            else:
-                return {key: log[key] for key in return_keys}
-        return log
-
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        params = list(self.model.parameters())
-        if self.cond_stage_trainable:
-            print(f"{self.__class__.__name__}: Also optimizing conditioner params!")
-            params = params + list(self.cond_stage_model.parameters())
-        if self.learn_logvar:
-            print('Diffusion model optimizing logvar')
-            params.append(self.logvar)
-        opt = torch.optim.AdamW(params, lr=lr)
-        if self.use_scheduler:
-            assert 'target' in self.scheduler_config
-            scheduler = instantiate_from_config(self.scheduler_config)
-
-            print("Setting up LambdaLR scheduler...")
-            scheduler = [
-                {
-                    'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule),
-                    'interval': 'step',
-                    'frequency': 1
-                }]
-            return [opt], scheduler
-        return opt
-
-    @torch.no_grad()
-    def to_rgb(self, x):
-        x = x.float()
-        if not hasattr(self, "colorize"):
-            self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x)
-        x = nn.functional.conv2d(x, weight=self.colorize)
-        x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.
-        return x
-
-
-class DiffusionWrapper(pl.LightningModule):
-    def __init__(self, diff_model_config, conditioning_key):
-        super().__init__()
-        self.diffusion_model = instantiate_from_config(diff_model_config)
-        self.conditioning_key = conditioning_key # 'crossattn' for txt2image, concat for inpainting
-        assert self.conditioning_key in [None, 'concat', 'crossattn', 'hybrid', 'adm']
-
-    def forward(self, x, t, c_concat: list = None, c_crossattn: list = None):
-        """param x: tensor with shape:[B,C,mel_len,T]"""
-        if self.conditioning_key is None:
-            out = self.diffusion_model(x, t)
-        elif self.conditioning_key == 'concat':
-            xc = torch.cat([x] + c_concat, dim=1)# channel dim,x shape (b,3,64,64) c_concat shape(b,4,64,64)
-            out = self.diffusion_model(xc, t)
-        elif self.conditioning_key == 'crossattn':
-            cc = torch.cat(c_crossattn, 1)# [b,seq_len,dim]
-            out = self.diffusion_model(x, t, context=cc)
-        elif self.conditioning_key == 'hybrid':# not implemented in the LatentDiffusion
-            xc = torch.cat([x] + c_concat, dim=1)
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(xc, t, context=cc)
-        elif self.conditioning_key == 'adm':
-            cc = c_crossattn[0]
-            out = self.diffusion_model(x, t, y=cc)
-        else:
-            raise NotImplementedError()
-
-        return out
-
-
-class Layout2ImgDiffusion(LatentDiffusion):
-    # TODO: move all layout-specific hacks to this class
-    def __init__(self, cond_stage_key, *args, **kwargs):
-        assert cond_stage_key == 'coordinates_bbox', 'Layout2ImgDiffusion only for cond_stage_key="coordinates_bbox"'
-        super().__init__(cond_stage_key=cond_stage_key, *args, **kwargs)
-
-    def log_images(self, batch, N=8, *args, **kwargs):
-        logs = super().log_images(batch=batch, N=N, *args, **kwargs)
-
-        key = 'train' if self.training else 'validation'
-        dset = self.trainer.datamodule.datasets[key]
-        mapper = dset.conditional_builders[self.cond_stage_key]
-
-        bbox_imgs = []
-        map_fn = lambda catno: dset.get_textual_label(dset.get_category_id(catno))
-        for tknzd_bbox in batch[self.cond_stage_key][:N]:
-            bboximg = mapper.plot(tknzd_bbox.detach().cpu(), map_fn, (256, 256))
-            bbox_imgs.append(bboximg)
-
-        cond_img = torch.stack(bbox_imgs, dim=0)
-        logs['bbox_image'] = cond_img
-        return logs

spaces/AIGC-Audio/Make_An_Audio/wav_evaluation/models/audio.py

@@ -1,179 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torchlibrosa.stft import Spectrogram, LogmelFilterBank
-
-def get_audio_encoder(name: str):
-    if name == "Cnn14":
-        return Cnn14
-    else:
-        raise Exception('The audio encoder name {} is incorrect or not supported'.format(name))
-
-
-class ConvBlock(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        
-        super(ConvBlock, self).__init__()
-        
-        self.conv1 = nn.Conv2d(in_channels=in_channels, 
-                              out_channels=out_channels,
-                              kernel_size=(3, 3), stride=(1, 1),
-                              padding=(1, 1), bias=False)
-                              
-        self.conv2 = nn.Conv2d(in_channels=out_channels, 
-                              out_channels=out_channels,
-                              kernel_size=(3, 3), stride=(1, 1),
-                              padding=(1, 1), bias=False)
-                              
-        self.bn1 = nn.BatchNorm2d(out_channels)
-        self.bn2 = nn.BatchNorm2d(out_channels)
-
-        
-    def forward(self, input, pool_size=(2, 2), pool_type='avg'):
-        
-        x = input
-        x = F.relu_(self.bn1(self.conv1(x)))
-        x = F.relu_(self.bn2(self.conv2(x)))
-        if pool_type == 'max':
-            x = F.max_pool2d(x, kernel_size=pool_size)
-        elif pool_type == 'avg':
-            x = F.avg_pool2d(x, kernel_size=pool_size)
-        elif pool_type == 'avg+max':
-            x1 = F.avg_pool2d(x, kernel_size=pool_size)
-            x2 = F.max_pool2d(x, kernel_size=pool_size)
-            x = x1 + x2
-        else:
-            raise Exception('Incorrect argument!')
-        
-        return x
-
-
-class ConvBlock5x5(nn.Module):
-    def __init__(self, in_channels, out_channels):
-        
-        super(ConvBlock5x5, self).__init__()
-        
-        self.conv1 = nn.Conv2d(in_channels=in_channels, 
-                              out_channels=out_channels,
-                              kernel_size=(5, 5), stride=(1, 1),
-                              padding=(2, 2), bias=False)
-                              
-        self.bn1 = nn.BatchNorm2d(out_channels)
-
-        
-    def forward(self, input, pool_size=(2, 2), pool_type='avg'):
-        
-        x = input
-        x = F.relu_(self.bn1(self.conv1(x)))
-        if pool_type == 'max':
-            x = F.max_pool2d(x, kernel_size=pool_size)
-        elif pool_type == 'avg':
-            x = F.avg_pool2d(x, kernel_size=pool_size)
-        elif pool_type == 'avg+max':
-            x1 = F.avg_pool2d(x, kernel_size=pool_size)
-            x2 = F.max_pool2d(x, kernel_size=pool_size)
-            x = x1 + x2
-        else:
-            raise Exception('Incorrect argument!')
-        
-        return x
-
-
-class AttBlock(nn.Module):
-    def __init__(self, n_in, n_out, activation='linear', temperature=1.):
-        super(AttBlock, self).__init__()
-        
-        self.activation = activation
-        self.temperature = temperature
-        self.att = nn.Conv1d(in_channels=n_in, out_channels=n_out, kernel_size=1, stride=1, padding=0, bias=True)
-        self.cla = nn.Conv1d(in_channels=n_in, out_channels=n_out, kernel_size=1, stride=1, padding=0, bias=True)
-        
-        self.bn_att = nn.BatchNorm1d(n_out)
-         
-    def forward(self, x):
-        # x: (n_samples, n_in, n_time)
-        norm_att = torch.softmax(torch.clamp(self.att(x), -10, 10), dim=-1)
-        cla = self.nonlinear_transform(self.cla(x))
-        x = torch.sum(norm_att * cla, dim=2)
-        return x, norm_att, cla
-
-    def nonlinear_transform(self, x):
-        if self.activation == 'linear':
-            return x
-        elif self.activation == 'sigmoid':
-            return torch.sigmoid(x)
-
-
-class Cnn14(nn.Module):
-    def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, 
-        fmax, classes_num, out_emb):
-        
-        super(Cnn14, self).__init__()
-
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-        ref = 1.0
-        amin = 1e-10
-        top_db = None
-
-        # Spectrogram extractor
-        self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, 
-            win_length=window_size, window=window, center=center, pad_mode=pad_mode, 
-            freeze_parameters=True)
-
-        # Logmel feature extractor
-        self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, 
-            n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, 
-            freeze_parameters=True)
-
-        self.bn0 = nn.BatchNorm2d(64)
-
-        self.conv_block1 = ConvBlock(in_channels=1, out_channels=64)
-        self.conv_block2 = ConvBlock(in_channels=64, out_channels=128)
-        self.conv_block3 = ConvBlock(in_channels=128, out_channels=256)
-        self.conv_block4 = ConvBlock(in_channels=256, out_channels=512)
-        self.conv_block5 = ConvBlock(in_channels=512, out_channels=1024)
-        self.conv_block6 = ConvBlock(in_channels=1024, out_channels=2048)
-        
-        # out_emb is 2048 for best Cnn14
-        self.fc1 = nn.Linear(2048, out_emb, bias=True)
-        self.fc_audioset = nn.Linear(out_emb, classes_num, bias=True)
-        
-    def forward(self, input, mixup_lambda=None):
-        """
-        Input: (batch_size, data_length)
-        """
-
-        x = self.spectrogram_extractor(input)   # (batch_size, 1, time_steps, freq_bins)
-        x = self.logmel_extractor(x)    # (batch_size, 1, time_steps, mel_bins)
-
-        x = x.transpose(1, 3)
-        x = self.bn0(x)
-        x = x.transpose(1, 3)
-
-        x = self.conv_block1(x, pool_size=(2, 2), pool_type='avg')
-        x = F.dropout(x, p=0.2, training=self.training)
-        x = self.conv_block2(x, pool_size=(2, 2), pool_type='avg')
-        x = F.dropout(x, p=0.2, training=self.training)
-        x = self.conv_block3(x, pool_size=(2, 2), pool_type='avg')
-        x = F.dropout(x, p=0.2, training=self.training)
-        x = self.conv_block4(x, pool_size=(2, 2), pool_type='avg')
-        x = F.dropout(x, p=0.2, training=self.training)
-        x = self.conv_block5(x, pool_size=(2, 2), pool_type='avg')
-        x = F.dropout(x, p=0.2, training=self.training)
-        x = self.conv_block6(x, pool_size=(1, 1), pool_type='avg')
-        x = F.dropout(x, p=0.2, training=self.training)
-        x = torch.mean(x, dim=3)
-        
-        (x1, _) = torch.max(x, dim=2)
-        x2 = torch.mean(x, dim=2)
-        x = x1 + x2
-        x = F.dropout(x, p=0.5, training=self.training)
-        x = F.relu_(self.fc1(x))
-        embedding = F.dropout(x, p=0.5, training=self.training)
-        clipwise_output = torch.sigmoid(self.fc_audioset(x))
-        
-        output_dict = {'clipwise_output': clipwise_output, 'embedding': embedding}
-
-        return output_dict

spaces/AILab-CVC/SEED-LLaMA/gradio_demo/conversation.py

@@ -1,190 +0,0 @@
-import dataclasses
-from enum import auto, Enum
-from typing import List, Tuple
-
-import io
-import base64
-import os
-from PIL import Image
-import copy
-
-IMG_FLAG = '<image>'
-
-
-class SeparatorStyle(Enum):
-    """Different separator style."""
-    SINGLE = auto()
-    TWO = auto()
-    MPT = auto()
-    PLAIN = auto()
-    LLAMA_2 = auto()
-
-
-def decode_image(encoded_image: str) -> Image:
-    decoded_bytes = base64.b64decode(encoded_image.encode('utf-8'))
-    buffer = io.BytesIO(decoded_bytes)
-    image = Image.open(buffer)
-    return image
-
-
-def encode_image(image: Image.Image, format: str = 'PNG') -> str:
-    with io.BytesIO() as buffer:
-        image.save(buffer, format=format)
-        encoded_image = base64.b64encode(buffer.getvalue()).decode('utf-8')
-        return encoded_image
-
-
-@dataclasses.dataclass
-class Conversation:
-    """A class that keeps all conversation history."""
-    system: str
-    roles: List[str]
-    messages: List[dict]  # multi-turn -> user & assistant -> {'images': [PIL.Image,], 'text': str}
-    offset: int
-    sep_style: SeparatorStyle = SeparatorStyle.SINGLE
-    sep: str = "###"
-    sep2: str = None
-    version: str = "Unknown"
-
-    skip_next: bool = False
-
-    def get_prompt(self):
-        messages = copy.deepcopy(self.messages)
-        if self.sep_style == SeparatorStyle.SINGLE:
-            if self.system is None or self.system == '':
-                text = ''
-            else:
-                text = self.system + self.sep
-            images = []
-            for message in messages:
-                text += message['role'] + ": " + message['message']['text'] + self.sep
-                for image_path, image_ids in zip(message['message']['images'], message['message']['images_ids']):
-                    if image_ids is not None:
-                        images.append(image_ids)
-                    else:
-                        image = Image.open(image_path).resize((256, 256))
-                        image_base64 = encode_image(image)
-                        images.append(image_base64)
-
-            text += self.roles[1] + ":"
-        elif self.sep_style == SeparatorStyle.LLAMA_2:
-            b_token = "[INST] "
-            e_token = " [/INST]"
-            if self.system is None or self.system == '':
-                text = ''
-            else:
-                text = f"<<SYS>>\n{self.system}\n<</SYS>>\n\n"
-            images = []
-            for idx, message in enumerate(messages):
-                # text += message['role'] + ": " + message['message']['text'] + self.sep
-                if idx % 2 == 0:
-                    text += b_token + message['message']['text'] + e_token + self.sep
-                else:
-                    text += message['message']['text'] + self.sep
-
-                for image_path, image_ids in zip(message['message']['images'], message['message']['images_ids']):
-                    if image_ids is not None:
-                        images.append(image_ids)
-                    else:
-                        image = Image.open(image_path).resize((256, 256))
-                        image_base64 = encode_image(image)
-                        images.append(image_base64)
-        else:
-            raise NotImplementedError
-
-        return {'text': text, 'images': images}
-
-    def update_image_ids(self, images_ids):
-        image_count = 0
-        for message in self.messages:
-            for idx in range(len(message['message']['images_ids'])):
-                if message['message']["images_ids"][idx] is None:
-                    message['message']["images_ids"][idx] = images_ids[image_count]
-                image_count += 1
-
-        assert len(images_ids) == image_count, print(len(images_ids), image_count)
-
-    def append_message(self, role, message):
-        self.messages.append([role, message])
-
-    def to_gradio_chatbot(self):
-        dialog = []
-        for i, single_turn in enumerate(self.messages[self.offset:]):
-            single_turn = single_turn['message']
-            text_list = single_turn['text'].split(IMG_FLAG)
-            assert len(text_list) == len(single_turn['images']) + 1, print(text_list, len(single_turn['images']))
-            message = ''
-            for image_idx in range(len(single_turn['images'])):
-                # image = single_turn['images'][image_idx]
-                # image_base64 = encode_image(image)
-                # image_str = f'<img src="data:image/png;base64,{image_base64}" alt="user upload image" />'
-                image_path = single_turn['images'][image_idx]
-                if image_path == '':
-                    message += text_list[image_idx] + '<corrupt_image>'
-                else:
-                    message += text_list[image_idx] + f'![](file={image_path})'
-            message += text_list[-1]
-
-            if i % 2 == 0:
-                dialog.append([message, None])
-            else:
-                dialog[-1][-1] = message
-
-        return dialog
-
-    def copy(self):
-        return Conversation(system=self.system,
-                            roles=self.roles,
-                            messages=copy.deepcopy(self.messages),
-                            offset=self.offset,
-                            sep_style=self.sep_style,
-                            sep=self.sep,
-                            sep2=self.sep2,
-                            version=self.version)
-
-    def dict(self):
-        messages = copy.deepcopy(self.messages)
-        for message in messages:
-            if 'images_ids' in message:
-                message.pop('images_ids')
-            for i in range(len(message['message']['images'])):
-                message['message']['images'][i] = os.path.basename(message['message']['images'][i])
-        return {
-            "system": self.system,
-            "roles": self.roles,
-            "messages": messages,
-            "offset": self.offset,
-            "sep": self.sep,
-            "sep2": self.sep2,
-        }
-
-
-conv_seed_vicuna = Conversation(
-    system="",
-    roles=("USER", "ASSISTANT"),
-    version="v2",
-    messages=[],
-    offset=0,
-    sep_style=SeparatorStyle.SINGLE,
-    sep='\n',
-)
-
-conv_seed_vicuna_system = Conversation(
-    system="A chat between a curious user and an artificial intelligence assistant. ",
-    roles=("USER", "ASSISTANT"),
-    version="v2",
-    messages=[],
-    offset=0,
-    sep_style=SeparatorStyle.SINGLE,
-    sep='\n',
-)
-
-conv_seed_llama2 = Conversation(
-    system="",
-    roles=("[INST]", "[/INST]"),
-    version="v2",
-    messages=[],
-    offset=0,
-    sep_style=SeparatorStyle.LLAMA_2,
-    sep='\n',
-)

spaces/Abhaykoul/HelpingAI-2.0/README.md

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

spaces/Aditya9790/yolo7-object-tracking/utils/torch_utils.py

@@ -1,374 +0,0 @@
-# YOLOR PyTorch utils
-
-import datetime
-import logging
-import math
-import os
-import platform
-import subprocess
-import time
-from contextlib import contextmanager
-from copy import deepcopy
-from pathlib import Path
-
-import torch
-import torch.backends.cudnn as cudnn
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision
-
-try:
-    import thop  # for FLOPS computation
-except ImportError:
-    thop = None
-logger = logging.getLogger(__name__)
-
-
-@contextmanager
-def torch_distributed_zero_first(local_rank: int):
-    """
-    Decorator to make all processes in distributed training wait for each local_master to do something.
-    """
-    if local_rank not in [-1, 0]:
-        torch.distributed.barrier()
-    yield
-    if local_rank == 0:
-        torch.distributed.barrier()
-
-
-def init_torch_seeds(seed=0):
-    # Speed-reproducibility tradeoff https://pytorch.org/docs/stable/notes/randomness.html
-    torch.manual_seed(seed)
-    if seed == 0:  # slower, more reproducible
-        cudnn.benchmark, cudnn.deterministic = False, True
-    else:  # faster, less reproducible
-        cudnn.benchmark, cudnn.deterministic = True, False
-
-
-def date_modified(path=__file__):
-    # return human-readable file modification date, i.e. '2021-3-26'
-    t = datetime.datetime.fromtimestamp(Path(path).stat().st_mtime)
-    return f'{t.year}-{t.month}-{t.day}'
-
-
-def git_describe(path=Path(__file__).parent):  # path must be a directory
-    # return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe
-    s = f'git -C {path} describe --tags --long --always'
-    try:
-        return subprocess.check_output(s, shell=True, stderr=subprocess.STDOUT).decode()[:-1]
-    except subprocess.CalledProcessError as e:
-        return ''  # not a git repository
-
-
-def select_device(device='', batch_size=None):
-    # device = 'cpu' or '0' or '0,1,2,3'
-    s = f'YOLOR 🚀 {git_describe() or date_modified()} torch {torch.__version__} '  # string
-    cpu = device.lower() == 'cpu'
-    if cpu:
-        os.environ['CUDA_VISIBLE_DEVICES'] = '-1'  # force torch.cuda.is_available() = False
-    elif device:  # non-cpu device requested
-        os.environ['CUDA_VISIBLE_DEVICES'] = device  # set environment variable
-        assert torch.cuda.is_available(), f'CUDA unavailable, invalid device {device} requested'  # check availability
-
-    cuda = not cpu and torch.cuda.is_available()
-    if cuda:
-        n = torch.cuda.device_count()
-        if n > 1 and batch_size:  # check that batch_size is compatible with device_count
-            assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'
-        space = ' ' * len(s)
-        for i, d in enumerate(device.split(',') if device else range(n)):
-            p = torch.cuda.get_device_properties(i)
-            s += f"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / 1024 ** 2}MB)\n"  # bytes to MB
-    else:
-        s += 'CPU\n'
-
-    logger.info(s.encode().decode('ascii', 'ignore') if platform.system() == 'Windows' else s)  # emoji-safe
-    return torch.device('cuda:0' if cuda else 'cpu')
-
-
-def time_synchronized():
-    # pytorch-accurate time
-    if torch.cuda.is_available():
-        torch.cuda.synchronize()
-    return time.time()
-
-
-def profile(x, ops, n=100, device=None):
-    # profile a pytorch module or list of modules. Example usage:
-    #     x = torch.randn(16, 3, 640, 640)  # input
-    #     m1 = lambda x: x * torch.sigmoid(x)
-    #     m2 = nn.SiLU()
-    #     profile(x, [m1, m2], n=100)  # profile speed over 100 iterations
-
-    device = device or torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
-    x = x.to(device)
-    x.requires_grad = True
-    print(torch.__version__, device.type, torch.cuda.get_device_properties(0) if device.type == 'cuda' else '')
-    print(f"\n{'Params':>12s}{'GFLOPS':>12s}{'forward (ms)':>16s}{'backward (ms)':>16s}{'input':>24s}{'output':>24s}")
-    for m in ops if isinstance(ops, list) else [ops]:
-        m = m.to(device) if hasattr(m, 'to') else m  # device
-        m = m.half() if hasattr(m, 'half') and isinstance(x, torch.Tensor) and x.dtype is torch.float16 else m  # type
-        dtf, dtb, t = 0., 0., [0., 0., 0.]  # dt forward, backward
-        try:
-            flops = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2  # GFLOPS
-        except:
-            flops = 0
-
-        for _ in range(n):
-            t[0] = time_synchronized()
-            y = m(x)
-            t[1] = time_synchronized()
-            try:
-                _ = y.sum().backward()
-                t[2] = time_synchronized()
-            except:  # no backward method
-                t[2] = float('nan')
-            dtf += (t[1] - t[0]) * 1000 / n  # ms per op forward
-            dtb += (t[2] - t[1]) * 1000 / n  # ms per op backward
-
-        s_in = tuple(x.shape) if isinstance(x, torch.Tensor) else 'list'
-        s_out = tuple(y.shape) if isinstance(y, torch.Tensor) else 'list'
-        p = sum(list(x.numel() for x in m.parameters())) if isinstance(m, nn.Module) else 0  # parameters
-        print(f'{p:12}{flops:12.4g}{dtf:16.4g}{dtb:16.4g}{str(s_in):>24s}{str(s_out):>24s}')
-
-
-def is_parallel(model):
-    return type(model) in (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel)
-
-
-def intersect_dicts(da, db, exclude=()):
-    # Dictionary intersection of matching keys and shapes, omitting 'exclude' keys, using da values
-    return {k: v for k, v in da.items() if k in db and not any(x in k for x in exclude) and v.shape == db[k].shape}
-
-
-def initialize_weights(model):
-    for m in model.modules():
-        t = type(m)
-        if t is nn.Conv2d:
-            pass  # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
-        elif t is nn.BatchNorm2d:
-            m.eps = 1e-3
-            m.momentum = 0.03
-        elif t in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
-            m.inplace = True
-
-
-def find_modules(model, mclass=nn.Conv2d):
-    # Finds layer indices matching module class 'mclass'
-    return [i for i, m in enumerate(model.module_list) if isinstance(m, mclass)]
-
-
-def sparsity(model):
-    # Return global model sparsity
-    a, b = 0., 0.
-    for p in model.parameters():
-        a += p.numel()
-        b += (p == 0).sum()
-    return b / a
-
-
-def prune(model, amount=0.3):
-    # Prune model to requested global sparsity
-    import torch.nn.utils.prune as prune
-    print('Pruning model... ', end='')
-    for name, m in model.named_modules():
-        if isinstance(m, nn.Conv2d):
-            prune.l1_unstructured(m, name='weight', amount=amount)  # prune
-            prune.remove(m, 'weight')  # make permanent
-    print(' %.3g global sparsity' % sparsity(model))
-
-
-def fuse_conv_and_bn(conv, bn):
-    # Fuse convolution and batchnorm layers https://tehnokv.com/posts/fusing-batchnorm-and-conv/
-    fusedconv = nn.Conv2d(conv.in_channels,
-                          conv.out_channels,
-                          kernel_size=conv.kernel_size,
-                          stride=conv.stride,
-                          padding=conv.padding,
-                          groups=conv.groups,
-                          bias=True).requires_grad_(False).to(conv.weight.device)
-
-    # prepare filters
-    w_conv = conv.weight.clone().view(conv.out_channels, -1)
-    w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var)))
-    fusedconv.weight.copy_(torch.mm(w_bn, w_conv).view(fusedconv.weight.shape))
-
-    # prepare spatial bias
-    b_conv = torch.zeros(conv.weight.size(0), device=conv.weight.device) if conv.bias is None else conv.bias
-    b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps))
-    fusedconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn)
-
-    return fusedconv
-
-
-def model_info(model, verbose=False, img_size=640):
-    # Model information. img_size may be int or list, i.e. img_size=640 or img_size=[640, 320]
-    n_p = sum(x.numel() for x in model.parameters())  # number parameters
-    n_g = sum(x.numel() for x in model.parameters() if x.requires_grad)  # number gradients
-    if verbose:
-        print('%5s %40s %9s %12s %20s %10s %10s' % ('layer', 'name', 'gradient', 'parameters', 'shape', 'mu', 'sigma'))
-        for i, (name, p) in enumerate(model.named_parameters()):
-            name = name.replace('module_list.', '')
-            print('%5g %40s %9s %12g %20s %10.3g %10.3g' %
-                  (i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std()))
-
-    try:  # FLOPS
-        from thop import profile
-        stride = max(int(model.stride.max()), 32) if hasattr(model, 'stride') else 32
-        img = torch.zeros((1, model.yaml.get('ch', 3), stride, stride), device=next(model.parameters()).device)  # input
-        flops = profile(deepcopy(model), inputs=(img,), verbose=False)[0] / 1E9 * 2  # stride GFLOPS
-        img_size = img_size if isinstance(img_size, list) else [img_size, img_size]  # expand if int/float
-        fs = ', %.1f GFLOPS' % (flops * img_size[0] / stride * img_size[1] / stride)  # 640x640 GFLOPS
-    except (ImportError, Exception):
-        fs = ''
-
-    logger.info(f"Model Summary: {len(list(model.modules()))} layers, {n_p} parameters, {n_g} gradients{fs}")
-
-
-def load_classifier(name='resnet101', n=2):
-    # Loads a pretrained model reshaped to n-class output
-    model = torchvision.models.__dict__[name](pretrained=True)
-
-    # ResNet model properties
-    # input_size = [3, 224, 224]
-    # input_space = 'RGB'
-    # input_range = [0, 1]
-    # mean = [0.485, 0.456, 0.406]
-    # std = [0.229, 0.224, 0.225]
-
-    # Reshape output to n classes
-    filters = model.fc.weight.shape[1]
-    model.fc.bias = nn.Parameter(torch.zeros(n), requires_grad=True)
-    model.fc.weight = nn.Parameter(torch.zeros(n, filters), requires_grad=True)
-    model.fc.out_features = n
-    return model
-
-
-def scale_img(img, ratio=1.0, same_shape=False, gs=32):  # img(16,3,256,416)
-    # scales img(bs,3,y,x) by ratio constrained to gs-multiple
-    if ratio == 1.0:
-        return img
-    else:
-        h, w = img.shape[2:]
-        s = (int(h * ratio), int(w * ratio))  # new size
-        img = F.interpolate(img, size=s, mode='bilinear', align_corners=False)  # resize
-        if not same_shape:  # pad/crop img
-            h, w = [math.ceil(x * ratio / gs) * gs for x in (h, w)]
-        return F.pad(img, [0, w - s[1], 0, h - s[0]], value=0.447)  # value = imagenet mean
-
-
-def copy_attr(a, b, include=(), exclude=()):
-    # Copy attributes from b to a, options to only include [...] and to exclude [...]
-    for k, v in b.__dict__.items():
-        if (len(include) and k not in include) or k.startswith('_') or k in exclude:
-            continue
-        else:
-            setattr(a, k, v)
-
-
-class ModelEMA:
-    """ Model Exponential Moving Average from https://github.com/rwightman/pytorch-image-models
-    Keep a moving average of everything in the model state_dict (parameters and buffers).
-    This is intended to allow functionality like
-    https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage
-    A smoothed version of the weights is necessary for some training schemes to perform well.
-    This class is sensitive where it is initialized in the sequence of model init,
-    GPU assignment and distributed training wrappers.
-    """
-
-    def __init__(self, model, decay=0.9999, updates=0):
-        # Create EMA
-        self.ema = deepcopy(model.module if is_parallel(model) else model).eval()  # FP32 EMA
-        # if next(model.parameters()).device.type != 'cpu':
-        #     self.ema.half()  # FP16 EMA
-        self.updates = updates  # number of EMA updates
-        self.decay = lambda x: decay * (1 - math.exp(-x / 2000))  # decay exponential ramp (to help early epochs)
-        for p in self.ema.parameters():
-            p.requires_grad_(False)
-
-    def update(self, model):
-        # Update EMA parameters
-        with torch.no_grad():
-            self.updates += 1
-            d = self.decay(self.updates)
-
-            msd = model.module.state_dict() if is_parallel(model) else model.state_dict()  # model state_dict
-            for k, v in self.ema.state_dict().items():
-                if v.dtype.is_floating_point:
-                    v *= d
-                    v += (1. - d) * msd[k].detach()
-
-    def update_attr(self, model, include=(), exclude=('process_group', 'reducer')):
-        # Update EMA attributes
-        copy_attr(self.ema, model, include, exclude)
-
-
-class BatchNormXd(torch.nn.modules.batchnorm._BatchNorm):
-    def _check_input_dim(self, input):
-        # The only difference between BatchNorm1d, BatchNorm2d, BatchNorm3d, etc
-        # is this method that is overwritten by the sub-class
-        # This original goal of this method was for tensor sanity checks
-        # If you're ok bypassing those sanity checks (eg. if you trust your inference
-        # to provide the right dimensional inputs), then you can just use this method
-        # for easy conversion from SyncBatchNorm
-        # (unfortunately, SyncBatchNorm does not store the original class - if it did
-        #  we could return the one that was originally created)
-        return
-
-def revert_sync_batchnorm(module):
-    # this is very similar to the function that it is trying to revert:
-    # https://github.com/pytorch/pytorch/blob/c8b3686a3e4ba63dc59e5dcfe5db3430df256833/torch/nn/modules/batchnorm.py#L679
-    module_output = module
-    if isinstance(module, torch.nn.modules.batchnorm.SyncBatchNorm):
-        new_cls = BatchNormXd
-        module_output = BatchNormXd(module.num_features,
-                                               module.eps, module.momentum,
-                                               module.affine,
-                                               module.track_running_stats)
-        if module.affine:
-            with torch.no_grad():
-                module_output.weight = module.weight
-                module_output.bias = module.bias
-        module_output.running_mean = module.running_mean
-        module_output.running_var = module.running_var
-        module_output.num_batches_tracked = module.num_batches_tracked
-        if hasattr(module, "qconfig"):
-            module_output.qconfig = module.qconfig
-    for name, child in module.named_children():
-        module_output.add_module(name, revert_sync_batchnorm(child))
-    del module
-    return module_output
-
-
-class TracedModel(nn.Module):
-
-    def __init__(self, model=None, device=None, img_size=(640,640)): 
-        super(TracedModel, self).__init__()
-        
-        print(" Convert model to Traced-model... ") 
-        self.stride = model.stride
-        self.names = model.names
-        self.model = model
-
-        self.model = revert_sync_batchnorm(self.model)
-        self.model.to('cpu')
-        self.model.eval()
-
-        self.detect_layer = self.model.model[-1]
-        self.model.traced = True
-        
-        rand_example = torch.rand(1, 3, img_size, img_size)
-        
-        traced_script_module = torch.jit.trace(self.model, rand_example, strict=False)
-        #traced_script_module = torch.jit.script(self.model)
-        traced_script_module.save("traced_model.pt")
-        print(" traced_script_module saved! ")
-        self.model = traced_script_module
-        self.model.to(device)
-        self.detect_layer.to(device)
-        print(" model is traced! \n") 
-
-    def forward(self, x, augment=False, profile=False):
-        out = self.model(x)
-        out = self.detect_layer(out)
-        return out

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

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

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/basesizer/utils/AddChild.js

@@ -1,16 +0,0 @@
-import Container from '../../container/Container.js';
-
-const ContainerAdd = Container.prototype.add;
-
-var AddChild = function (gameObject) {
-    ContainerAdd.call(this, gameObject);
-
-    if (this.sizerEventsEnable) {
-        gameObject.emit('sizer.add', gameObject, this);
-        this.emit('add', gameObject, this);
-    }
-
-    return this;
-}
-
-export default AddChild;

spaces/Andy1621/uniformer_image_detection/configs/ssd/README.md

@@ -1,21 +0,0 @@
-# SSD: Single Shot MultiBox Detector
-
-## Introduction
-
-[ALGORITHM]
-
-```latex
-@article{Liu_2016,
-   title={SSD: Single Shot MultiBox Detector},
-   journal={ECCV},
-   author={Liu, Wei and Anguelov, Dragomir and Erhan, Dumitru and Szegedy, Christian and Reed, Scott and Fu, Cheng-Yang and Berg, Alexander C.},
-   year={2016},
-}
-```
-
-## Results and models
-
-| Backbone | Size  | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download |
-| :------: | :---: | :---: | :-----: | :------: | :------------: | :----: | :------: |  :--------: |
-|  VGG16   |  300  | caffe |  120e   |   10.2   |  43.7          |  25.6  | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/ssd/ssd300_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/ssd/ssd300_coco/ssd300_coco_20200307-a92d2092.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/ssd/ssd300_coco/ssd300_coco_20200307_174216.log.json) |
-|  VGG16   |  512  | caffe |  120e   |   9.3    |  30.7          |  29.4  | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/ssd/ssd512_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/ssd/ssd512_coco/ssd512_coco_20200308-038c5591.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/ssd/ssd512_coco/ssd512_coco_20200308_134447.log.json) |

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

@@ -1,187 +0,0 @@
-from mmcv.cnn import build_conv_layer, build_norm_layer
-from torch import nn as nn
-
-
-class ResLayer(nn.Sequential):
-    """ResLayer to build ResNet style backbone.
-
-    Args:
-        block (nn.Module): block used to build ResLayer.
-        inplanes (int): inplanes of block.
-        planes (int): planes of block.
-        num_blocks (int): number of blocks.
-        stride (int): stride of the first block. Default: 1
-        avg_down (bool): Use AvgPool instead of stride conv when
-            downsampling in the bottleneck. Default: False
-        conv_cfg (dict): dictionary to construct and config conv layer.
-            Default: None
-        norm_cfg (dict): dictionary to construct and config norm layer.
-            Default: dict(type='BN')
-        downsample_first (bool): Downsample at the first block or last block.
-            False for Hourglass, True for ResNet. Default: True
-    """
-
-    def __init__(self,
-                 block,
-                 inplanes,
-                 planes,
-                 num_blocks,
-                 stride=1,
-                 avg_down=False,
-                 conv_cfg=None,
-                 norm_cfg=dict(type='BN'),
-                 downsample_first=True,
-                 **kwargs):
-        self.block = block
-
-        downsample = None
-        if stride != 1 or inplanes != planes * block.expansion:
-            downsample = []
-            conv_stride = stride
-            if avg_down:
-                conv_stride = 1
-                downsample.append(
-                    nn.AvgPool2d(
-                        kernel_size=stride,
-                        stride=stride,
-                        ceil_mode=True,
-                        count_include_pad=False))
-            downsample.extend([
-                build_conv_layer(
-                    conv_cfg,
-                    inplanes,
-                    planes * block.expansion,
-                    kernel_size=1,
-                    stride=conv_stride,
-                    bias=False),
-                build_norm_layer(norm_cfg, planes * block.expansion)[1]
-            ])
-            downsample = nn.Sequential(*downsample)
-
-        layers = []
-        if downsample_first:
-            layers.append(
-                block(
-                    inplanes=inplanes,
-                    planes=planes,
-                    stride=stride,
-                    downsample=downsample,
-                    conv_cfg=conv_cfg,
-                    norm_cfg=norm_cfg,
-                    **kwargs))
-            inplanes = planes * block.expansion
-            for _ in range(1, num_blocks):
-                layers.append(
-                    block(
-                        inplanes=inplanes,
-                        planes=planes,
-                        stride=1,
-                        conv_cfg=conv_cfg,
-                        norm_cfg=norm_cfg,
-                        **kwargs))
-
-        else:  # downsample_first=False is for HourglassModule
-            for _ in range(num_blocks - 1):
-                layers.append(
-                    block(
-                        inplanes=inplanes,
-                        planes=inplanes,
-                        stride=1,
-                        conv_cfg=conv_cfg,
-                        norm_cfg=norm_cfg,
-                        **kwargs))
-            layers.append(
-                block(
-                    inplanes=inplanes,
-                    planes=planes,
-                    stride=stride,
-                    downsample=downsample,
-                    conv_cfg=conv_cfg,
-                    norm_cfg=norm_cfg,
-                    **kwargs))
-        super(ResLayer, self).__init__(*layers)
-
-
-class SimplifiedBasicBlock(nn.Module):
-    """Simplified version of original basic residual block. This is used in
-    `SCNet <https://arxiv.org/abs/2012.10150>`_.
-
-    - Norm layer is now optional
-    - Last ReLU in forward function is removed
-    """
-    expansion = 1
-
-    def __init__(self,
-                 inplanes,
-                 planes,
-                 stride=1,
-                 dilation=1,
-                 downsample=None,
-                 style='pytorch',
-                 with_cp=False,
-                 conv_cfg=None,
-                 norm_cfg=dict(type='BN'),
-                 dcn=None,
-                 plugins=None):
-        super(SimplifiedBasicBlock, self).__init__()
-        assert dcn is None, 'Not implemented yet.'
-        assert plugins is None, 'Not implemented yet.'
-        assert not with_cp, 'Not implemented yet.'
-        self.with_norm = norm_cfg is not None
-        with_bias = True if norm_cfg is None else False
-        self.conv1 = build_conv_layer(
-            conv_cfg,
-            inplanes,
-            planes,
-            3,
-            stride=stride,
-            padding=dilation,
-            dilation=dilation,
-            bias=with_bias)
-        if self.with_norm:
-            self.norm1_name, norm1 = build_norm_layer(
-                norm_cfg, planes, postfix=1)
-            self.add_module(self.norm1_name, norm1)
-        self.conv2 = build_conv_layer(
-            conv_cfg, planes, planes, 3, padding=1, bias=with_bias)
-        if self.with_norm:
-            self.norm2_name, norm2 = build_norm_layer(
-                norm_cfg, planes, postfix=2)
-            self.add_module(self.norm2_name, norm2)
-
-        self.relu = nn.ReLU(inplace=True)
-        self.downsample = downsample
-        self.stride = stride
-        self.dilation = dilation
-        self.with_cp = with_cp
-
-    @property
-    def norm1(self):
-        """nn.Module: normalization layer after the first convolution layer"""
-        return getattr(self, self.norm1_name) if self.with_norm else None
-
-    @property
-    def norm2(self):
-        """nn.Module: normalization layer after the second convolution layer"""
-        return getattr(self, self.norm2_name) if self.with_norm else None
-
-    def forward(self, x):
-        """Forward function."""
-
-        identity = x
-
-        out = self.conv1(x)
-        if self.with_norm:
-            out = self.norm1(out)
-        out = self.relu(out)
-
-        out = self.conv2(out)
-        if self.with_norm:
-            out = self.norm2(out)
-
-        if self.downsample is not None:
-            identity = self.downsample(x)
-
-        out += identity
-
-        return out

spaces/AndyCer/TehVenom-MPT-7b-Chat-Instruct-LongCTX-Merge/README.md

@@ -1,12 +0,0 @@
----
-title: TehVenom MPT 7b Chat Instruct LongCTX Merge
-emoji: 📉
-colorFrom: gray
-colorTo: blue
-sdk: gradio
-sdk_version: 3.29.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Anthony7906/MengHuiMXD_GPT/Dockerfile

@@ -1,15 +0,0 @@
-FROM python:3.9 as builder
-RUN apt-get update && apt-get install -y build-essential
-COPY requirements.txt .
-COPY requirements_advanced.txt .
-RUN pip install --user -r requirements.txt
-# RUN pip install --user -r requirements_advanced.txt
-
-FROM python:3.9
-MAINTAINER iskoldt
-COPY --from=builder /root/.local /root/.local
-ENV PATH=/root/.local/bin:$PATH
-COPY . /app
-WORKDIR /app
-ENV dockerrun yes
-CMD ["python3", "-u", "ChuanhuChatbot.py", "2>&1", "|", "tee", "/var/log/application.log"]

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/vision.cpp

@@ -1,117 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-
-#include <torch/extension.h>
-#include "ROIAlignRotated/ROIAlignRotated.h"
-#include "box_iou_rotated/box_iou_rotated.h"
-#include "cocoeval/cocoeval.h"
-#include "deformable/deform_conv.h"
-#include "nms_rotated/nms_rotated.h"
-
-namespace detectron2 {
-
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-extern int get_cudart_version();
-#endif
-
-std::string get_cuda_version() {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-  std::ostringstream oss;
-
-#if defined(WITH_CUDA)
-  oss << "CUDA ";
-#else
-  oss << "HIP ";
-#endif
-
-  // copied from
-  // https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/cuda/detail/CUDAHooks.cpp#L231
-  auto printCudaStyleVersion = [&](int v) {
-    oss << (v / 1000) << "." << (v / 10 % 100);
-    if (v % 10 != 0) {
-      oss << "." << (v % 10);
-    }
-  };
-  printCudaStyleVersion(get_cudart_version());
-  return oss.str();
-#else // neither CUDA nor HIP
-  return std::string("not available");
-#endif
-}
-
-bool has_cuda() {
-#if defined(WITH_CUDA)
-  return true;
-#else
-  return false;
-#endif
-}
-
-// similar to
-// https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/Version.cpp
-std::string get_compiler_version() {
-  std::ostringstream ss;
-#if defined(__GNUC__)
-#ifndef __clang__
-
-#if ((__GNUC__ <= 4) && (__GNUC_MINOR__ <= 8))
-#error "GCC >= 4.9 is required!"
-#endif
-
-  { ss << "GCC " << __GNUC__ << "." << __GNUC_MINOR__; }
-#endif
-#endif
-
-#if defined(__clang_major__)
-  {
-    ss << "clang " << __clang_major__ << "." << __clang_minor__ << "."
-       << __clang_patchlevel__;
-  }
-#endif
-
-#if defined(_MSC_VER)
-  { ss << "MSVC " << _MSC_FULL_VER; }
-#endif
-  return ss.str();
-}
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
-  m.def("get_compiler_version", &get_compiler_version, "get_compiler_version");
-  m.def("get_cuda_version", &get_cuda_version, "get_cuda_version");
-  m.def("has_cuda", &has_cuda, "has_cuda");
-
-  m.def("deform_conv_forward", &deform_conv_forward, "deform_conv_forward");
-  m.def(
-      "deform_conv_backward_input",
-      &deform_conv_backward_input,
-      "deform_conv_backward_input");
-  m.def(
-      "deform_conv_backward_filter",
-      &deform_conv_backward_filter,
-      "deform_conv_backward_filter");
-  m.def(
-      "modulated_deform_conv_forward",
-      &modulated_deform_conv_forward,
-      "modulated_deform_conv_forward");
-  m.def(
-      "modulated_deform_conv_backward",
-      &modulated_deform_conv_backward,
-      "modulated_deform_conv_backward");
-
-  m.def("COCOevalAccumulate", &COCOeval::Accumulate, "COCOeval::Accumulate");
-  m.def(
-      "COCOevalEvaluateImages",
-      &COCOeval::EvaluateImages,
-      "COCOeval::EvaluateImages");
-  pybind11::class_<COCOeval::InstanceAnnotation>(m, "InstanceAnnotation")
-      .def(pybind11::init<uint64_t, double, double, bool, bool>());
-  pybind11::class_<COCOeval::ImageEvaluation>(m, "ImageEvaluation")
-      .def(pybind11::init<>());
-}
-
-TORCH_LIBRARY(detectron2, m) {
-  m.def("nms_rotated", &nms_rotated);
-  m.def("box_iou_rotated", &box_iou_rotated);
-  m.def("roi_align_rotated_forward", &ROIAlignRotated_forward);
-  m.def("roi_align_rotated_backward", &ROIAlignRotated_backward);
-}
-} // namespace detectron2

spaces/BAAI/vid2vid-zero/gradio_demo/app_running.py

@@ -1,169 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import annotations
-
-import os
-
-import gradio as gr
-
-from gradio_demo.runner import Runner
-
-
-def create_demo(runner: Runner,
-                pipe: InferencePipeline | None = None) -> gr.Blocks:
-    hf_token = os.getenv('HF_TOKEN')
-    with gr.Blocks() as demo:
-        with gr.Row():
-            with gr.Column():
-                with gr.Box():
-                    gr.Markdown('Input Data')
-                    input_video = gr.File(label='Input video')
-                    input_prompt = gr.Textbox(
-                        label='Input prompt',
-                        max_lines=1,
-                        placeholder='A car is moving on the road.')
-                    gr.Markdown('''
-                        - Upload a video and write a `Input Prompt` that describes the video.
-                        ''')
-
-            with gr.Column():
-                with gr.Box():
-                    gr.Markdown('Input Parameters')
-                    with gr.Row():
-                        model_path = gr.Text(
-                            label='Path to off-the-shelf model',
-                            value='CompVis/stable-diffusion-v1-4',
-                            max_lines=1)
-                        resolution = gr.Dropdown(choices=['512', '768'],
-                                                 value='512',
-                                                 label='Resolution',
-                                                 visible=False)
-
-                    with gr.Accordion('Advanced settings', open=False):
-                        sample_start_idx = gr.Number(
-                            label='Start Frame Index',value=0)
-                        sample_frame_rate = gr.Number(
-                            label='Frame Rate',value=1)
-                        n_sample_frames = gr.Number(
-                            label='Number of Frames',value=8)
-                        guidance_scale = gr.Number(
-                            label='Guidance Scale', value=7.5)
-                        seed = gr.Slider(label='Seed',
-                                         minimum=0,
-                                         maximum=100000,
-                                         step=1,
-                                         randomize=True,
-                                         value=33)
-                        input_token = gr.Text(label='Hugging Face Write Token',
-                                              placeholder='',
-                                              visible=False if hf_token else True)
-                    gr.Markdown('''
-                        - Upload input video or choose an exmple blow
-                        - Set hyperparameters & click start
-                        - It takes a few minutes to download model first
-                    ''')
-
-        with gr.Row():
-            with gr.Column():
-                validation_prompt = gr.Text(
-                    label='Validation Prompt',
-                    placeholder=
-                    'prompt to test the model, e.g: a Lego man is surfing')
-
-        remove_gpu_after_running = gr.Checkbox(
-            label='Remove GPU after running',
-            value=False,
-            interactive=bool(os.getenv('SPACE_ID')),
-            visible=False)
-
-        with gr.Row():
-            result = gr.Video(label='Result')
-
-        # examples
-        with gr.Row():
-            examples = [
-                [
-                    'CompVis/stable-diffusion-v1-4',
-                    "data/car-moving.mp4",
-                    'A car is moving on the road.',
-                    8, 0, 1,
-                    'A jeep car is moving on the desert.',
-                    7.5, 512, 33,
-                    False, None,
-                ],
-
-                [
-                    'CompVis/stable-diffusion-v1-4',
-                    "data/black-swan.mp4",
-                    'A blackswan is swimming on the water.',
-                    8, 0, 4,
-                    'A white swan is swimming on the water.',
-                    7.5, 512, 33,
-                    False, None,
-                ],
-
-                [
-                    'CompVis/stable-diffusion-v1-4',
-                    "data/child-riding.mp4",
-                    'A child is riding a bike on the road.',
-                    8, 0, 1,
-                    'A lego child is riding a bike on the road.',
-                    7.5, 512, 33,
-                    False, None,
-                ],
-
-                [
-                    'CompVis/stable-diffusion-v1-4',
-                    "data/car-turn.mp4",
-                    'A jeep car is moving on the road.',
-                    8, 0, 6,
-                    'A jeep car is moving on the snow.',
-                    7.5, 512, 33,
-                    False, None,
-                ],
-
-                [
-                    'CompVis/stable-diffusion-v1-4',
-                    "data/rabbit-watermelon.mp4",
-                    'A rabbit is eating a watermelon.',
-                    8, 0, 6,
-                    'A puppy is eating an orange.',
-                    7.5, 512, 33,
-                    False, None,
-                ],
-
-            ]
-            gr.Examples(examples=examples,
-                        fn=runner.run_vid2vid_zero,
-                        inputs=[
-                            model_path, input_video, input_prompt,
-                            n_sample_frames, sample_start_idx, sample_frame_rate,
-                            validation_prompt, guidance_scale, resolution, seed,
-                            remove_gpu_after_running,
-                            input_token,
-                        ],
-                        outputs=result,
-                        cache_examples=os.getenv('SYSTEM') == 'spaces'
-                        )
-
-        # run
-        run_button_vid2vid_zero = gr.Button('Start vid2vid-zero')
-        run_button_vid2vid_zero.click(
-            fn=runner.run_vid2vid_zero,
-            inputs=[
-                model_path, input_video, input_prompt,
-                n_sample_frames, sample_start_idx, sample_frame_rate,
-                validation_prompt, guidance_scale, resolution, seed,
-                remove_gpu_after_running,
-                input_token,
-            ],
-            outputs=result)
-
-    return demo
-
-
-if __name__ == '__main__':
-    hf_token = os.getenv('HF_TOKEN')
-    runner = Runner(hf_token)
-    demo = create_demo(runner)
-    demo.queue(max_size=1).launch(share=False)

spaces/BFH/BKMotionsAI/app.py

@@ -1,86 +0,0 @@
-#!/usr/bin/env python
-# coding: utf-8
-
-import gradio as gr
-import numpy as np
-import requests
-from transformers import AutoModelForSequenceClassification, AutoTokenizer, TextClassificationPipeline, pipeline
-from langdetect import detect
-from matplotlib import pyplot as plt
-import imageio
-
-# Load the model
-model = AutoModelForSequenceClassification.from_pretrained("saved_model") 
-tokenizer = AutoTokenizer.from_pretrained("saved_model")
-pipe = TextClassificationPipeline(model=model, tokenizer=tokenizer)
-
-# Function called by the UI
-def attribution(text):
-    
-    # Clean the plot
-    plt.clf()
-    
-    # Detect the language
-    language = detect(text)
-     
-    # Translate the input in german if necessary
-    if language == 'fr':
-        translator = pipeline("translation", model="Helsinki-NLP/opus-mt-fr-de")
-        translatedText = translator(text[0:1000])
-        text = translatedText[0]["translation_text"]
-    elif language != 'de':
-        return "The language is not recognized, it must be either in German or in French.", None
-    
-    # Set the bars of the bar chart
-    bars = ""
-    if language == 'fr':
-        bars = ("DDPS", "DFI", "AS-MPC", "DFJP", "DEFR", "DETEC", "DFAE", "Parl", "ChF", "DFF", "AF", "TF")
-    else:
-        bars = ("VBS", "EDI", "AB-BA", "EJPD", "WBF", "UVEK", "EDA", "Parl", "BK", "EFD", "BV", "BGer")
-
-    # Make the prediction with the 1000 first characters 
-    results = pipe(text[0:1000], return_all_scores=True)
-    rates = [row["score"] for row in results[0]]
-    
-    # Bar chart
-    y_pos = np.arange(len(bars))
-    plt.barh(y_pos, rates)
-    plt.yticks(y_pos, bars)
-    
-    # Set the output text
-    name = ""    
-    maxRate = np.max(rates)
-    maxIndex = np.argmax(rates)
-
-    # ML model not sure if highest probability < 60%
-    if maxRate < 0.6:
-        # de / fr
-        if language == 'de':
-            name = "Das ML-Modell ist nicht sicher. Das Departement könnte sein : \n\n"
-        else:
-            name = "Le modèle ML n'est pas sûr. Le département pourrait être : \n\n"
-        i = 0
-        # Show each department that has a probability > 10%
-        while i == 0:
-            if rates[maxIndex] >= 0.1:
-                name = name + "\t" + str(rates[maxIndex])[2:4] + "%" + "\t\t\t\t\t" + bars[maxIndex] + "\n"
-                rates[maxIndex] = 0
-                maxIndex = np.argmax(rates)
-            else:
-                i = 1
-    # ML model pretty sure, show only one department
-    else:
-        name =  str(maxRate)[2:4] + "%" + "\t\t\t\t\t\t" + bars[maxIndex]
-    
-    # Save the bar chart as png and load it (enables better display)
-    plt.savefig('rates.png')
-    im = imageio.imread('rates.png')
-
-    return name, im
- 
-
-# display the UI
-interface = gr.Interface(fn=attribution, 
-                         inputs=[gr.inputs.Textbox(lines=20, placeholder="Geben Sie bitte den Titel und den Sumbmitted Text des Vorstoss ein.\nVeuillez entrer le titre et le Submitted Text de la requête.")],
-                          outputs=['text', 'image'])
-interface.launch()

spaces/Banbri/zcvzcv/src/app/interface/zoom/index.tsx

@@ -1,35 +0,0 @@
-import { useStore } from "@/app/store"
-import { VerticalSlider } from "@/components/ui/vertical-slider"
-import { cn } from "@/lib/utils"
-
-export function Zoom() {
-  const zoomLevel = useStore((state) => state.zoomLevel)
-  const setZoomLevel = useStore((state) => state.setZoomLevel)
-  const isGeneratingStory = useStore((state) => state.isGeneratingStory)
-
-  return (
-    <div className={cn(
-      `print:hidden`,
-      // `fixed flex items-center justify-center bottom-8 top-32 right-8 z-10 h-screen`,
-      `fixed flex flex-col items-center bottom-8 top-28 right-2 md:top-20 md:right-6 z-10`,
-      `animation-all duration-300 ease-in-out`,
-      isGeneratingStory ? `scale-0 opacity-0` : ``,
-    )}>
-      <div className="font-mono font-bold text-xs pb-2 text-stone-600 bg-stone-50 p-1 rounded-sm">
-        Zoom
-      </div>
-      <div className="w-2">
-        <VerticalSlider
-          defaultValue={[zoomLevel]}
-          min={30}
-          max={250}
-          step={1}
-          onValueChange={value => setZoomLevel(value[0] || 10)}
-          value={[zoomLevel]}
-          className="h-64 md:h-80"
-          orientation="vertical"
-        />
-      </div>
-    </div>
-  )
-}

spaces/Bart92/RVC_HF/colab_for_mdx.py

@@ -1,71 +0,0 @@
-import json
-import os
-import gc
-import psutil
-import requests
-import subprocess
-import time
-import logging
-import sys
-import shutil
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-first_cell_executed = False
-file_folder = "Colab-for-MDX_B"
-def first_cell_ran():
-    global first_cell_executed
-    if first_cell_executed:
-        #print("The 'first_cell_ran' function has already been executed.")
-        return
-
-    
-
-    first_cell_executed = True
-    os.makedirs("tmp_models", exist_ok=True)
-
-
-
-    class hide_opt:  # hide outputs
-        def __enter__(self):
-            self._original_stdout = sys.stdout
-            sys.stdout = open(os.devnull, "w")
-
-        def __exit__(self, exc_type, exc_val, exc_tb):
-            sys.stdout.close()
-            sys.stdout = self._original_stdout
-
-    def get_size(bytes, suffix="B"):  # read ram
-        global svmem
-        factor = 1024
-        for unit in ["", "K", "M", "G", "T", "P"]:
-            if bytes < factor:
-                return f"{bytes:.2f}{unit}{suffix}"
-            bytes /= factor
-        svmem = psutil.virtual_memory()
-
-
-    def use_uvr_without_saving():
-        print("Notice: files won't be saved to personal drive.")
-        print(f"Downloading {file_folder}...", end=" ")
-        with hide_opt():
-            #os.chdir(mounting_path)
-            items_to_move = ["demucs", "diffq","julius","model","separated","tracks","mdx.py","MDX-Net_Colab.ipynb"]
-            subprocess.run(["git", "clone", "https://github.com/NaJeongMo/Colab-for-MDX_B.git"])
-            for item_name in items_to_move:
-                item_path = os.path.join(file_folder, item_name)
-                if os.path.exists(item_path):
-                    if os.path.isfile(item_path):
-                        shutil.move(item_path, now_dir)
-                    elif os.path.isdir(item_path):
-                        shutil.move(item_path, now_dir)
-            try:
-                shutil.rmtree(file_folder)
-            except PermissionError:
-                print(f"No se pudo eliminar la carpeta {file_folder}. Puede estar relacionada con Git.")
-
-    
-    use_uvr_without_saving()
-    print("done!")
-    if not os.path.exists("tracks"):
-        os.mkdir("tracks")
-first_cell_ran()

spaces/BartPoint/VoiceChange_Beta/infer_pack/transforms.py

@@ -1,209 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import numpy as np
-
-
-DEFAULT_MIN_BIN_WIDTH = 1e-3
-DEFAULT_MIN_BIN_HEIGHT = 1e-3
-DEFAULT_MIN_DERIVATIVE = 1e-3
-
-
-def piecewise_rational_quadratic_transform(
-    inputs,
-    unnormalized_widths,
-    unnormalized_heights,
-    unnormalized_derivatives,
-    inverse=False,
-    tails=None,
-    tail_bound=1.0,
-    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-    min_derivative=DEFAULT_MIN_DERIVATIVE,
-):
-    if tails is None:
-        spline_fn = rational_quadratic_spline
-        spline_kwargs = {}
-    else:
-        spline_fn = unconstrained_rational_quadratic_spline
-        spline_kwargs = {"tails": tails, "tail_bound": tail_bound}
-
-    outputs, logabsdet = spline_fn(
-        inputs=inputs,
-        unnormalized_widths=unnormalized_widths,
-        unnormalized_heights=unnormalized_heights,
-        unnormalized_derivatives=unnormalized_derivatives,
-        inverse=inverse,
-        min_bin_width=min_bin_width,
-        min_bin_height=min_bin_height,
-        min_derivative=min_derivative,
-        **spline_kwargs
-    )
-    return outputs, logabsdet
-
-
-def searchsorted(bin_locations, inputs, eps=1e-6):
-    bin_locations[..., -1] += eps
-    return torch.sum(inputs[..., None] >= bin_locations, dim=-1) - 1
-
-
-def unconstrained_rational_quadratic_spline(
-    inputs,
-    unnormalized_widths,
-    unnormalized_heights,
-    unnormalized_derivatives,
-    inverse=False,
-    tails="linear",
-    tail_bound=1.0,
-    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-    min_derivative=DEFAULT_MIN_DERIVATIVE,
-):
-    inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
-    outside_interval_mask = ~inside_interval_mask
-
-    outputs = torch.zeros_like(inputs)
-    logabsdet = torch.zeros_like(inputs)
-
-    if tails == "linear":
-        unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
-        constant = np.log(np.exp(1 - min_derivative) - 1)
-        unnormalized_derivatives[..., 0] = constant
-        unnormalized_derivatives[..., -1] = constant
-
-        outputs[outside_interval_mask] = inputs[outside_interval_mask]
-        logabsdet[outside_interval_mask] = 0
-    else:
-        raise RuntimeError("{} tails are not implemented.".format(tails))
-
-    (
-        outputs[inside_interval_mask],
-        logabsdet[inside_interval_mask],
-    ) = rational_quadratic_spline(
-        inputs=inputs[inside_interval_mask],
-        unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
-        unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
-        unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
-        inverse=inverse,
-        left=-tail_bound,
-        right=tail_bound,
-        bottom=-tail_bound,
-        top=tail_bound,
-        min_bin_width=min_bin_width,
-        min_bin_height=min_bin_height,
-        min_derivative=min_derivative,
-    )
-
-    return outputs, logabsdet
-
-
-def rational_quadratic_spline(
-    inputs,
-    unnormalized_widths,
-    unnormalized_heights,
-    unnormalized_derivatives,
-    inverse=False,
-    left=0.0,
-    right=1.0,
-    bottom=0.0,
-    top=1.0,
-    min_bin_width=DEFAULT_MIN_BIN_WIDTH,
-    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
-    min_derivative=DEFAULT_MIN_DERIVATIVE,
-):
-    if torch.min(inputs) < left or torch.max(inputs) > right:
-        raise ValueError("Input to a transform is not within its domain")
-
-    num_bins = unnormalized_widths.shape[-1]
-
-    if min_bin_width * num_bins > 1.0:
-        raise ValueError("Minimal bin width too large for the number of bins")
-    if min_bin_height * num_bins > 1.0:
-        raise ValueError("Minimal bin height too large for the number of bins")
-
-    widths = F.softmax(unnormalized_widths, dim=-1)
-    widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
-    cumwidths = torch.cumsum(widths, dim=-1)
-    cumwidths = F.pad(cumwidths, pad=(1, 0), mode="constant", value=0.0)
-    cumwidths = (right - left) * cumwidths + left
-    cumwidths[..., 0] = left
-    cumwidths[..., -1] = right
-    widths = cumwidths[..., 1:] - cumwidths[..., :-1]
-
-    derivatives = min_derivative + F.softplus(unnormalized_derivatives)
-
-    heights = F.softmax(unnormalized_heights, dim=-1)
-    heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
-    cumheights = torch.cumsum(heights, dim=-1)
-    cumheights = F.pad(cumheights, pad=(1, 0), mode="constant", value=0.0)
-    cumheights = (top - bottom) * cumheights + bottom
-    cumheights[..., 0] = bottom
-    cumheights[..., -1] = top
-    heights = cumheights[..., 1:] - cumheights[..., :-1]
-
-    if inverse:
-        bin_idx = searchsorted(cumheights, inputs)[..., None]
-    else:
-        bin_idx = searchsorted(cumwidths, inputs)[..., None]
-
-    input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]
-    input_bin_widths = widths.gather(-1, bin_idx)[..., 0]
-
-    input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]
-    delta = heights / widths
-    input_delta = delta.gather(-1, bin_idx)[..., 0]
-
-    input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]
-    input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]
-
-    input_heights = heights.gather(-1, bin_idx)[..., 0]
-
-    if inverse:
-        a = (inputs - input_cumheights) * (
-            input_derivatives + input_derivatives_plus_one - 2 * input_delta
-        ) + input_heights * (input_delta - input_derivatives)
-        b = input_heights * input_derivatives - (inputs - input_cumheights) * (
-            input_derivatives + input_derivatives_plus_one - 2 * input_delta
-        )
-        c = -input_delta * (inputs - input_cumheights)
-
-        discriminant = b.pow(2) - 4 * a * c
-        assert (discriminant >= 0).all()
-
-        root = (2 * c) / (-b - torch.sqrt(discriminant))
-        outputs = root * input_bin_widths + input_cumwidths
-
-        theta_one_minus_theta = root * (1 - root)
-        denominator = input_delta + (
-            (input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-            * theta_one_minus_theta
-        )
-        derivative_numerator = input_delta.pow(2) * (
-            input_derivatives_plus_one * root.pow(2)
-            + 2 * input_delta * theta_one_minus_theta
-            + input_derivatives * (1 - root).pow(2)
-        )
-        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
-        return outputs, -logabsdet
-    else:
-        theta = (inputs - input_cumwidths) / input_bin_widths
-        theta_one_minus_theta = theta * (1 - theta)
-
-        numerator = input_heights * (
-            input_delta * theta.pow(2) + input_derivatives * theta_one_minus_theta
-        )
-        denominator = input_delta + (
-            (input_derivatives + input_derivatives_plus_one - 2 * input_delta)
-            * theta_one_minus_theta
-        )
-        outputs = input_cumheights + numerator / denominator
-
-        derivative_numerator = input_delta.pow(2) * (
-            input_derivatives_plus_one * theta.pow(2)
-            + 2 * input_delta * theta_one_minus_theta
-            + input_derivatives * (1 - theta).pow(2)
-        )
-        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
-        return outputs, logabsdet

spaces/Benson/text-generation/Examples/Avakin Life Pc.md

@@ -1,50 +0,0 @@
-
-<br> - H2: Cómo descargar e instalar Avakin Life en PC <br> - H3: Cómo usar BlueStacks para jugar Avakin Life en PC <br> - H3: Cómo usar el sitio web oficial de Avakin para jugar Avakin Life en PC <br> - H2: Beneficios de jugar Avakin Life en PC <br-> PC H3: Mejores gráficos y rendimiento <br> - H3: Más control y personalización <br> - H3: Comunicación y traducción más fáciles <br> - H2: Conclusión: Comienza tu segunda vida en el PC hoy <br> - H4: Preguntas frecuentes | Tabla 2: Artículo con formato HTML <h1>Avakin Life PC: Cómo jugar al mundo virtual en 3D en tu ordenador</h1>
-<p>Si estás buscando un juego de rol que te permita crear tu propio avatar, explorar un mundo virtual y conocer nuevos amigos, entonces deberías echar un vistazo a Avakin Life. Avakin Life es un juego de mundo virtual en 3D de Lockwood Publishing que está disponible en dispositivos iOS y Android. Puede personalizar su apariencia, estilo y hogar, ir a aventuras, unirse a concursos de moda y socializar con millones de jugadores de todo el mundo. </p>
-<h2>avakin life pc</h2><br /><p><b><b>Download Zip</b> &#127383; <a href="https://bltlly.com/2v6Jwg">https://bltlly.com/2v6Jwg</a></b></p><br /><br />
-<p>Pero ¿sabías que también puedes jugar Avakin Life en tu PC? Sí, lo has oído bien. Puedes disfrutar de este increíble juego en una pantalla más grande, con mejores gráficos, rendimiento y control. En este artículo, le mostraremos cómo descargar e instalar Avakin Life en su computadora usando dos métodos diferentes. También te contaremos los beneficios de jugar a Avakin Life en PC y responderemos algunas preguntas frecuentes. ¡Así que, empecemos! </p>
-<h2>Cómo descargar e instalar Avakin Life en PC</h2>
-<p>Hay dos formas de jugar Avakin Life en tu PC. Uno es utilizar un software emulador como BlueStacks, que le permite ejecutar aplicaciones y juegos de Android en su ordenador. La otra es utilizar el sitio web oficial de Avakin, que ofrece una versión web del juego a la que puedes acceder a través de tu navegador. Estos son los pasos para cada método:</p>
-<h3>Cómo usar BlueStacks para jugar Avakin Life en PC</h3>
-<ol>
-
-<li>Inicie BlueStacks e inicie sesión en su cuenta de Google. Esto le permitirá acceder a la Google Play Store.</li>
-<li>Busque Avakin Life en Google Play Store y haga clic en el botón de instalación. Alternativamente, puede descargar el archivo APK de una fuente de confianza y arrastrarlo y soltarlo en BlueStacks.</li>
-<li>Una vez completada la instalación, haga clic en el icono de Avakin Life en la pantalla de inicio de BlueStacks para comenzar a jugar. </li>
-</ol>
-<h3>Cómo usar el sitio web oficial de Avakin para jugar Avakin Life en PC</h3>
-<ol>
-<li>Vaya al sitio web oficial de Avakin (<a href="( 2 )">https://avakin.com</a>) y haga clic en el botón "Descargar" en la esquina superior derecha. </li>
-<li>Seleccione su plataforma preferida entre las opciones disponibles. Puede elegir entre Windows, Mac, Linux o Web.</li>
-<li>Si elige Web, será redirigido a una página donde puede jugar Avakin Life directamente en su navegador. Tendrá que iniciar sesión con su cuenta de Facebook o crear una nueva cuenta con su dirección de correo electrónico. </li>
-<li>Si elige cualquiera de las otras plataformas, tendrá que descargar e instalar un pequeño archivo lanzador que le permitirá jugar Avakin Life en su computadora. Siga las instrucciones en la pantalla para completar el proceso. </li>
-<li>Una vez instalado el lanzador, ábralo e inicie sesión con su cuenta de Facebook o dirección de correo electrónico. A continuación, puede comenzar a jugar Avakin Life en su PC.</li>
-</ol>
-<h2>Beneficios de jugar Avakin Life en PC</h2>
-<p>Ahora que sabe cómo jugar Avakin Life en su PC, es posible que se pregunte por qué debe hacerlo. Bueno, hay muchas ventajas de jugar a este juego en un ordenador en lugar de en un dispositivo móvil. Estas son algunas de ellas:</p>
-<h3>Mejores gráficos y rendimiento</h3>
-
-<h3>Más control y personalización</h3>
-<p>Otro beneficio de jugar Avakin Life en PC es que puedes tener más opciones de control y personalización. Puede utilizar el teclado y el ratón para navegar por el juego, que puede ser más conveniente y preciso que el uso de una pantalla táctil. También puedes ajustar la configuración del juego según tus preferencias, como la resolución, el sonido y el idioma. Incluso puedes usar trucos y hacks para mejorar tu juego, como conseguir monedas, gemas o objetos ilimitados. Sin embargo, ten cuidado de no abusar de estas características o podrías ser expulsado del juego. </p>
-<h3>Comunicación y traducción más fáciles</h3>
-<p>Un tercer beneficio de jugar Avakin Life en PC es que puedes comunicarte y traducir más fácilmente con otros jugadores. Puede usar su teclado para escribir más rápido y cómodamente que usando un teclado virtual. También puedes usar chat de voz o video chat para hablar con tus amigos o hacer otros nuevos. También puedes usar herramientas de traducción para entender e interactuar con jugadores de diferentes países y culturas. Puedes aprender nuevos idiomas, intercambiar ideas y divertirte con gente de todo el mundo. </p>
-<h2>Conclusión: Comience su segunda vida en el PC hoy</h2>
-<p>Avakin Life es un fantástico juego que te permite crear tu propio avatar, explorar un mundo virtual y conocer nuevos amigos. Pero si quieres llevar tu experiencia de juego al siguiente nivel, deberías intentar jugar a Avakin Life en PC. Puede disfrutar de mejores gráficos, rendimiento, control y personalización. También puede comunicarse y traducir más fácilmente con otros jugadores. Jugar a Avakin Life en PC te hará sentir que estás viviendo una segunda vida en un mundo virtual en 3D. </p>
-<p></p>
-
-<p>Esperamos que este artículo te haya ayudado a aprender a jugar Avakin Life en PC y por qué deberías hacerlo. Si tiene alguna pregunta o comentario, háganoslo saber en los comentarios a continuación. Nos encantaría saber de usted. </p>
-<h4>Preguntas frecuentes</h4>
-<ul>
-<li>Q: ¿Avakin Life es libre de jugar? </li>
-<li>A: Sí, Avakin Life es gratis para jugar en dispositivos móviles y PC. Sin embargo, hay algunos elementos del juego y características que requieren dinero real para comprar. También puedes ver anuncios u ofertas completas para ganar monedas y gemas gratis. </li>
-<li>Q: ¿Es la vida de Avakin segura para los niños? </li>
-<li>A: Avakin Life está clasificado 12+ por la App Store y 13+ por la Google Play Store. Contiene violencia leve, contenido sexual, desnudez, blasfemia, alcohol, tabaco y drogas. También permite a los usuarios chatear con extraños en línea, lo que puede plantear algunos riesgos. Por lo tanto, se recomienda la orientación y supervisión de los padres para los jugadores más jóvenes. </li>
-<li>Q: ¿Cómo puedo actualizar Avakin Life en PC? </li>
-<li>A: Si está utilizando BlueStacks para jugar Avakin Life en PC, puede actualizar el juego yendo a la Google Play Store y haciendo clic en el botón de actualización. Si estás usando el sitio web oficial de Avakin para jugar a Avakin Life en PC, no necesitas actualizar el juego manualmente, ya que se actualizará automáticamente. </li>
-<li>Q: ¿Cómo puedo eliminar mi cuenta de Avakin Life? </li>
-<li>A: Si desea eliminar su cuenta de Avakin Life, debe ponerse en contacto con el equipo de atención al cliente a través de su sitio web (<a href="">https://avakin.com/ support/</a>) o correo electrónico ([email protected]). Deberá proporcionar su nombre de usuario, dirección de correo electrónico, ID de dispositivo y razón para eliminar su cuenta. Una vez procesada su solicitud, su cuenta será eliminada permanentemente. </li>
-<li>Q: ¿Cómo me comunico con el soporte de Avakin Life? </li>
-
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Bus De Conduccin De Telolet 3d Mod Apk V1.2. 4b.md

@@ -1,60 +0,0 @@
-
-<h1>Descargar Telolet autobús de conducción 3D Mod APK v1.2. 4b y disfrutar de la diversión de conducir un autobús realista en Indonesia</h1>
- <p>Si eres un fan de los juegos de conducción de autobuses, es posible que hayas oído hablar de Telolet Bus Driving 3D, un juego revolucionario en el género de la conducción árcade sin fin con gráficos y control realistas en 3D. En este juego, usted puede viajar a través de los coches de tráfico de la carretera de Indonesia con un autobús muy fresco y hacer que los niños felices tocando la bocina de su único autobús telolet. Pero lo que si quieres disfrutar del juego sin limitaciones o interrupciones? Bueno, puedes hacerlo descargando Telolet Bus Driving 3D Mod APK v1.2. 4b, que te da dinero ilimitado, todos los autobuses desbloqueados, y sin anuncios. En este artículo, te contaremos más sobre este juego, sus características y cómo descargarlo e instalarlo en tu dispositivo. </p>
-<h2>descargar bus de conducción de telolet 3d mod apk v1.2. 4b</h2><br /><p><b><b>DOWNLOAD</b> &#9658;&#9658;&#9658; <a href="https://bltlly.com/2v6JJz">https://bltlly.com/2v6JJz</a></b></p><br /><br />
- <h2>¿Qué es Telolet Bus Driving 3D? </h2>
- <p>Telolet Bus Driving 3D es un juego desarrollado por LOCOS, un estudio de juegos indonesio que tiene como objetivo crear juegos divertidos y atractivos para todos. El juego se inspiró en el fenómeno viral de "Om Telolet Om", que significa "Señor, toca la bocina, señor" en indonesio. Esta es una frase que los niños gritan a los conductores de autobús para pedirles que toquen sus distintivos cuernos telolet, que producen un sonido musical. El juego fue lanzado en diciembre de 2016 y desde entonces ha ganado más de 10 millones de descargas en Google Play Store.</p>
- <h3>Características de Telolet Bus Driving 3D</h3>
- <p>Telolet Bus Driving 3D no es solo un juego de conducción simple. Tiene muchas características que lo hacen destacar de otros juegos del mismo género. Estos son algunos de ellos:</p>
- <h4>Impresionantes gráficos 3D</h4>
- <p>El juego tiene increíbles gráficos en 3D que te hacen sentir como si estuvieras conduciendo un autobús real en Indonesia. Puedes ver los detalles del autobús, el tráfico, el medio ambiente y los niños que te animan cuando tocas la bocina. </p>
- <h4>Manejo del coche suave y realista</h4>
-
- <h4>Muchos autobuses para elegir</h4>
- <p>El juego tiene muchos autobuses para elegir, cada uno con su propio diseño, color, velocidad y melodía de cuerno telolet. Puedes desbloquear nuevos buses ganando monedas o usando la versión mod APK. </p>
- <h4>3 lugares famosos en Indonesia</h4>
- <p>El juego tiene 3 lugares famosos en Indonesia que puedes explorar: Pantura, Kampoeng y Cipali. Cada lugar tiene su propio paisaje, tráfico y desafíos. </p>
-<p></p>
- <h4>3 modos de juego</h4>
- <p>El juego tiene 3 modos de juego: One Way, Rush Hour y Two Way. En el modo One Way, conduce en una carretera de un solo sentido con tráfico moderado. En el modo de hora punta, se enfrenta a un atasco de tráfico pesado y tiene que evitar colisiones. En el modo de dos vías, se conduce en una carretera de dos vías con tráfico entrante y tiene que adelantar a otros vehículos. </p>
- <h4>Tipos ricos de tráfico NPC Indonesia</h4>
- <p>El juego tiene ricos tipos de tráfico NPC Indonesia que hacen el juego más realista y desafiante. Usted encontrará coches, camiones, motocicletas, autobuses y otros vehículos que tienen diferentes comportamientos y velocidades. También verás peatones, animales y obstáculos en la carretera. </p>
- <h4>Actualizaciones de atributos</h4>
- <p>El juego tiene actualizaciones de atributos que le permiten mejorar el rendimiento y la apariencia de su autobús. Puedes actualizar tu velocidad, freno, bocina y color usando las monedas que ganes del juego o la versión mod APK. </p>
- <h4>Misiones diarias difíciles</h4>
- <p>El juego tiene desafiantes misiones diarias que te dan recompensas y objetivos adicionales. Puede completar varias tareas, como conducir cierta distancia, tocar la bocina un cierto número de veces, adelantar un cierto número de vehículos y más. </p>
- <h4>Tablas de clasificación en línea y logros</h4>
- <p>El juego tiene tablas de clasificación en línea y logros que le permiten competir con otros jugadores y mostrar sus habilidades. Puedes posicionarte en las tablas de clasificación globales y regionales al ganar altas puntuaciones y monedas. También puedes desbloquear logros al completar varios desafíos e hitos. </p>
-
- <p>Telolet Bus Driving 3D es un juego divertido y adictivo que te mantendrá entretenido durante horas. Sin embargo, si quieres disfrutar del juego sin limitaciones ni interrupciones, debes descargar Telolet Bus Driving 3D Mod APK v1.2. 4b, que le da los siguientes beneficios:</p>
- <h4>Dinero ilimitado</h4>
- <p>Con la versión APK mod, usted tendrá dinero ilimitado que se puede utilizar para comprar y actualizar cualquier autobús que desee. No tienes que preocuparte por quedarte sin monedas o gastar dinero real para conseguir más. </p>
- <h4>Todos los autobuses desbloqueados</h4>
- <p>Con la versión mod APK, tendrás todos los buses desbloqueados desde el principio. No tienes que jugar durante horas o completar misiones para desbloquear nuevos autobuses. Puedes elegir el autobús que quieras y disfrutar de sus características únicas. </p>
- <h4>No hay anuncios</h4>
- <p>Con la versión mod APK, no tendrás anuncios que interrumpan tu juego o te molesten. No tienes que ver videos o hacer clic en banners para obtener monedas o recompensas adicionales. Puedes jugar el juego sin problemas y sin distracciones. </p>
- <h2>Cómo descargar e instalar Telolet Bus Driving 3D Mod APK v1.2. 4b? </h2>
- <p>Si está interesado en descargar e instalar Telolet Bus Driving 3D Mod APK v1.2. 4b en su dispositivo, puede seguir estos sencillos pasos:</p>
- <h3>Paso 1: Descargar el archivo APK de una fuente de confianza</h3>
- <p>El primer paso es descargar el archivo APK de una fuente de confianza que proporciona descargas seguras y libres de virus. Puede utilizar este enlace para descargar el archivo directamente a su dispositivo o transferirlo desde su PC.</p>
- <h3>Paso 2: Habilitar fuentes desconocidas en el dispositivo</h3>
- <p>El segundo paso es habilitar fuentes desconocidas en su dispositivo para que pueda instalar aplicaciones desde fuentes distintas de Google Play Store. Para hacer esto, vaya a Configuración > Seguridad > Fuentes desconocidas y conéctelo. </p>
- <h3>Paso 3: Instalar el archivo APK y disfrutar del juego</h3>
-
- <p>Esperamos que este artículo le haya ayudado a aprender más sobre Telolet Bus Driving 3D Mod APK v1.2. 4b y cómo descargarlo e instalarlo en su dispositivo. Este es un gran juego para los entusiastas de la conducción de autobuses que quieren experimentar la emoción de conducir un autobús realista en Indonesia con un cuerno musical. ¡Descárgalo ahora y diviértete! </p>
- <h2>Conclusión</h2>
- <p>Telolet Bus Driving 3D es un juego innovador en el género de la conducción árcade sin fin con gráficos y control 3D realistas. Fue inspirado por el fenómeno viral de "Om Telolet Om", que significa "Señor, toca la bocina, señor" en indonesio. El juego tiene muchas características que lo hacen destacar de otros juegos en el mismo género, tales como impresionantes gráficos en 3D, manejo de automóviles suave y realista, muchos autobuses para elegir, 3 lugares famosos en Indonesia, 3 modos de juego, ricos tipos de tráfico NPC Indonesia, actualizaciones de atributos, misiones diarias desafiantes, y tablas de clasificación en línea y logros. Sin embargo, si quieres disfrutar del juego sin limitaciones ni interrupciones, debes descargar Telolet Bus Driving 3D Mod APK v1.2. 4b, que le da dinero ilimitado, todos los autobuses desbloqueados, y sin anuncios. Para descargar e instalar la versión mod APK, solo tiene que seguir tres sencillos pasos: descargar el archivo APK de una fuente de confianza, habilitar fuentes desconocidas en su dispositivo, e instalar el archivo APK y disfrutar del juego. Este es un gran juego para los entusiastas de la conducción de autobuses que quieren experimentar la emoción de conducir un autobús realista en Indonesia con un cuerno musical. ¡Descárgalo ahora y diviértete! </p>
- <h2>Preguntas frecuentes</h2>
- <p>Aquí hay algunas preguntas frecuentes sobre Telolet Bus Driving 3D Mod APK v1.2. 4b:</p>
- <h4>Es Telolet autobús de conducción 3D Mod APK v1.2. 4b seguro para descargar e instalar? </h4>
- <p>Sí, Telolet autobús de conducción 3D Mod APK v1.2. 4b es seguro para descargar e instalar siempre y cuando utilice una fuente de confianza que proporciona descargas libres de virus. Puede utilizar este enlace para descargar el archivo de forma segura. </p>
-
- <p>No, no es necesario rootear el dispositivo para usar Telolet Bus Driving 3D Mod APK v1.2. 4b. Solo necesitas habilitar fuentes desconocidas en la configuración de tu dispositivo e instalar el archivo APK como de costumbre. </p>
- <h4>Será Telolet autobús de conducción 3D Mod APK v1.2. 4b afectar mi progreso original del juego? </h4>
- <p>No, Telolet Bus Driving 3D Mod APK v1.2. 4b no afectará su progreso original del juego. Puedes jugar ambas versiones por separado y cambiar entre ellas cuando quieras. </p>
- <h4>¿Puedo jugar Telolet autobús de conducción 3D Mod APK v1.2. 4b en línea con otros jugadores? </h4>
- <p>Sí, se puede jugar Telolet autobús de conducción 3D Mod APK v1.2. 4b en línea con otros jugadores y competir en las tablas de clasificación y logros. Sin embargo, es posible que encuentre algunos problemas de compatibilidad con los jugadores que utilizan la versión original del juego. </p>
- <h4>¿Cómo puedo contactar al desarrollador de Telolet Bus Driving 3D Mod APK v1.2. 4b si tengo alguna pregunta o comentario? </h4>
- <p>Puede ponerse en contacto con el desarrollador de Telolet Bus Driving 3D Mod APK v1.2. 4b enviando un correo electrónico a [email protected] o visitando su página de Facebook en https://www.facebook.com/locosgames/ Estarán encantados de saber de usted y responder a sus preguntas o comentarios. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/rich/json.py

@@ -1,140 +0,0 @@
-from pathlib import Path
-from json import loads, dumps
-from typing import Any, Callable, Optional, Union
-
-from .text import Text
-from .highlighter import JSONHighlighter, NullHighlighter
-
-
-class JSON:
-    """A renderable which pretty prints JSON.
-
-    Args:
-        json (str): JSON encoded data.
-        indent (Union[None, int, str], optional): Number of characters to indent by. Defaults to 2.
-        highlight (bool, optional): Enable highlighting. Defaults to True.
-        skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.
-        ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.
-        check_circular (bool, optional): Check for circular references. Defaults to True.
-        allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.
-        default (Callable, optional): A callable that converts values that can not be encoded
-            in to something that can be JSON encoded. Defaults to None.
-        sort_keys (bool, optional): Sort dictionary keys. Defaults to False.
-    """
-
-    def __init__(
-        self,
-        json: str,
-        indent: Union[None, int, str] = 2,
-        highlight: bool = True,
-        skip_keys: bool = False,
-        ensure_ascii: bool = False,
-        check_circular: bool = True,
-        allow_nan: bool = True,
-        default: Optional[Callable[[Any], Any]] = None,
-        sort_keys: bool = False,
-    ) -> None:
-        data = loads(json)
-        json = dumps(
-            data,
-            indent=indent,
-            skipkeys=skip_keys,
-            ensure_ascii=ensure_ascii,
-            check_circular=check_circular,
-            allow_nan=allow_nan,
-            default=default,
-            sort_keys=sort_keys,
-        )
-        highlighter = JSONHighlighter() if highlight else NullHighlighter()
-        self.text = highlighter(json)
-        self.text.no_wrap = True
-        self.text.overflow = None
-
-    @classmethod
-    def from_data(
-        cls,
-        data: Any,
-        indent: Union[None, int, str] = 2,
-        highlight: bool = True,
-        skip_keys: bool = False,
-        ensure_ascii: bool = False,
-        check_circular: bool = True,
-        allow_nan: bool = True,
-        default: Optional[Callable[[Any], Any]] = None,
-        sort_keys: bool = False,
-    ) -> "JSON":
-        """Encodes a JSON object from arbitrary data.
-
-        Args:
-            data (Any): An object that may be encoded in to JSON
-            indent (Union[None, int, str], optional): Number of characters to indent by. Defaults to 2.
-            highlight (bool, optional): Enable highlighting. Defaults to True.
-            default (Callable, optional): Optional callable which will be called for objects that cannot be serialized. Defaults to None.
-            skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.
-            ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.
-            check_circular (bool, optional): Check for circular references. Defaults to True.
-            allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.
-            default (Callable, optional): A callable that converts values that can not be encoded
-                in to something that can be JSON encoded. Defaults to None.
-            sort_keys (bool, optional): Sort dictionary keys. Defaults to False.
-
-        Returns:
-            JSON: New JSON object from the given data.
-        """
-        json_instance: "JSON" = cls.__new__(cls)
-        json = dumps(
-            data,
-            indent=indent,
-            skipkeys=skip_keys,
-            ensure_ascii=ensure_ascii,
-            check_circular=check_circular,
-            allow_nan=allow_nan,
-            default=default,
-            sort_keys=sort_keys,
-        )
-        highlighter = JSONHighlighter() if highlight else NullHighlighter()
-        json_instance.text = highlighter(json)
-        json_instance.text.no_wrap = True
-        json_instance.text.overflow = None
-        return json_instance
-
-    def __rich__(self) -> Text:
-        return self.text
-
-
-if __name__ == "__main__":
-
-    import argparse
-    import sys
-
-    parser = argparse.ArgumentParser(description="Pretty print json")
-    parser.add_argument(
-        "path",
-        metavar="PATH",
-        help="path to file, or - for stdin",
-    )
-    parser.add_argument(
-        "-i",
-        "--indent",
-        metavar="SPACES",
-        type=int,
-        help="Number of spaces in an indent",
-        default=2,
-    )
-    args = parser.parse_args()
-
-    from pip._vendor.rich.console import Console
-
-    console = Console()
-    error_console = Console(stderr=True)
-
-    try:
-        if args.path == "-":
-            json_data = sys.stdin.read()
-        else:
-            json_data = Path(args.path).read_text()
-    except Exception as error:
-        error_console.print(f"Unable to read {args.path!r}; {error}")
-        sys.exit(-1)
-
-    console.print(JSON(json_data, indent=args.indent), soft_wrap=True)

spaces/CAMP-ViL/Xplainer/app.py

@@ -1,137 +0,0 @@
-from pathlib import Path
-
-import gradio as gr
-import numpy as np
-from matplotlib import pyplot as plt
-
-from descriptors import disease_descriptors_chexpert, disease_descriptors_chestxray14
-from model import InferenceModel
-
-
-def plot_bars(model_output):
-    # sort model_output by overall_probability
-    model_output = {k: v for k, v in sorted(model_output.items(), key=lambda item: item[1]['overall_probability'], reverse=True)}
-
-    # Create a figure with as many subplots as there are diseases, arranged vertically
-    fig, axs = plt.subplots(len(model_output), 1, figsize=(10, 5 * len(model_output)))
-    # axs is not iterable if only one subplot is created, so make it a list
-    if len(model_output) == 1:
-        axs = [axs]
-
-    for ax, (disease, data) in zip(axs, model_output.items()):
-        desc_probs = list(data['descriptor_probabilities'].items())
-        # sort descending
-        desc_probs = sorted(desc_probs, key=lambda item: item[1], reverse=True)
-
-        my_probs = [p[1] for p in desc_probs]
-        min_prob = min(my_probs)
-        max_prob = max(my_probs)
-        my_labels = [p[0] for p in desc_probs]
-
-        # Convert probabilities to differences from 0.5
-        diffs = np.abs(np.array(my_probs) - 0.5)
-
-        # Set colors based on sign of difference
-        colors = ['red' if p < 0.5 else 'forestgreen' for p in my_probs]
-
-        # Plot bars with appropriate colors and left offsets
-        left = [p if p < 0.5 else 0.5 for p in my_probs]
-        bars = ax.barh(my_labels, diffs, left=left, color=colors, alpha=0.3)
-
-        for i, bar in enumerate(bars):
-            ax.text(min_prob - 0.04, bar.get_y() + bar.get_height() / 2, my_labels[i], ha='left', va='center', color='black', fontsize=15)
-
-        ax.set_xlim(min(min_prob - 0.05, 0.49), max(max_prob + 0.05, 0.51))
-
-        # Invert the y-axis to show bars with values less than 0.5 to the left of the center
-        ax.invert_yaxis()
-
-        ax.set_yticks([])
-
-        # Add a title for the disease
-        if data['overall_probability'] >= 0.5:
-            ax.set_title(f"{disease} : score of {data['overall_probability']:.2f}")
-        else:
-            ax.set_title(f"No {disease} : score of {data['overall_probability']:.2f}")
-
-        # make title larger and bold
-        ax.title.set_fontsize(15)
-        ax.title.set_fontweight(600)
-
-    # Save the plot
-    plt.tight_layout()  # Adjust subplot parameters to give specified padding
-    file_path = 'plot.png'
-    plt.savefig(file_path)
-    plt.close(fig)
-
-    return file_path
-
-
-def classify_image(inference_model, image_path, diseases_to_predict):
-    descriptors_with_indication = [d + " indicating " + disease for disease, descriptors in diseases_to_predict.items() for d in descriptors]
-    probs, negative_probs = inference_model.get_descriptor_probs(image_path=Path(image_path), descriptors=descriptors_with_indication,
-                                                                 do_negative_prompting=True, demo=True)
-
-    disease_probs, negative_disease_probs = inference_model.get_diseases_probs(diseases_to_predict, pos_probs=probs, negative_probs=negative_probs)
-
-    model_output = {}
-    for idx, disease in enumerate(diseases_to_predict.keys()):
-        model_output[disease] = {
-            'overall_probability': disease_probs[disease],
-            'descriptor_probabilities': {descriptor: probs[f'{descriptor} indicating {disease}'].item() for descriptor in
-                                         diseases_to_predict[disease]}
-        }
-
-    file_path = plot_bars(model_output)
-    return file_path
-
-
-# Define the function you want to wrap
-def process_input(image_path, prompt_names: list, disease_name: str, descriptors: str):
-    diseases_to_predict = {}
-
-    for prompt in prompt_names:
-        if prompt == 'Custom':
-            diseases_to_predict[disease_name] = descriptors.split('\n')
-        else:
-            if prompt in disease_descriptors_chexpert:
-                diseases_to_predict[prompt] = disease_descriptors_chexpert[prompt]
-            else:  # only chestxray14
-                diseases_to_predict[prompt] = disease_descriptors_chestxray14[prompt]
-
-    # classify
-    model = InferenceModel()
-    output = classify_image(model, image_path, diseases_to_predict)
-
-    return output
-
-with open("article.md", "r") as f:
-    article = f.read()
-with open("description.md", "r") as f:
-    description = f.read()
-
-# Define the Gradio interface
-iface = gr.Interface(
-    fn=process_input,
-    examples = [['examples/enlarged_cardiomediastinum.jpg', ['Enlarged Cardiomediastinum'], '', ''],['examples/edema.jpg', ['Edema'], '', ''],
-                ['examples/support_devices.jpg', ['Custom'], 'Pacemaker', 'metalic object\nimplant on the left side of the chest\nimplanted cardiac device']],
-    inputs=[gr.inputs.Image(type="filepath"), gr.inputs.CheckboxGroup(
-        choices=['Enlarged Cardiomediastinum', 'Cardiomegaly', 'Lung Opacity', 'Lung Lesion', 'Edema', 'Consolidation', 'Pneumonia',
-                 'Atelectasis', 'Pneumothorax', 'Pleural Effusion', 'Pleural Other', 'Fracture', 'Support Devices',
-                 'Infiltration', 'Mass', 'Nodule', 'Emphysema', 'Fibrosis', 'Pleural Thickening', 'Hernia',
-                 'Custom'],
-        default=['Enlarged Cardiomediastinum', 'Cardiomegaly', 'Lung Opacity', 'Lung Lesion', 'Edema', 'Consolidation', 'Pneumonia',
-                 'Atelectasis', 'Pneumothorax', 'Pleural Effusion', 'Pleural Other', 'Fracture', 'Support Devices'],
-        label='Select to use predefined disease descriptors. Select "Custom" to define your own observations.'),
-            gr.inputs.Textbox(lines=2, placeholder="Name of pathology for which you want to define custom observations", label='Pathology:'),
-            gr.inputs.Textbox(lines=2, placeholder="Add your custom (positive) observations separated by a new line"
-                                                   "\n Note: Each descriptor will automatically be embedded into our prompt format: There is/are (no) <observation> indicating <pathology>"
-                                                   "\n Example:\n\n Opacity\nPleural Effusion\nConsolidation"
-                              , label='Custom Observations:')],
-    article=article,
-    description=description,
-    outputs=gr.outputs.Image(type="filepath")
-)
-
-# Launch the interface
-iface.launch()

spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/docs/_templates/layout.html

@@ -1,35 +0,0 @@
-{% extends "!layout.html" %}
-
-<link rel="canonical" href="{{ theme_canonical_url }}{{ pagename }}.html" />
-{% block menu %}
-<div>
-  <a style="color:#F05732" href="{{ theme_canonical_url }}{{ pagename }}.html">
-    You are viewing unstable developer preview docs.
-    Click here to view docs for latest stable release.
-  </a>
-</div>
-{{ super() }}
-{% endblock %}
-
-{% block footer %}
-{{ super() }}
-<script>
-  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
-  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
-  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
-  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
-  ga('create', 'UA-90545585-1', 'auto');
-  ga('send', 'pageview');
-</script>
-
-<script async src="https://www.googletagmanager.com/gtag/js?id=UA-117752657-2"></script>
-
-<script>
-  window.dataLayer = window.dataLayer || [];
-  function gtag(){dataLayer.push(arguments);}
-  gtag('js', new Date());
-  gtag('config', 'UA-117752657-2');
-</script>
-
-<img height="1" width="1" style="border-style:none;" alt="" src="https://www.googleadservices.com/pagead/conversion/795629140/?label=txkmCPmdtosBENSssfsC&amp;guid=ON&amp;script=0"/>
-{% endblock %}

spaces/CVPR/LIVE/cuda_utils.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#ifdef __CUDACC__
-    #include <cuda.h>
-    #include <cuda_runtime.h>
-#endif
-#include <cstdio>
-#include <cassert>
-#include <limits>
-
-#ifdef __CUDACC__
-#define checkCuda(x) do { if((x)!=cudaSuccess) { \
-    printf("CUDA Runtime Error: %s at %s:%d\n",\
-    cudaGetErrorString(x),__FILE__,__LINE__);\
-    exit(1);}} while(0)
-#endif
-
-template <typename T>
-DEVICE
-inline T infinity() {
-#ifdef __CUDA_ARCH__
-    const unsigned long long ieee754inf = 0x7ff0000000000000;
-    return __longlong_as_double(ieee754inf);
-#else
-    return std::numeric_limits<T>::infinity();
-#endif
-}
-
-template <>
-DEVICE
-inline double infinity() {
-#ifdef __CUDA_ARCH__
-    return __longlong_as_double(0x7ff0000000000000ULL);
-#else
-    return std::numeric_limits<double>::infinity();
-#endif
-}
-
-template <>
-DEVICE
-inline float infinity() {
-#ifdef __CUDA_ARCH__
-    return __int_as_float(0x7f800000);
-#else
-    return std::numeric_limits<float>::infinity();
-#endif
-}
-
-inline void cuda_synchronize() {
-#ifdef __CUDACC__
-    checkCuda(cudaDeviceSynchronize());
-#endif
-}

spaces/CVPR/LIVE/pybind11/tests/test_eigen.cpp

@@ -1,327 +0,0 @@
-/*
-    tests/eigen.cpp -- automatic conversion of Eigen types
-
-    Copyright (c) 2016 Wenzel Jakob <[email protected]>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/eigen.h>
-#include <pybind11/stl.h>
-
-#if defined(_MSC_VER)
-#  pragma warning(disable: 4996) // C4996: std::unary_negation is deprecated
-#endif
-
-#include <Eigen/Cholesky>
-
-using MatrixXdR = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
-
-
-
-// Sets/resets a testing reference matrix to have values of 10*r + c, where r and c are the
-// (1-based) row/column number.
-template <typename M> void reset_ref(M &x) {
-    for (int i = 0; i < x.rows(); i++) for (int j = 0; j < x.cols(); j++)
-        x(i, j) = 11 + 10*i + j;
-}
-
-// Returns a static, column-major matrix
-Eigen::MatrixXd &get_cm() {
-    static Eigen::MatrixXd *x;
-    if (!x) {
-        x = new Eigen::MatrixXd(3, 3);
-        reset_ref(*x);
-    }
-    return *x;
-}
-// Likewise, but row-major
-MatrixXdR &get_rm() {
-    static MatrixXdR *x;
-    if (!x) {
-        x = new MatrixXdR(3, 3);
-        reset_ref(*x);
-    }
-    return *x;
-}
-// Resets the values of the static matrices returned by get_cm()/get_rm()
-void reset_refs() {
-    reset_ref(get_cm());
-    reset_ref(get_rm());
-}
-
-// Returns element 2,1 from a matrix (used to test copy/nocopy)
-double get_elem(Eigen::Ref<const Eigen::MatrixXd> m) { return m(2, 1); };
-
-
-// Returns a matrix with 10*r + 100*c added to each matrix element (to help test that the matrix
-// reference is referencing rows/columns correctly).
-template <typename MatrixArgType> Eigen::MatrixXd adjust_matrix(MatrixArgType m) {
-    Eigen::MatrixXd ret(m);
-    for (int c = 0; c < m.cols(); c++) for (int r = 0; r < m.rows(); r++)
-        ret(r, c) += 10*r + 100*c;
-    return ret;
-}
-
-struct CustomOperatorNew {
-    CustomOperatorNew() = default;
-
-    Eigen::Matrix4d a = Eigen::Matrix4d::Zero();
-    Eigen::Matrix4d b = Eigen::Matrix4d::Identity();
-
-    EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
-};
-
-TEST_SUBMODULE(eigen, m) {
-    using FixedMatrixR = Eigen::Matrix<float, 5, 6, Eigen::RowMajor>;
-    using FixedMatrixC = Eigen::Matrix<float, 5, 6>;
-    using DenseMatrixR = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
-    using DenseMatrixC = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic>;
-    using FourRowMatrixC = Eigen::Matrix<float, 4, Eigen::Dynamic>;
-    using FourColMatrixC = Eigen::Matrix<float, Eigen::Dynamic, 4>;
-    using FourRowMatrixR = Eigen::Matrix<float, 4, Eigen::Dynamic>;
-    using FourColMatrixR = Eigen::Matrix<float, Eigen::Dynamic, 4>;
-    using SparseMatrixR = Eigen::SparseMatrix<float, Eigen::RowMajor>;
-    using SparseMatrixC = Eigen::SparseMatrix<float>;
-
-    // various tests
-    m.def("double_col", [](const Eigen::VectorXf &x) -> Eigen::VectorXf { return 2.0f * x; });
-    m.def("double_row", [](const Eigen::RowVectorXf &x) -> Eigen::RowVectorXf { return 2.0f * x; });
-    m.def("double_complex", [](const Eigen::VectorXcf &x) -> Eigen::VectorXcf { return 2.0f * x; });
-    m.def("double_threec", [](py::EigenDRef<Eigen::Vector3f> x) { x *= 2; });
-    m.def("double_threer", [](py::EigenDRef<Eigen::RowVector3f> x) { x *= 2; });
-    m.def("double_mat_cm", [](Eigen::MatrixXf x) -> Eigen::MatrixXf { return 2.0f * x; });
-    m.def("double_mat_rm", [](DenseMatrixR x) -> DenseMatrixR { return 2.0f * x; });
-
-    // test_eigen_ref_to_python
-    // Different ways of passing via Eigen::Ref; the first and second are the Eigen-recommended
-    m.def("cholesky1", [](Eigen::Ref<MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
-    m.def("cholesky2", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
-    m.def("cholesky3", [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
-    m.def("cholesky4", [](Eigen::Ref<const MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
-
-    // test_eigen_ref_mutators
-    // Mutators: these add some value to the given element using Eigen, but Eigen should be mapping into
-    // the numpy array data and so the result should show up there.  There are three versions: one that
-    // works on a contiguous-row matrix (numpy's default), one for a contiguous-column matrix, and one
-    // for any matrix.
-    auto add_rm = [](Eigen::Ref<MatrixXdR> x, int r, int c, double v) { x(r,c) += v; };
-    auto add_cm = [](Eigen::Ref<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; };
-
-    // Mutators (Eigen maps into numpy variables):
-    m.def("add_rm", add_rm); // Only takes row-contiguous
-    m.def("add_cm", add_cm); // Only takes column-contiguous
-    // Overloaded versions that will accept either row or column contiguous:
-    m.def("add1", add_rm);
-    m.def("add1", add_cm);
-    m.def("add2", add_cm);
-    m.def("add2", add_rm);
-    // This one accepts a matrix of any stride:
-    m.def("add_any", [](py::EigenDRef<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; });
-
-    // Return mutable references (numpy maps into eigen variables)
-    m.def("get_cm_ref", []() { return Eigen::Ref<Eigen::MatrixXd>(get_cm()); });
-    m.def("get_rm_ref", []() { return Eigen::Ref<MatrixXdR>(get_rm()); });
-    // The same references, but non-mutable (numpy maps into eigen variables, but is !writeable)
-    m.def("get_cm_const_ref", []() { return Eigen::Ref<const Eigen::MatrixXd>(get_cm()); });
-    m.def("get_rm_const_ref", []() { return Eigen::Ref<const MatrixXdR>(get_rm()); });
-
-    m.def("reset_refs", reset_refs); // Restores get_{cm,rm}_ref to original values
-
-    // Increments and returns ref to (same) matrix
-    m.def("incr_matrix", [](Eigen::Ref<Eigen::MatrixXd> m, double v) {
-        m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
-        return m;
-    }, py::return_value_policy::reference);
-
-    // Same, but accepts a matrix of any strides
-    m.def("incr_matrix_any", [](py::EigenDRef<Eigen::MatrixXd> m, double v) {
-        m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
-        return m;
-    }, py::return_value_policy::reference);
-
-    // Returns an eigen slice of even rows
-    m.def("even_rows", [](py::EigenDRef<Eigen::MatrixXd> m) {
-        return py::EigenDMap<Eigen::MatrixXd>(
-                m.data(), (m.rows() + 1) / 2, m.cols(),
-                py::EigenDStride(m.outerStride(), 2 * m.innerStride()));
-    }, py::return_value_policy::reference);
-
-    // Returns an eigen slice of even columns
-    m.def("even_cols", [](py::EigenDRef<Eigen::MatrixXd> m) {
-        return py::EigenDMap<Eigen::MatrixXd>(
-                m.data(), m.rows(), (m.cols() + 1) / 2,
-                py::EigenDStride(2 * m.outerStride(), m.innerStride()));
-    }, py::return_value_policy::reference);
-
-    // Returns diagonals: a vector-like object with an inner stride != 1
-    m.def("diagonal", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal(); });
-    m.def("diagonal_1", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal<1>(); });
-    m.def("diagonal_n", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int index) { return x.diagonal(index); });
-
-    // Return a block of a matrix (gives non-standard strides)
-    m.def("block", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int start_row, int start_col, int block_rows, int block_cols) {
-        return x.block(start_row, start_col, block_rows, block_cols);
-    });
-
-    // test_eigen_return_references, test_eigen_keepalive
-    // return value referencing/copying tests:
-    class ReturnTester {
-        Eigen::MatrixXd mat = create();
-    public:
-        ReturnTester() { print_created(this); }
-        ~ReturnTester() { print_destroyed(this); }
-        static Eigen::MatrixXd create() { return Eigen::MatrixXd::Ones(10, 10); }
-        static const Eigen::MatrixXd createConst() { return Eigen::MatrixXd::Ones(10, 10); }
-        Eigen::MatrixXd &get() { return mat; }
-        Eigen::MatrixXd *getPtr() { return &mat; }
-        const Eigen::MatrixXd &view() { return mat; }
-        const Eigen::MatrixXd *viewPtr() { return &mat; }
-        Eigen::Ref<Eigen::MatrixXd> ref() { return mat; }
-        Eigen::Ref<const Eigen::MatrixXd> refConst() { return mat; }
-        Eigen::Block<Eigen::MatrixXd> block(int r, int c, int nrow, int ncol) { return mat.block(r, c, nrow, ncol); }
-        Eigen::Block<const Eigen::MatrixXd> blockConst(int r, int c, int nrow, int ncol) const { return mat.block(r, c, nrow, ncol); }
-        py::EigenDMap<Eigen::Matrix2d> corners() { return py::EigenDMap<Eigen::Matrix2d>(mat.data(),
-                    py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); }
-        py::EigenDMap<const Eigen::Matrix2d> cornersConst() const { return py::EigenDMap<const Eigen::Matrix2d>(mat.data(),
-                    py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); }
-    };
-    using rvp = py::return_value_policy;
-    py::class_<ReturnTester>(m, "ReturnTester")
-        .def(py::init<>())
-        .def_static("create", &ReturnTester::create)
-        .def_static("create_const", &ReturnTester::createConst)
-        .def("get", &ReturnTester::get, rvp::reference_internal)
-        .def("get_ptr", &ReturnTester::getPtr, rvp::reference_internal)
-        .def("view", &ReturnTester::view, rvp::reference_internal)
-        .def("view_ptr", &ReturnTester::view, rvp::reference_internal)
-        .def("copy_get", &ReturnTester::get)   // Default rvp: copy
-        .def("copy_view", &ReturnTester::view) //         "
-        .def("ref", &ReturnTester::ref) // Default for Ref is to reference
-        .def("ref_const", &ReturnTester::refConst) // Likewise, but const
-        .def("ref_safe", &ReturnTester::ref, rvp::reference_internal)
-        .def("ref_const_safe", &ReturnTester::refConst, rvp::reference_internal)
-        .def("copy_ref", &ReturnTester::ref, rvp::copy)
-        .def("copy_ref_const", &ReturnTester::refConst, rvp::copy)
-        .def("block", &ReturnTester::block)
-        .def("block_safe", &ReturnTester::block, rvp::reference_internal)
-        .def("block_const", &ReturnTester::blockConst, rvp::reference_internal)
-        .def("copy_block", &ReturnTester::block, rvp::copy)
-        .def("corners", &ReturnTester::corners, rvp::reference_internal)
-        .def("corners_const", &ReturnTester::cornersConst, rvp::reference_internal)
-        ;
-
-    // test_special_matrix_objects
-    // Returns a DiagonalMatrix with diagonal (1,2,3,...)
-    m.def("incr_diag", [](int k) {
-        Eigen::DiagonalMatrix<int, Eigen::Dynamic> m(k);
-        for (int i = 0; i < k; i++) m.diagonal()[i] = i+1;
-        return m;
-    });
-
-    // Returns a SelfAdjointView referencing the lower triangle of m
-    m.def("symmetric_lower", [](const Eigen::MatrixXi &m) {
-            return m.selfadjointView<Eigen::Lower>();
-    });
-    // Returns a SelfAdjointView referencing the lower triangle of m
-    m.def("symmetric_upper", [](const Eigen::MatrixXi &m) {
-            return m.selfadjointView<Eigen::Upper>();
-    });
-
-    // Test matrix for various functions below.
-    Eigen::MatrixXf mat(5, 6);
-    mat << 0,  3,  0,  0,  0, 11,
-           22, 0,  0,  0, 17, 11,
-           7,  5,  0,  1,  0, 11,
-           0,  0,  0,  0,  0, 11,
-           0,  0, 14,  0,  8, 11;
-
-    // test_fixed, and various other tests
-    m.def("fixed_r", [mat]() -> FixedMatrixR { return FixedMatrixR(mat); });
-    m.def("fixed_r_const", [mat]() -> const FixedMatrixR { return FixedMatrixR(mat); });
-    m.def("fixed_c", [mat]() -> FixedMatrixC { return FixedMatrixC(mat); });
-    m.def("fixed_copy_r", [](const FixedMatrixR &m) -> FixedMatrixR { return m; });
-    m.def("fixed_copy_c", [](const FixedMatrixC &m) -> FixedMatrixC { return m; });
-    // test_mutator_descriptors
-    m.def("fixed_mutator_r", [](Eigen::Ref<FixedMatrixR>) {});
-    m.def("fixed_mutator_c", [](Eigen::Ref<FixedMatrixC>) {});
-    m.def("fixed_mutator_a", [](py::EigenDRef<FixedMatrixC>) {});
-    // test_dense
-    m.def("dense_r", [mat]() -> DenseMatrixR { return DenseMatrixR(mat); });
-    m.def("dense_c", [mat]() -> DenseMatrixC { return DenseMatrixC(mat); });
-    m.def("dense_copy_r", [](const DenseMatrixR &m) -> DenseMatrixR { return m; });
-    m.def("dense_copy_c", [](const DenseMatrixC &m) -> DenseMatrixC { return m; });
-    // test_sparse, test_sparse_signature
-    m.def("sparse_r", [mat]() -> SparseMatrixR { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
-    m.def("sparse_c", [mat]() -> SparseMatrixC { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
-    m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; });
-    m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; });
-    // test_partially_fixed
-    m.def("partial_copy_four_rm_r", [](const FourRowMatrixR &m) -> FourRowMatrixR { return m; });
-    m.def("partial_copy_four_rm_c", [](const FourColMatrixR &m) -> FourColMatrixR { return m; });
-    m.def("partial_copy_four_cm_r", [](const FourRowMatrixC &m) -> FourRowMatrixC { return m; });
-    m.def("partial_copy_four_cm_c", [](const FourColMatrixC &m) -> FourColMatrixC { return m; });
-
-    // test_cpp_casting
-    // Test that we can cast a numpy object to a Eigen::MatrixXd explicitly
-    m.def("cpp_copy", [](py::handle m) { return m.cast<Eigen::MatrixXd>()(1, 0); });
-    m.def("cpp_ref_c", [](py::handle m) { return m.cast<Eigen::Ref<Eigen::MatrixXd>>()(1, 0); });
-    m.def("cpp_ref_r", [](py::handle m) { return m.cast<Eigen::Ref<MatrixXdR>>()(1, 0); });
-    m.def("cpp_ref_any", [](py::handle m) { return m.cast<py::EigenDRef<Eigen::MatrixXd>>()(1, 0); });
-
-
-    // test_nocopy_wrapper
-    // Test that we can prevent copying into an argument that would normally copy: First a version
-    // that would allow copying (if types or strides don't match) for comparison:
-    m.def("get_elem", &get_elem);
-    // Now this alternative that calls the tells pybind to fail rather than copy:
-    m.def("get_elem_nocopy", [](Eigen::Ref<const Eigen::MatrixXd> m) -> double { return get_elem(m); },
-            py::arg().noconvert());
-    // Also test a row-major-only no-copy const ref:
-    m.def("get_elem_rm_nocopy", [](Eigen::Ref<const Eigen::Matrix<long, -1, -1, Eigen::RowMajor>> &m) -> long { return m(2, 1); },
-            py::arg().noconvert());
-
-    // test_issue738
-    // Issue #738: 1xN or Nx1 2D matrices were neither accepted nor properly copied with an
-    // incompatible stride value on the length-1 dimension--but that should be allowed (without
-    // requiring a copy!) because the stride value can be safely ignored on a size-1 dimension.
-    m.def("iss738_f1", &adjust_matrix<const Eigen::Ref<const Eigen::MatrixXd> &>, py::arg().noconvert());
-    m.def("iss738_f2", &adjust_matrix<const Eigen::Ref<const Eigen::Matrix<double, -1, -1, Eigen::RowMajor>> &>, py::arg().noconvert());
-
-    // test_issue1105
-    // Issue #1105: when converting from a numpy two-dimensional (Nx1) or (1xN) value into a dense
-    // eigen Vector or RowVector, the argument would fail to load because the numpy copy would fail:
-    // numpy won't broadcast a Nx1 into a 1-dimensional vector.
-    m.def("iss1105_col", [](Eigen::VectorXd) { return true; });
-    m.def("iss1105_row", [](Eigen::RowVectorXd) { return true; });
-
-    // test_named_arguments
-    // Make sure named arguments are working properly:
-    m.def("matrix_multiply", [](const py::EigenDRef<const Eigen::MatrixXd> A, const py::EigenDRef<const Eigen::MatrixXd> B)
-            -> Eigen::MatrixXd {
-        if (A.cols() != B.rows()) throw std::domain_error("Nonconformable matrices!");
-        return A * B;
-    }, py::arg("A"), py::arg("B"));
-
-    // test_custom_operator_new
-    py::class_<CustomOperatorNew>(m, "CustomOperatorNew")
-        .def(py::init<>())
-        .def_readonly("a", &CustomOperatorNew::a)
-        .def_readonly("b", &CustomOperatorNew::b);
-
-    // test_eigen_ref_life_support
-    // In case of a failure (the caster's temp array does not live long enough), creating
-    // a new array (np.ones(10)) increases the chances that the temp array will be garbage
-    // collected and/or that its memory will be overridden with different values.
-    m.def("get_elem_direct", [](Eigen::Ref<const Eigen::VectorXd> v) {
-        py::module::import("numpy").attr("ones")(10);
-        return v(5);
-    });
-    m.def("get_elem_indirect", [](std::vector<Eigen::Ref<const Eigen::VectorXd>> v) {
-        py::module::import("numpy").attr("ones")(10);
-        return v[0](5);
-    });
-}

spaces/CVPR/LIVE/thrust/thrust/iterator/detail/iterator_traversal_tags.h

@@ -1,41 +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
-
-namespace thrust
-{
-
-// define Boost's traversal tags
-struct no_traversal_tag {};
-
-struct incrementable_traversal_tag
-  : no_traversal_tag {};
-
-struct single_pass_traversal_tag
-  : incrementable_traversal_tag {};
-
-struct forward_traversal_tag
-  : single_pass_traversal_tag {};
-
-struct bidirectional_traversal_tag
-  : forward_traversal_tag {};
-
-struct random_access_traversal_tag
-  : bidirectional_traversal_tag {};
-
-} // end thrust
-

spaces/CVPR/LIVE/thrust/thrust/iterator/detail/reverse_iterator_base.h

@@ -1,42 +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/iterator/iterator_adaptor.h>
-#include <thrust/iterator/iterator_traits.h>
-
-namespace thrust
-{
-
-template <typename> class reverse_iterator;
-
-namespace detail
-{
-
-template<typename BidirectionalIterator>
-  struct reverse_iterator_base
-{
-  typedef thrust::iterator_adaptor<
-    thrust::reverse_iterator<BidirectionalIterator>,
-    BidirectionalIterator
-  > type;
-}; // end reverse_iterator_base
-
-} // end detail
-
-} // end thrust
-

spaces/CVPR/LIVE/thrust/thrust/system/cuda/pointer.h

@@ -1,321 +0,0 @@
-/*
- *  Copyright 2008-2018 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in ccudaliance 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/system/cuda/detail/execution_policy.h>
-#include <thrust/detail/type_traits.h>
-#include <thrust/detail/pointer.h>
-#include <thrust/detail/reference.h>
-
-namespace thrust
-{
-namespace cuda_cub
-{
-
-template <typename>
-class pointer;
-
-} // end cuda_cub
-} // end thrust
-
-
-// specialize thrust::iterator_traits to avoid problems with the name of
-// pointer's constructor shadowing its nested pointer type
-// do this before pointer is defined so the specialization is correctly
-// used inside the definition
-namespace thrust
-{
-
-template <typename Element>
-struct iterator_traits<thrust::cuda_cub::pointer<Element> >
-{
-private:
-  typedef thrust::cuda_cub::pointer<Element> ptr;
-
-public:
-  typedef typename ptr::iterator_category iterator_category;
-  typedef typename ptr::value_type        value_type;
-  typedef typename ptr::difference_type   difference_type;
-  typedef ptr                             pointer;
-  typedef typename ptr::reference         reference;
-};    // end iterator_traits
-
-namespace cuda_cub {
-
-// forward declaration of reference for pointer
-template <typename Element>
-class reference;
-
-// XXX nvcc + msvc have trouble instantiating reference below
-//     this is a workaround
-template <typename Element>
-struct reference_msvc_workaround
-{
-  typedef thrust::cuda_cub::reference<Element> type;
-};    // end reference_msvc_workaround
-
-
-/*! \p pointer stores a pointer to an object allocated in memory available to the cuda system.
- *  This type provides type safety when dispatching standard algorithms on ranges resident
- *  in cuda memory.
- *
- *  \p pointer has pointer semantics: it may be dereferenced and manipulated with pointer arithmetic.
- *
- *  \p pointer can be created with the function \p cuda::malloc, or by explicitly calling its constructor
- *  with a raw pointer.
- *
- *  The raw pointer encapsulated by a \p pointer may be obtained by eiter its <tt>get</tt> member function
- *  or the \p raw_pointer_cast function.
- *
- *  \note \p pointer is not a "smart" pointer; it is the programmer's responsibility to deallocate memory
- *  pointed to by \p pointer.
- *
- *  \tparam T specifies the type of the pointee.
- *
- *  \see cuda::malloc
- *  \see cuda::free
- *  \see raw_pointer_cast
- */
-template <typename T>
-class pointer
-    : public thrust::pointer<
-          T,
-          thrust::cuda_cub::tag,
-          thrust::cuda_cub::reference<T>,
-          thrust::cuda_cub::pointer<T> >
-{
-
-private:
-  typedef thrust::pointer<
-      T,
-      thrust::cuda_cub::tag,
-      typename reference_msvc_workaround<T>::type,
-      thrust::cuda_cub::pointer<T> >
-      super_t;
-
-public:
-  /*! \p pointer's no-argument constructor initializes its encapsulated pointer to \c 0.
-   */
-  __host__ __device__
-  pointer() : super_t() {}
-
-  #if THRUST_CPP_DIALECT >= 2011
-  // NOTE: This is needed so that Thrust smart pointers can be used in
-  // `std::unique_ptr`.
-  __host__ __device__
-  pointer(decltype(nullptr)) : super_t(nullptr) {}
-  #endif
-
-  /*! This constructor allows construction of a <tt>pointer<const T></tt> from a <tt>T*</tt>.
-   *
-   *  \param ptr A raw pointer to copy from, presumed to point to a location in memory
-   *         accessible by the \p cuda system.
-   *  \tparam OtherT \p OtherT shall be convertible to \p T.
-   */
-  template <typename OtherT>
-  __host__ __device__ explicit pointer(OtherT *ptr) : super_t(ptr)
-  {
-  }
-
-  /*! This constructor allows construction from another pointer-like object with related type.
-   *
-   *  \param other The \p OtherPointer to copy.
-   *  \tparam OtherPointer The system tag associated with \p OtherPointer shall be convertible
-   *          to \p thrust::system::cuda::tag and its element type shall be convertible to \p T.
-   */
-  template <typename OtherPointer>
-  __host__ __device__
-  pointer(const OtherPointer &other,
-          typename thrust::detail::enable_if_pointer_is_convertible<
-              OtherPointer,
-              pointer>::type * = 0) : super_t(other)
-  {
-  }
-
-  /*! This constructor allows construction from another pointer-like object with \p void type.
-   *
-   *  \param other The \p OtherPointer to copy.
-   *  \tparam OtherPointer The system tag associated with \p OtherPointer shall be convertible
-   *          to \p thrust::system::cuda::tag and its element type shall be \p void.
-   */
-  template <typename OtherPointer>
-  __host__ __device__
-  explicit
-  pointer(const OtherPointer &other,
-          typename thrust::detail::enable_if_void_pointer_is_system_convertible<
-              OtherPointer,
-              pointer>::type * = 0) : super_t(other)
-  {
-  }
-
-  /*! Assignment operator allows assigning from another pointer-like object with related type.
-   *
-   *  \param other The other pointer-like object to assign from.
-   *  \tparam OtherPointer The system tag associated with \p OtherPointer shall be convertible
-   *          to \p thrust::system::cuda::tag and its element type shall be convertible to \p T.
-   */
-  template <typename OtherPointer>
-  __host__ __device__
-      typename thrust::detail::enable_if_pointer_is_convertible<
-          OtherPointer,
-          pointer,
-          pointer &>::type
-      operator=(const OtherPointer &other)
-  {
-    return super_t::operator=(other);
-  }
-
-  #if THRUST_CPP_DIALECT >= 2011
-  // NOTE: This is needed so that Thrust smart pointers can be used in
-  // `std::unique_ptr`.
-  __host__ __device__
-  pointer& operator=(decltype(nullptr))
-  {
-    super_t::operator=(nullptr);
-    return *this;
-  }
-  #endif
-};    // struct pointer
-
-/*! \p reference is a wrapped reference to an object stored in memory available to the \p cuda system.
- *  \p reference is the type of the result of dereferencing a \p cuda::pointer.
- *
- *  \tparam T Specifies the type of the referenced object.
- */
-template <typename T>
-class reference
-    : public thrust::reference<
-          T,
-          thrust::cuda_cub::pointer<T>,
-          thrust::cuda_cub::reference<T> >
-{
-
-private:
-  typedef thrust::reference<
-      T,
-      thrust::cuda_cub::pointer<T>,
-      thrust::cuda_cub::reference<T> >
-      super_t;
-
-public:
-  /*! \cond
-   */
-
-  typedef typename super_t::value_type value_type;
-  typedef typename super_t::pointer    pointer;
-
-  /*! \endcond
-   */
-
-  /*! This constructor initializes this \p reference to refer to an object
-   *  pointed to by the given \p pointer. After this \p reference is constructed,
-   *  it shall refer to the object pointed to by \p ptr.
-   *
-   *  \param ptr A \p pointer to copy from.
-   */
-  __host__ __device__ explicit reference(const pointer &ptr)
-      : super_t(ptr)
-  {
-  }
-
-  /*! This constructor accepts a const reference to another \p reference of related type.
-   *  After this \p reference is constructed, it shall refer to the same object as \p other.
-   *
-   *  \param other A \p reference to copy from.
-   *  \tparam OtherT The element type of the other \p reference.
-   *
-   *  \note This constructor is templated primarily to allow initialization of <tt>reference<const T></tt>
-   *        from <tt>reference<T></tt>.
-   */
-  template <typename OtherT>
-  __host__ __device__
-  reference(const reference<OtherT> &other,
-            typename thrust::detail::enable_if_convertible<
-                typename reference<OtherT>::pointer,
-                pointer>::type * = 0)
-      : super_t(other)
-  {
-  }
-
-  /*! Copy assignment operator copy assigns from another \p reference of related type.
-   *
-   *  \param other The other \p reference to assign from.
-   *  \return <tt>*this</tt>
-   *  \tparam OtherT The element type of the other \p reference.
-   */
-  template <typename OtherT>
-  __host__ __device__
-      reference &
-      operator=(const reference<OtherT> &other);
-
-  /*! Assignment operator assigns from a \p value_type.
-   *
-   *  \param x The \p value_type to assign from.
-   *  \return <tt>*this</tt>
-   */
-  __host__ __device__
-      reference &
-      operator=(const value_type &x);
-};    // struct reference
-
-/*! Exchanges the values of two objects referred to by \p reference.
- *  \p x The first \p reference of interest.
- *  \p y The second \p reference of interest.
- */
-template <typename T>
-__host__ __device__ void swap(reference<T> x, reference<T> y);
-
-} // end cuda_cub
-
-namespace system {
-
-
-/*! \addtogroup system_backends Systems
- *  \ingroup system
- *  \{
- */
-
-/*! \namespace thrust::system::cuda
- *  \brief \p thrust::system::cuda is the namespace containing functionality for allocating, manipulating,
- *         and deallocating memory available to Thrust's CUDA backend system.
- *         The identifiers are provided in a separate namespace underneath <tt>thrust::system</tt>
- *         for import convenience but are also aliased in the top-level <tt>thrust::cuda</tt>
- *         namespace for easy access.
- *
- */
-
-namespace cuda {
-using thrust::cuda_cub::pointer;
-using thrust::cuda_cub::reference;
-} // end cuda
-
-/*! \}
- */
-
-} // end system
-
-/*! \namespace thrust::cuda
- *  \brief \p thrust::cuda is a top-level alias for \p thrust::system::cuda. */
-namespace cuda {
-using thrust::cuda_cub::pointer;
-using thrust::cuda_cub::reference;
-} // end cuda
-
-} // end thrust
-
-#include <thrust/system/cuda/detail/pointer.inl>

spaces/CVPR/LIVE/thrust/thrust/system/detail/sequential/generate.h

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

spaces/CVPR/WALT/mmdet/datasets/pipelines/transforms.py

@@ -1,1812 +0,0 @@
-import copy
-import inspect
-
-import mmcv
-import numpy as np
-from numpy import random
-
-from mmdet.core import PolygonMasks
-from mmdet.core.evaluation.bbox_overlaps import bbox_overlaps
-from ..builder import PIPELINES
-
-try:
-    from imagecorruptions import corrupt
-except ImportError:
-    corrupt = None
-
-try:
-    import albumentations
-    from albumentations import Compose
-except ImportError:
-    albumentations = None
-    Compose = None
-
-
-@PIPELINES.register_module()
-class Resize(object):
-    """Resize images & bbox & mask.
-
-    This transform resizes the input image to some scale. Bboxes and masks are
-    then resized with the same scale factor. If the input dict contains the key
-    "scale", then the scale in the input dict is used, otherwise the specified
-    scale in the init method is used. If the input dict contains the key
-    "scale_factor" (if MultiScaleFlipAug does not give img_scale but
-    scale_factor), the actual scale will be computed by image shape and
-    scale_factor.
-
-    `img_scale` can either be a tuple (single-scale) or a list of tuple
-    (multi-scale). There are 3 multiscale modes:
-
-    - ``ratio_range is not None``: randomly sample a ratio from the ratio \
-      range and multiply it with the image scale.
-    - ``ratio_range is None`` and ``multiscale_mode == "range"``: randomly \
-      sample a scale from the multiscale range.
-    - ``ratio_range is None`` and ``multiscale_mode == "value"``: randomly \
-      sample a scale from multiple scales.
-
-    Args:
-        img_scale (tuple or list[tuple]): Images scales for resizing.
-        multiscale_mode (str): Either "range" or "value".
-        ratio_range (tuple[float]): (min_ratio, max_ratio)
-        keep_ratio (bool): Whether to keep the aspect ratio when resizing the
-            image.
-        bbox_clip_border (bool, optional): Whether clip the objects outside
-            the border of the image. Defaults to True.
-        backend (str): Image resize backend, choices are 'cv2' and 'pillow'.
-            These two backends generates slightly different results. Defaults
-            to 'cv2'.
-        override (bool, optional): Whether to override `scale` and
-            `scale_factor` so as to call resize twice. Default False. If True,
-            after the first resizing, the existed `scale` and `scale_factor`
-            will be ignored so the second resizing can be allowed.
-            This option is a work-around for multiple times of resize in DETR.
-            Defaults to False.
-    """
-
-    def __init__(self,
-                 img_scale=None,
-                 multiscale_mode='range',
-                 ratio_range=None,
-                 keep_ratio=True,
-                 bbox_clip_border=True,
-                 backend='cv2',
-                 override=False):
-        if img_scale is None:
-            self.img_scale = None
-        else:
-            if isinstance(img_scale, list):
-                self.img_scale = img_scale
-            else:
-                self.img_scale = [img_scale]
-            assert mmcv.is_list_of(self.img_scale, tuple)
-
-        if ratio_range is not None:
-            # mode 1: given a scale and a range of image ratio
-            assert len(self.img_scale) == 1
-        else:
-            # mode 2: given multiple scales or a range of scales
-            assert multiscale_mode in ['value', 'range']
-
-        self.backend = backend
-        self.multiscale_mode = multiscale_mode
-        self.ratio_range = ratio_range
-        self.keep_ratio = keep_ratio
-        # TODO: refactor the override option in Resize
-        self.override = override
-        self.bbox_clip_border = bbox_clip_border
-
-    @staticmethod
-    def random_select(img_scales):
-        """Randomly select an img_scale from given candidates.
-
-        Args:
-            img_scales (list[tuple]): Images scales for selection.
-
-        Returns:
-            (tuple, int): Returns a tuple ``(img_scale, scale_dix)``, \
-                where ``img_scale`` is the selected image scale and \
-                ``scale_idx`` is the selected index in the given candidates.
-        """
-
-        assert mmcv.is_list_of(img_scales, tuple)
-        scale_idx = np.random.randint(len(img_scales))
-        img_scale = img_scales[scale_idx]
-        return img_scale, scale_idx
-
-    @staticmethod
-    def random_sample(img_scales):
-        """Randomly sample an img_scale when ``multiscale_mode=='range'``.
-
-        Args:
-            img_scales (list[tuple]): Images scale range for sampling.
-                There must be two tuples in img_scales, which specify the lower
-                and upper bound of image scales.
-
-        Returns:
-            (tuple, None): Returns a tuple ``(img_scale, None)``, where \
-                ``img_scale`` is sampled scale and None is just a placeholder \
-                to be consistent with :func:`random_select`.
-        """
-
-        assert mmcv.is_list_of(img_scales, tuple) and len(img_scales) == 2
-        img_scale_long = [max(s) for s in img_scales]
-        img_scale_short = [min(s) for s in img_scales]
-        long_edge = np.random.randint(
-            min(img_scale_long),
-            max(img_scale_long) + 1)
-        short_edge = np.random.randint(
-            min(img_scale_short),
-            max(img_scale_short) + 1)
-        img_scale = (long_edge, short_edge)
-        return img_scale, None
-
-    @staticmethod
-    def random_sample_ratio(img_scale, ratio_range):
-        """Randomly sample an img_scale when ``ratio_range`` is specified.
-
-        A ratio will be randomly sampled from the range specified by
-        ``ratio_range``. Then it would be multiplied with ``img_scale`` to
-        generate sampled scale.
-
-        Args:
-            img_scale (tuple): Images scale base to multiply with ratio.
-            ratio_range (tuple[float]): The minimum and maximum ratio to scale
-                the ``img_scale``.
-
-        Returns:
-            (tuple, None): Returns a tuple ``(scale, None)``, where \
-                ``scale`` is sampled ratio multiplied with ``img_scale`` and \
-                None is just a placeholder to be consistent with \
-                :func:`random_select`.
-        """
-
-        assert isinstance(img_scale, tuple) and len(img_scale) == 2
-        min_ratio, max_ratio = ratio_range
-        assert min_ratio <= max_ratio
-        ratio = np.random.random_sample() * (max_ratio - min_ratio) + min_ratio
-        scale = int(img_scale[0] * ratio), int(img_scale[1] * ratio)
-        return scale, None
-
-    def _random_scale(self, results):
-        """Randomly sample an img_scale according to ``ratio_range`` and
-        ``multiscale_mode``.
-
-        If ``ratio_range`` is specified, a ratio will be sampled and be
-        multiplied with ``img_scale``.
-        If multiple scales are specified by ``img_scale``, a scale will be
-        sampled according to ``multiscale_mode``.
-        Otherwise, single scale will be used.
-
-        Args:
-            results (dict): Result dict from :obj:`dataset`.
-
-        Returns:
-            dict: Two new keys 'scale` and 'scale_idx` are added into \
-                ``results``, which would be used by subsequent pipelines.
-        """
-
-        if self.ratio_range is not None:
-            scale, scale_idx = self.random_sample_ratio(
-                self.img_scale[0], self.ratio_range)
-        elif len(self.img_scale) == 1:
-            scale, scale_idx = self.img_scale[0], 0
-        elif self.multiscale_mode == 'range':
-            scale, scale_idx = self.random_sample(self.img_scale)
-        elif self.multiscale_mode == 'value':
-            scale, scale_idx = self.random_select(self.img_scale)
-        else:
-            raise NotImplementedError
-
-        results['scale'] = scale
-        results['scale_idx'] = scale_idx
-
-    def _resize_img(self, results):
-        """Resize images with ``results['scale']``."""
-        for key in results.get('img_fields', ['img']):
-            if self.keep_ratio:
-                img, scale_factor = mmcv.imrescale(
-                    results[key],
-                    results['scale'],
-                    return_scale=True,
-                    backend=self.backend)
-                # the w_scale and h_scale has minor difference
-                # a real fix should be done in the mmcv.imrescale in the future
-                new_h, new_w = img.shape[:2]
-                h, w = results[key].shape[:2]
-                w_scale = new_w / w
-                h_scale = new_h / h
-            else:
-                img, w_scale, h_scale = mmcv.imresize(
-                    results[key],
-                    results['scale'],
-                    return_scale=True,
-                    backend=self.backend)
-            results[key] = img
-
-            scale_factor = np.array([w_scale, h_scale, w_scale, h_scale],
-                                    dtype=np.float32)
-            results['img_shape'] = img.shape
-            # in case that there is no padding
-            results['pad_shape'] = img.shape
-            results['scale_factor'] = scale_factor
-            results['keep_ratio'] = self.keep_ratio
-
-    def _resize_bboxes(self, results):
-        """Resize bounding boxes with ``results['scale_factor']``."""
-        for key in results.get('bbox_fields', []):
-            bboxes = results[key] * results['scale_factor']
-            if self.bbox_clip_border:
-                img_shape = results['img_shape']
-                bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])
-                bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])
-            results[key] = bboxes
-
-    def _resize_masks(self, results):
-        """Resize masks with ``results['scale']``"""
-        for key in results.get('mask_fields', []):
-            if results[key] is None:
-                continue
-            if self.keep_ratio:
-                results[key] = results[key].rescale(results['scale'])
-            else:
-                results[key] = results[key].resize(results['img_shape'][:2])
-
-    def _resize_seg(self, results):
-        """Resize semantic segmentation map with ``results['scale']``."""
-        for key in results.get('seg_fields', []):
-            if self.keep_ratio:
-                gt_seg = mmcv.imrescale(
-                    results[key],
-                    results['scale'],
-                    interpolation='nearest',
-                    backend=self.backend)
-            else:
-                gt_seg = mmcv.imresize(
-                    results[key],
-                    results['scale'],
-                    interpolation='nearest',
-                    backend=self.backend)
-            results['gt_semantic_seg'] = gt_seg
-
-    def __call__(self, results):
-        """Call function to resize images, bounding boxes, masks, semantic
-        segmentation map.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Resized results, 'img_shape', 'pad_shape', 'scale_factor', \
-                'keep_ratio' keys are added into result dict.
-        """
-
-        if 'scale' not in results:
-            if 'scale_factor' in results:
-                img_shape = results['img'].shape[:2]
-                scale_factor = results['scale_factor']
-                assert isinstance(scale_factor, float)
-                results['scale'] = tuple(
-                    [int(x * scale_factor) for x in img_shape][::-1])
-            else:
-                self._random_scale(results)
-        else:
-            if not self.override:
-                assert 'scale_factor' not in results, (
-                    'scale and scale_factor cannot be both set.')
-            else:
-                results.pop('scale')
-                if 'scale_factor' in results:
-                    results.pop('scale_factor')
-                self._random_scale(results)
-
-        self._resize_img(results)
-        self._resize_bboxes(results)
-        self._resize_masks(results)
-        self._resize_seg(results)
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(img_scale={self.img_scale}, '
-        repr_str += f'multiscale_mode={self.multiscale_mode}, '
-        repr_str += f'ratio_range={self.ratio_range}, '
-        repr_str += f'keep_ratio={self.keep_ratio}, '
-        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class RandomFlip(object):
-    """Flip the image & bbox & mask.
-
-    If the input dict contains the key "flip", then the flag will be used,
-    otherwise it will be randomly decided by a ratio specified in the init
-    method.
-
-    When random flip is enabled, ``flip_ratio``/``direction`` can either be a
-    float/string or tuple of float/string. There are 3 flip modes:
-
-    - ``flip_ratio`` is float, ``direction`` is string: the image will be
-        ``direction``ly flipped with probability of ``flip_ratio`` .
-        E.g., ``flip_ratio=0.5``, ``direction='horizontal'``,
-        then image will be horizontally flipped with probability of 0.5.
-    - ``flip_ratio`` is float, ``direction`` is list of string: the image wil
-        be ``direction[i]``ly flipped with probability of
-        ``flip_ratio/len(direction)``.
-        E.g., ``flip_ratio=0.5``, ``direction=['horizontal', 'vertical']``,
-        then image will be horizontally flipped with probability of 0.25,
-        vertically with probability of 0.25.
-    - ``flip_ratio`` is list of float, ``direction`` is list of string:
-        given ``len(flip_ratio) == len(direction)``, the image wil
-        be ``direction[i]``ly flipped with probability of ``flip_ratio[i]``.
-        E.g., ``flip_ratio=[0.3, 0.5]``, ``direction=['horizontal',
-        'vertical']``, then image will be horizontally flipped with probability
-         of 0.3, vertically with probability of 0.5
-
-    Args:
-        flip_ratio (float | list[float], optional): The flipping probability.
-            Default: None.
-        direction(str | list[str], optional): The flipping direction. Options
-            are 'horizontal', 'vertical', 'diagonal'. Default: 'horizontal'.
-            If input is a list, the length must equal ``flip_ratio``. Each
-            element in ``flip_ratio`` indicates the flip probability of
-            corresponding direction.
-    """
-
-    def __init__(self, flip_ratio=None, direction='horizontal'):
-        if isinstance(flip_ratio, list):
-            assert mmcv.is_list_of(flip_ratio, float)
-            assert 0 <= sum(flip_ratio) <= 1
-        elif isinstance(flip_ratio, float):
-            assert 0 <= flip_ratio <= 1
-        elif flip_ratio is None:
-            pass
-        else:
-            raise ValueError('flip_ratios must be None, float, '
-                             'or list of float')
-        self.flip_ratio = flip_ratio
-
-        valid_directions = ['horizontal', 'vertical', 'diagonal']
-        if isinstance(direction, str):
-            assert direction in valid_directions
-        elif isinstance(direction, list):
-            assert mmcv.is_list_of(direction, str)
-            assert set(direction).issubset(set(valid_directions))
-        else:
-            raise ValueError('direction must be either str or list of str')
-        self.direction = direction
-
-        if isinstance(flip_ratio, list):
-            assert len(self.flip_ratio) == len(self.direction)
-
-    def bbox_flip(self, bboxes, img_shape, direction):
-        """Flip bboxes horizontally.
-
-        Args:
-            bboxes (numpy.ndarray): Bounding boxes, shape (..., 4*k)
-            img_shape (tuple[int]): Image shape (height, width)
-            direction (str): Flip direction. Options are 'horizontal',
-                'vertical'.
-
-        Returns:
-            numpy.ndarray: Flipped bounding boxes.
-        """
-
-        assert bboxes.shape[-1] % 4 == 0
-        flipped = bboxes.copy()
-        if direction == 'horizontal':
-            w = img_shape[1]
-            flipped[..., 0::4] = w - bboxes[..., 2::4]
-            flipped[..., 2::4] = w - bboxes[..., 0::4]
-        elif direction == 'vertical':
-            h = img_shape[0]
-            flipped[..., 1::4] = h - bboxes[..., 3::4]
-            flipped[..., 3::4] = h - bboxes[..., 1::4]
-        elif direction == 'diagonal':
-            w = img_shape[1]
-            h = img_shape[0]
-            flipped[..., 0::4] = w - bboxes[..., 2::4]
-            flipped[..., 1::4] = h - bboxes[..., 3::4]
-            flipped[..., 2::4] = w - bboxes[..., 0::4]
-            flipped[..., 3::4] = h - bboxes[..., 1::4]
-        else:
-            raise ValueError(f"Invalid flipping direction '{direction}'")
-        return flipped
-
-    def __call__(self, results):
-        """Call function to flip bounding boxes, masks, semantic segmentation
-        maps.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Flipped results, 'flip', 'flip_direction' keys are added \
-                into result dict.
-        """
-
-        if 'flip' not in results:
-            if isinstance(self.direction, list):
-                # None means non-flip
-                direction_list = self.direction + [None]
-            else:
-                # None means non-flip
-                direction_list = [self.direction, None]
-
-            if isinstance(self.flip_ratio, list):
-                non_flip_ratio = 1 - sum(self.flip_ratio)
-                flip_ratio_list = self.flip_ratio + [non_flip_ratio]
-            else:
-                non_flip_ratio = 1 - self.flip_ratio
-                # exclude non-flip
-                single_ratio = self.flip_ratio / (len(direction_list) - 1)
-                flip_ratio_list = [single_ratio] * (len(direction_list) -
-                                                    1) + [non_flip_ratio]
-
-            cur_dir = np.random.choice(direction_list, p=flip_ratio_list)
-
-            results['flip'] = cur_dir is not None
-        if 'flip_direction' not in results:
-            results['flip_direction'] = cur_dir
-        if results['flip']:
-            # flip image
-            for key in results.get('img_fields', ['img']):
-                results[key] = mmcv.imflip(
-                    results[key], direction=results['flip_direction'])
-            # flip bboxes
-            for key in results.get('bbox_fields', []):
-                results[key] = self.bbox_flip(results[key],
-                                              results['img_shape'],
-                                              results['flip_direction'])
-            # flip masks
-            for key in results.get('mask_fields', []):
-                results[key] = results[key].flip(results['flip_direction'])
-
-            # flip segs
-            for key in results.get('seg_fields', []):
-                results[key] = mmcv.imflip(
-                    results[key], direction=results['flip_direction'])
-        return results
-
-    def __repr__(self):
-        return self.__class__.__name__ + f'(flip_ratio={self.flip_ratio})'
-
-
-@PIPELINES.register_module()
-class Pad(object):
-    """Pad the image & mask.
-
-    There are two padding modes: (1) pad to a fixed size and (2) pad to the
-    minimum size that is divisible by some number.
-    Added keys are "pad_shape", "pad_fixed_size", "pad_size_divisor",
-
-    Args:
-        size (tuple, optional): Fixed padding size.
-        size_divisor (int, optional): The divisor of padded size.
-        pad_val (float, optional): Padding value, 0 by default.
-    """
-
-    def __init__(self, size=None, size_divisor=None, pad_val=0):
-        self.size = size
-        self.size_divisor = size_divisor
-        self.pad_val = pad_val
-        # only one of size and size_divisor should be valid
-        assert size is not None or size_divisor is not None
-        assert size is None or size_divisor is None
-
-    def _pad_img(self, results):
-        """Pad images according to ``self.size``."""
-        for key in results.get('img_fields', ['img']):
-            if self.size is not None:
-                padded_img = mmcv.impad(
-                    results[key], shape=self.size, pad_val=self.pad_val)
-            elif self.size_divisor is not None:
-                padded_img = mmcv.impad_to_multiple(
-                    results[key], self.size_divisor, pad_val=self.pad_val)
-            results[key] = padded_img
-        results['pad_shape'] = padded_img.shape
-        results['pad_fixed_size'] = self.size
-        results['pad_size_divisor'] = self.size_divisor
-
-    def _pad_masks(self, results):
-        """Pad masks according to ``results['pad_shape']``."""
-        pad_shape = results['pad_shape'][:2]
-        for key in results.get('mask_fields', []):
-            results[key] = results[key].pad(pad_shape, pad_val=self.pad_val)
-
-    def _pad_seg(self, results):
-        """Pad semantic segmentation map according to
-        ``results['pad_shape']``."""
-        for key in results.get('seg_fields', []):
-            results[key] = mmcv.impad(
-                results[key], shape=results['pad_shape'][:2])
-
-    def __call__(self, results):
-        """Call function to pad images, masks, semantic segmentation maps.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Updated result dict.
-        """
-        self._pad_img(results)
-        self._pad_masks(results)
-        self._pad_seg(results)
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(size={self.size}, '
-        repr_str += f'size_divisor={self.size_divisor}, '
-        repr_str += f'pad_val={self.pad_val})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class Normalize(object):
-    """Normalize the image.
-
-    Added key is "img_norm_cfg".
-
-    Args:
-        mean (sequence): Mean values of 3 channels.
-        std (sequence): Std values of 3 channels.
-        to_rgb (bool): Whether to convert the image from BGR to RGB,
-            default is true.
-    """
-
-    def __init__(self, mean, std, to_rgb=True):
-        self.mean = np.array(mean, dtype=np.float32)
-        self.std = np.array(std, dtype=np.float32)
-        self.to_rgb = to_rgb
-
-    def __call__(self, results):
-        """Call function to normalize images.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Normalized results, 'img_norm_cfg' key is added into
-                result dict.
-        """
-        for key in results.get('img_fields', ['img']):
-            results[key] = mmcv.imnormalize(results[key], self.mean, self.std,
-                                            self.to_rgb)
-        results['img_norm_cfg'] = dict(
-            mean=self.mean, std=self.std, to_rgb=self.to_rgb)
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(mean={self.mean}, std={self.std}, to_rgb={self.to_rgb})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class RandomCrop(object):
-    """Random crop the image & bboxes & masks.
-
-    The absolute `crop_size` is sampled based on `crop_type` and `image_size`,
-    then the cropped results are generated.
-
-    Args:
-        crop_size (tuple): The relative ratio or absolute pixels of
-            height and width.
-        crop_type (str, optional): one of "relative_range", "relative",
-            "absolute", "absolute_range". "relative" randomly crops
-            (h * crop_size[0], w * crop_size[1]) part from an input of size
-            (h, w). "relative_range" uniformly samples relative crop size from
-            range [crop_size[0], 1] and [crop_size[1], 1] for height and width
-            respectively. "absolute" crops from an input with absolute size
-            (crop_size[0], crop_size[1]). "absolute_range" uniformly samples
-            crop_h in range [crop_size[0], min(h, crop_size[1])] and crop_w
-            in range [crop_size[0], min(w, crop_size[1])]. Default "absolute".
-        allow_negative_crop (bool, optional): Whether to allow a crop that does
-            not contain any bbox area. Default False.
-        bbox_clip_border (bool, optional): Whether clip the objects outside
-            the border of the image. Defaults to True.
-
-    Note:
-        - If the image is smaller than the absolute crop size, return the
-            original image.
-        - The keys for bboxes, labels and masks must be aligned. That is,
-          `gt_bboxes` corresponds to `gt_labels` and `gt_masks`, and
-          `gt_bboxes_ignore` corresponds to `gt_labels_ignore` and
-          `gt_masks_ignore`.
-        - If the crop does not contain any gt-bbox region and
-          `allow_negative_crop` is set to False, skip this image.
-    """
-
-    def __init__(self,
-                 crop_size,
-                 crop_type='absolute',
-                 allow_negative_crop=False,
-                 bbox_clip_border=True):
-        if crop_type not in [
-                'relative_range', 'relative', 'absolute', 'absolute_range'
-        ]:
-            raise ValueError(f'Invalid crop_type {crop_type}.')
-        if crop_type in ['absolute', 'absolute_range']:
-            assert crop_size[0] > 0 and crop_size[1] > 0
-            assert isinstance(crop_size[0], int) and isinstance(
-                crop_size[1], int)
-        else:
-            assert 0 < crop_size[0] <= 1 and 0 < crop_size[1] <= 1
-        self.crop_size = crop_size
-        self.crop_type = crop_type
-        self.allow_negative_crop = allow_negative_crop
-        self.bbox_clip_border = bbox_clip_border
-        # The key correspondence from bboxes to labels and masks.
-        self.bbox2label = {
-            'gt_bboxes': 'gt_labels',
-            'gt_bboxes_ignore': 'gt_labels_ignore'
-        }
-        self.bbox2mask = {
-            'gt_bboxes': 'gt_masks',
-            'gt_bboxes_ignore': 'gt_masks_ignore'
-        }
-
-    def _crop_data(self, results, crop_size, allow_negative_crop):
-        """Function to randomly crop images, bounding boxes, masks, semantic
-        segmentation maps.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-            crop_size (tuple): Expected absolute size after cropping, (h, w).
-            allow_negative_crop (bool): Whether to allow a crop that does not
-                contain any bbox area. Default to False.
-
-        Returns:
-            dict: Randomly cropped results, 'img_shape' key in result dict is
-                updated according to crop size.
-        """
-        assert crop_size[0] > 0 and crop_size[1] > 0
-        for key in results.get('img_fields', ['img']):
-            img = results[key]
-            margin_h = max(img.shape[0] - crop_size[0], 0)
-            margin_w = max(img.shape[1] - crop_size[1], 0)
-            offset_h = np.random.randint(0, margin_h + 1)
-            offset_w = np.random.randint(0, margin_w + 1)
-            crop_y1, crop_y2 = offset_h, offset_h + crop_size[0]
-            crop_x1, crop_x2 = offset_w, offset_w + crop_size[1]
-
-            # crop the image
-            img = img[crop_y1:crop_y2, crop_x1:crop_x2, ...]
-            img_shape = img.shape
-            results[key] = img
-        results['img_shape'] = img_shape
-
-        # crop bboxes accordingly and clip to the image boundary
-        for key in results.get('bbox_fields', []):
-            # e.g. gt_bboxes and gt_bboxes_ignore
-            bbox_offset = np.array([offset_w, offset_h, offset_w, offset_h],
-                                   dtype=np.float32)
-            bboxes = results[key] - bbox_offset
-            if self.bbox_clip_border:
-                bboxes[:, 0::2] = np.clip(bboxes[:, 0::2], 0, img_shape[1])
-                bboxes[:, 1::2] = np.clip(bboxes[:, 1::2], 0, img_shape[0])
-            valid_inds = (bboxes[:, 2] > bboxes[:, 0]) & (
-                bboxes[:, 3] > bboxes[:, 1])
-            # If the crop does not contain any gt-bbox area and
-            # allow_negative_crop is False, skip this image.
-            if (key == 'gt_bboxes' and not valid_inds.any()
-                    and not allow_negative_crop):
-                return None
-            results[key] = bboxes[valid_inds, :]
-            # label fields. e.g. gt_labels and gt_labels_ignore
-            label_key = self.bbox2label.get(key)
-            if label_key in results:
-                results[label_key] = results[label_key][valid_inds]
-
-            # mask fields, e.g. gt_masks and gt_masks_ignore
-            mask_key = self.bbox2mask.get(key)
-            if mask_key in results:
-                results[mask_key] = results[mask_key][
-                    valid_inds.nonzero()[0]].crop(
-                        np.asarray([crop_x1, crop_y1, crop_x2, crop_y2]))
-
-
-        # crop semantic seg
-        for key in results.get('seg_fields', []):
-            results[key] = results[key][crop_y1:crop_y2, crop_x1:crop_x2]
-
-        return results
-
-    def _get_crop_size(self, image_size):
-        """Randomly generates the absolute crop size based on `crop_type` and
-        `image_size`.
-
-        Args:
-            image_size (tuple): (h, w).
-
-        Returns:
-            crop_size (tuple): (crop_h, crop_w) in absolute pixels.
-        """
-        h, w = image_size
-        if self.crop_type == 'absolute':
-            return (min(self.crop_size[0], h), min(self.crop_size[1], w))
-        elif self.crop_type == 'absolute_range':
-            assert self.crop_size[0] <= self.crop_size[1]
-            crop_h = np.random.randint(
-                min(h, self.crop_size[0]),
-                min(h, self.crop_size[1]) + 1)
-            crop_w = np.random.randint(
-                min(w, self.crop_size[0]),
-                min(w, self.crop_size[1]) + 1)
-            return crop_h, crop_w
-        elif self.crop_type == 'relative':
-            crop_h, crop_w = self.crop_size
-            return int(h * crop_h + 0.5), int(w * crop_w + 0.5)
-        elif self.crop_type == 'relative_range':
-            crop_size = np.asarray(self.crop_size, dtype=np.float32)
-            crop_h, crop_w = crop_size + np.random.rand(2) * (1 - crop_size)
-            return int(h * crop_h + 0.5), int(w * crop_w + 0.5)
-
-    def __call__(self, results):
-        """Call function to randomly crop images, bounding boxes, masks,
-        semantic segmentation maps.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Randomly cropped results, 'img_shape' key in result dict is
-                updated according to crop size.
-        """
-        image_size = results['img'].shape[:2]
-        crop_size = self._get_crop_size(image_size)
-        results = self._crop_data(results, crop_size, self.allow_negative_crop)
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(crop_size={self.crop_size}, '
-        repr_str += f'crop_type={self.crop_type}, '
-        repr_str += f'allow_negative_crop={self.allow_negative_crop}, '
-        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class SegRescale(object):
-    """Rescale semantic segmentation maps.
-
-    Args:
-        scale_factor (float): The scale factor of the final output.
-        backend (str): Image rescale backend, choices are 'cv2' and 'pillow'.
-            These two backends generates slightly different results. Defaults
-            to 'cv2'.
-    """
-
-    def __init__(self, scale_factor=1, backend='cv2'):
-        self.scale_factor = scale_factor
-        self.backend = backend
-
-    def __call__(self, results):
-        """Call function to scale the semantic segmentation map.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Result dict with semantic segmentation map scaled.
-        """
-
-        for key in results.get('seg_fields', []):
-            if self.scale_factor != 1:
-                results[key] = mmcv.imrescale(
-                    results[key],
-                    self.scale_factor,
-                    interpolation='nearest',
-                    backend=self.backend)
-        return results
-
-    def __repr__(self):
-        return self.__class__.__name__ + f'(scale_factor={self.scale_factor})'
-
-
-@PIPELINES.register_module()
-class PhotoMetricDistortion(object):
-    """Apply photometric distortion to image sequentially, every transformation
-    is applied with a probability of 0.5. The position of random contrast is in
-    second or second to last.
-
-    1. random brightness
-    2. random contrast (mode 0)
-    3. convert color from BGR to HSV
-    4. random saturation
-    5. random hue
-    6. convert color from HSV to BGR
-    7. random contrast (mode 1)
-    8. randomly swap channels
-
-    Args:
-        brightness_delta (int): delta of brightness.
-        contrast_range (tuple): range of contrast.
-        saturation_range (tuple): range of saturation.
-        hue_delta (int): delta of hue.
-    """
-
-    def __init__(self,
-                 brightness_delta=32,
-                 contrast_range=(0.5, 1.5),
-                 saturation_range=(0.5, 1.5),
-                 hue_delta=18):
-        self.brightness_delta = brightness_delta
-        self.contrast_lower, self.contrast_upper = contrast_range
-        self.saturation_lower, self.saturation_upper = saturation_range
-        self.hue_delta = hue_delta
-
-    def __call__(self, results):
-        """Call function to perform photometric distortion on images.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Result dict with images distorted.
-        """
-
-        if 'img_fields' in results:
-            assert results['img_fields'] == ['img'], \
-                'Only single img_fields is allowed'
-        img = results['img']
-        assert img.dtype == np.float32, \
-            'PhotoMetricDistortion needs the input image of dtype np.float32,'\
-            ' please set "to_float32=True" in "LoadImageFromFile" pipeline'
-        # random brightness
-        if random.randint(2):
-            delta = random.uniform(-self.brightness_delta,
-                                   self.brightness_delta)
-            img += delta
-
-        # mode == 0 --> do random contrast first
-        # mode == 1 --> do random contrast last
-        mode = random.randint(2)
-        if mode == 1:
-            if random.randint(2):
-                alpha = random.uniform(self.contrast_lower,
-                                       self.contrast_upper)
-                img *= alpha
-
-        # convert color from BGR to HSV
-        img = mmcv.bgr2hsv(img)
-
-        # random saturation
-        if random.randint(2):
-            img[..., 1] *= random.uniform(self.saturation_lower,
-                                          self.saturation_upper)
-
-        # random hue
-        if random.randint(2):
-            img[..., 0] += random.uniform(-self.hue_delta, self.hue_delta)
-            img[..., 0][img[..., 0] > 360] -= 360
-            img[..., 0][img[..., 0] < 0] += 360
-
-        # convert color from HSV to BGR
-        img = mmcv.hsv2bgr(img)
-
-        # random contrast
-        if mode == 0:
-            if random.randint(2):
-                alpha = random.uniform(self.contrast_lower,
-                                       self.contrast_upper)
-                img *= alpha
-
-        # randomly swap channels
-        if random.randint(2):
-            img = img[..., random.permutation(3)]
-
-        results['img'] = img
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(\nbrightness_delta={self.brightness_delta},\n'
-        repr_str += 'contrast_range='
-        repr_str += f'{(self.contrast_lower, self.contrast_upper)},\n'
-        repr_str += 'saturation_range='
-        repr_str += f'{(self.saturation_lower, self.saturation_upper)},\n'
-        repr_str += f'hue_delta={self.hue_delta})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class Expand(object):
-    """Random expand the image & bboxes.
-
-    Randomly place the original image on a canvas of 'ratio' x original image
-    size filled with mean values. The ratio is in the range of ratio_range.
-
-    Args:
-        mean (tuple): mean value of dataset.
-        to_rgb (bool): if need to convert the order of mean to align with RGB.
-        ratio_range (tuple): range of expand ratio.
-        prob (float): probability of applying this transformation
-    """
-
-    def __init__(self,
-                 mean=(0, 0, 0),
-                 to_rgb=True,
-                 ratio_range=(1, 4),
-                 seg_ignore_label=None,
-                 prob=0.5):
-        self.to_rgb = to_rgb
-        self.ratio_range = ratio_range
-        if to_rgb:
-            self.mean = mean[::-1]
-        else:
-            self.mean = mean
-        self.min_ratio, self.max_ratio = ratio_range
-        self.seg_ignore_label = seg_ignore_label
-        self.prob = prob
-
-    def __call__(self, results):
-        """Call function to expand images, bounding boxes.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Result dict with images, bounding boxes expanded
-        """
-
-        if random.uniform(0, 1) > self.prob:
-            return results
-
-        if 'img_fields' in results:
-            assert results['img_fields'] == ['img'], \
-                'Only single img_fields is allowed'
-        img = results['img']
-
-        h, w, c = img.shape
-        ratio = random.uniform(self.min_ratio, self.max_ratio)
-        # speedup expand when meets large image
-        if np.all(self.mean == self.mean[0]):
-            expand_img = np.empty((int(h * ratio), int(w * ratio), c),
-                                  img.dtype)
-            expand_img.fill(self.mean[0])
-        else:
-            expand_img = np.full((int(h * ratio), int(w * ratio), c),
-                                 self.mean,
-                                 dtype=img.dtype)
-        left = int(random.uniform(0, w * ratio - w))
-        top = int(random.uniform(0, h * ratio - h))
-        expand_img[top:top + h, left:left + w] = img
-
-        results['img'] = expand_img
-        # expand bboxes
-        for key in results.get('bbox_fields', []):
-            results[key] = results[key] + np.tile(
-                (left, top), 2).astype(results[key].dtype)
-
-        # expand masks
-        for key in results.get('mask_fields', []):
-            results[key] = results[key].expand(
-                int(h * ratio), int(w * ratio), top, left)
-
-        # expand segs
-        for key in results.get('seg_fields', []):
-            gt_seg = results[key]
-            expand_gt_seg = np.full((int(h * ratio), int(w * ratio)),
-                                    self.seg_ignore_label,
-                                    dtype=gt_seg.dtype)
-            expand_gt_seg[top:top + h, left:left + w] = gt_seg
-            results[key] = expand_gt_seg
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(mean={self.mean}, to_rgb={self.to_rgb}, '
-        repr_str += f'ratio_range={self.ratio_range}, '
-        repr_str += f'seg_ignore_label={self.seg_ignore_label})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class MinIoURandomCrop(object):
-    """Random crop the image & bboxes, the cropped patches have minimum IoU
-    requirement with original image & bboxes, the IoU threshold is randomly
-    selected from min_ious.
-
-    Args:
-        min_ious (tuple): minimum IoU threshold for all intersections with
-        bounding boxes
-        min_crop_size (float): minimum crop's size (i.e. h,w := a*h, a*w,
-        where a >= min_crop_size).
-        bbox_clip_border (bool, optional): Whether clip the objects outside
-            the border of the image. Defaults to True.
-
-    Note:
-        The keys for bboxes, labels and masks should be paired. That is, \
-        `gt_bboxes` corresponds to `gt_labels` and `gt_masks`, and \
-        `gt_bboxes_ignore` to `gt_labels_ignore` and `gt_masks_ignore`.
-    """
-
-    def __init__(self,
-                 min_ious=(0.1, 0.3, 0.5, 0.7, 0.9),
-                 min_crop_size=0.3,
-                 bbox_clip_border=True):
-        # 1: return ori img
-        self.min_ious = min_ious
-        self.sample_mode = (1, *min_ious, 0)
-        self.min_crop_size = min_crop_size
-        self.bbox_clip_border = bbox_clip_border
-        self.bbox2label = {
-            'gt_bboxes': 'gt_labels',
-            'gt_bboxes_ignore': 'gt_labels_ignore'
-        }
-        self.bbox2mask = {
-            'gt_bboxes': 'gt_masks',
-            'gt_bboxes_ignore': 'gt_masks_ignore'
-        }
-
-    def __call__(self, results):
-        """Call function to crop images and bounding boxes with minimum IoU
-        constraint.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Result dict with images and bounding boxes cropped, \
-                'img_shape' key is updated.
-        """
-
-        if 'img_fields' in results:
-            assert results['img_fields'] == ['img'], \
-                'Only single img_fields is allowed'
-        img = results['img']
-        assert 'bbox_fields' in results
-        boxes = [results[key] for key in results['bbox_fields']]
-        boxes = np.concatenate(boxes, 0)
-        h, w, c = img.shape
-        while True:
-            mode = random.choice(self.sample_mode)
-            self.mode = mode
-            if mode == 1:
-                return results
-
-            min_iou = mode
-            for i in range(50):
-                new_w = random.uniform(self.min_crop_size * w, w)
-                new_h = random.uniform(self.min_crop_size * h, h)
-
-                # h / w in [0.5, 2]
-                if new_h / new_w < 0.5 or new_h / new_w > 2:
-                    continue
-
-                left = random.uniform(w - new_w)
-                top = random.uniform(h - new_h)
-
-                patch = np.array(
-                    (int(left), int(top), int(left + new_w), int(top + new_h)))
-                # Line or point crop is not allowed
-                if patch[2] == patch[0] or patch[3] == patch[1]:
-                    continue
-                overlaps = bbox_overlaps(
-                    patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1)
-                if len(overlaps) > 0 and overlaps.min() < min_iou:
-                    continue
-
-                # center of boxes should inside the crop img
-                # only adjust boxes and instance masks when the gt is not empty
-                if len(overlaps) > 0:
-                    # adjust boxes
-                    def is_center_of_bboxes_in_patch(boxes, patch):
-                        center = (boxes[:, :2] + boxes[:, 2:]) / 2
-                        mask = ((center[:, 0] > patch[0]) *
-                                (center[:, 1] > patch[1]) *
-                                (center[:, 0] < patch[2]) *
-                                (center[:, 1] < patch[3]))
-                        return mask
-
-                    mask = is_center_of_bboxes_in_patch(boxes, patch)
-                    if not mask.any():
-                        continue
-                    for key in results.get('bbox_fields', []):
-                        boxes = results[key].copy()
-                        mask = is_center_of_bboxes_in_patch(boxes, patch)
-                        boxes = boxes[mask]
-                        if self.bbox_clip_border:
-                            boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:])
-                            boxes[:, :2] = boxes[:, :2].clip(min=patch[:2])
-                        boxes -= np.tile(patch[:2], 2)
-
-                        results[key] = boxes
-                        # labels
-                        label_key = self.bbox2label.get(key)
-                        if label_key in results:
-                            results[label_key] = results[label_key][mask]
-
-                        # mask fields
-                        mask_key = self.bbox2mask.get(key)
-                        if mask_key in results:
-                            results[mask_key] = results[mask_key][
-                                mask.nonzero()[0]].crop(patch)
-                # adjust the img no matter whether the gt is empty before crop
-                img = img[patch[1]:patch[3], patch[0]:patch[2]]
-                results['img'] = img
-                results['img_shape'] = img.shape
-
-                # seg fields
-                for key in results.get('seg_fields', []):
-                    results[key] = results[key][patch[1]:patch[3],
-                                                patch[0]:patch[2]]
-                return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(min_ious={self.min_ious}, '
-        repr_str += f'min_crop_size={self.min_crop_size}, '
-        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class Corrupt(object):
-    """Corruption augmentation.
-
-    Corruption transforms implemented based on
-    `imagecorruptions <https://github.com/bethgelab/imagecorruptions>`_.
-
-    Args:
-        corruption (str): Corruption name.
-        severity (int, optional): The severity of corruption. Default: 1.
-    """
-
-    def __init__(self, corruption, severity=1):
-        self.corruption = corruption
-        self.severity = severity
-
-    def __call__(self, results):
-        """Call function to corrupt image.
-
-        Args:
-            results (dict): Result dict from loading pipeline.
-
-        Returns:
-            dict: Result dict with images corrupted.
-        """
-
-        if corrupt is None:
-            raise RuntimeError('imagecorruptions is not installed')
-        if 'img_fields' in results:
-            assert results['img_fields'] == ['img'], \
-                'Only single img_fields is allowed'
-        results['img'] = corrupt(
-            results['img'].astype(np.uint8),
-            corruption_name=self.corruption,
-            severity=self.severity)
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(corruption={self.corruption}, '
-        repr_str += f'severity={self.severity})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class Albu(object):
-    """Albumentation augmentation.
-
-    Adds custom transformations from Albumentations library.
-    Please, visit `https://albumentations.readthedocs.io`
-    to get more information.
-
-    An example of ``transforms`` is as followed:
-
-    .. code-block::
-
-        [
-            dict(
-                type='ShiftScaleRotate',
-                shift_limit=0.0625,
-                scale_limit=0.0,
-                rotate_limit=0,
-                interpolation=1,
-                p=0.5),
-            dict(
-                type='RandomBrightnessContrast',
-                brightness_limit=[0.1, 0.3],
-                contrast_limit=[0.1, 0.3],
-                p=0.2),
-            dict(type='ChannelShuffle', p=0.1),
-            dict(
-                type='OneOf',
-                transforms=[
-                    dict(type='Blur', blur_limit=3, p=1.0),
-                    dict(type='MedianBlur', blur_limit=3, p=1.0)
-                ],
-                p=0.1),
-        ]
-
-    Args:
-        transforms (list[dict]): A list of albu transformations
-        bbox_params (dict): Bbox_params for albumentation `Compose`
-        keymap (dict): Contains {'input key':'albumentation-style key'}
-        skip_img_without_anno (bool): Whether to skip the image if no ann left
-            after aug
-    """
-
-    def __init__(self,
-                 transforms,
-                 bbox_params=None,
-                 keymap=None,
-                 update_pad_shape=False,
-                 skip_img_without_anno=False):
-        if Compose is None:
-            raise RuntimeError('albumentations is not installed')
-
-        # Args will be modified later, copying it will be safer
-        transforms = copy.deepcopy(transforms)
-        if bbox_params is not None:
-            bbox_params = copy.deepcopy(bbox_params)
-        if keymap is not None:
-            keymap = copy.deepcopy(keymap)
-        self.transforms = transforms
-        self.filter_lost_elements = False
-        self.update_pad_shape = update_pad_shape
-        self.skip_img_without_anno = skip_img_without_anno
-
-        # A simple workaround to remove masks without boxes
-        if (isinstance(bbox_params, dict) and 'label_fields' in bbox_params
-                and 'filter_lost_elements' in bbox_params):
-            self.filter_lost_elements = True
-            self.origin_label_fields = bbox_params['label_fields']
-            bbox_params['label_fields'] = ['idx_mapper']
-            del bbox_params['filter_lost_elements']
-
-        self.bbox_params = (
-            self.albu_builder(bbox_params) if bbox_params else None)
-        self.aug = Compose([self.albu_builder(t) for t in self.transforms],
-                           bbox_params=self.bbox_params)
-
-        if not keymap:
-            self.keymap_to_albu = {
-                'img': 'image',
-                'gt_masks': 'masks',
-                'gt_bboxes': 'bboxes'
-            }
-        else:
-            self.keymap_to_albu = keymap
-        self.keymap_back = {v: k for k, v in self.keymap_to_albu.items()}
-
-    def albu_builder(self, cfg):
-        """Import a module from albumentations.
-
-        It inherits some of :func:`build_from_cfg` logic.
-
-        Args:
-            cfg (dict): Config dict. It should at least contain the key "type".
-
-        Returns:
-            obj: The constructed object.
-        """
-
-        assert isinstance(cfg, dict) and 'type' in cfg
-        args = cfg.copy()
-
-        obj_type = args.pop('type')
-        if mmcv.is_str(obj_type):
-            if albumentations is None:
-                raise RuntimeError('albumentations is not installed')
-            obj_cls = getattr(albumentations, obj_type)
-        elif inspect.isclass(obj_type):
-            obj_cls = obj_type
-        else:
-            raise TypeError(
-                f'type must be a str or valid type, but got {type(obj_type)}')
-
-        if 'transforms' in args:
-            args['transforms'] = [
-                self.albu_builder(transform)
-                for transform in args['transforms']
-            ]
-
-        return obj_cls(**args)
-
-    @staticmethod
-    def mapper(d, keymap):
-        """Dictionary mapper. Renames keys according to keymap provided.
-
-        Args:
-            d (dict): old dict
-            keymap (dict): {'old_key':'new_key'}
-        Returns:
-            dict: new dict.
-        """
-
-        updated_dict = {}
-        for k, v in zip(d.keys(), d.values()):
-            new_k = keymap.get(k, k)
-            updated_dict[new_k] = d[k]
-        return updated_dict
-
-    def __call__(self, results):
-        # dict to albumentations format
-        results = self.mapper(results, self.keymap_to_albu)
-        # TODO: add bbox_fields
-        if 'bboxes' in results:
-            # to list of boxes
-            if isinstance(results['bboxes'], np.ndarray):
-                results['bboxes'] = [x for x in results['bboxes']]
-            # add pseudo-field for filtration
-            if self.filter_lost_elements:
-                results['idx_mapper'] = np.arange(len(results['bboxes']))
-
-        # TODO: Support mask structure in albu
-        if 'masks' in results:
-            if isinstance(results['masks'], PolygonMasks):
-                raise NotImplementedError(
-                    'Albu only supports BitMap masks now')
-            ori_masks = results['masks']
-            if albumentations.__version__ < '0.5':
-                results['masks'] = results['masks'].masks
-            else:
-                results['masks'] = [mask for mask in results['masks'].masks]
-
-        results = self.aug(**results)
-
-        if 'bboxes' in results:
-            if isinstance(results['bboxes'], list):
-                results['bboxes'] = np.array(
-                    results['bboxes'], dtype=np.float32)
-            results['bboxes'] = results['bboxes'].reshape(-1, 4)
-
-            # filter label_fields
-            if self.filter_lost_elements:
-
-                for label in self.origin_label_fields:
-                    results[label] = np.array(
-                        [results[label][i] for i in results['idx_mapper']])
-                if 'masks' in results:
-                    results['masks'] = np.array(
-                        [results['masks'][i] for i in results['idx_mapper']])
-                    results['masks'] = ori_masks.__class__(
-                        results['masks'], results['image'].shape[0],
-                        results['image'].shape[1])
-
-                if (not len(results['idx_mapper'])
-                        and self.skip_img_without_anno):
-                    return None
-
-        if 'gt_labels' in results:
-            if isinstance(results['gt_labels'], list):
-                results['gt_labels'] = np.array(results['gt_labels'])
-            results['gt_labels'] = results['gt_labels'].astype(np.int64)
-
-        # back to the original format
-        results = self.mapper(results, self.keymap_back)
-
-        # update final shape
-        if self.update_pad_shape:
-            results['pad_shape'] = results['img'].shape
-
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__ + f'(transforms={self.transforms})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class RandomCenterCropPad(object):
-    """Random center crop and random around padding for CornerNet.
-
-    This operation generates randomly cropped image from the original image and
-    pads it simultaneously. Different from :class:`RandomCrop`, the output
-    shape may not equal to ``crop_size`` strictly. We choose a random value
-    from ``ratios`` and the output shape could be larger or smaller than
-    ``crop_size``. The padding operation is also different from :class:`Pad`,
-    here we use around padding instead of right-bottom padding.
-
-    The relation between output image (padding image) and original image:
-
-    .. code:: text
-
-                        output image
-
-               +----------------------------+
-               |          padded area       |
-        +------|----------------------------|----------+
-        |      |         cropped area       |          |
-        |      |         +---------------+  |          |
-        |      |         |    .   center |  |          | original image
-        |      |         |        range  |  |          |
-        |      |         +---------------+  |          |
-        +------|----------------------------|----------+
-               |          padded area       |
-               +----------------------------+
-
-    There are 5 main areas in the figure:
-
-    - output image: output image of this operation, also called padding
-      image in following instruction.
-    - original image: input image of this operation.
-    - padded area: non-intersect area of output image and original image.
-    - cropped area: the overlap of output image and original image.
-    - center range: a smaller area where random center chosen from.
-      center range is computed by ``border`` and original image's shape
-      to avoid our random center is too close to original image's border.
-
-    Also this operation act differently in train and test mode, the summary
-    pipeline is listed below.
-
-    Train pipeline:
-
-    1. Choose a ``random_ratio`` from ``ratios``, the shape of padding image
-       will be ``random_ratio * crop_size``.
-    2. Choose a ``random_center`` in center range.
-    3. Generate padding image with center matches the ``random_center``.
-    4. Initialize the padding image with pixel value equals to ``mean``.
-    5. Copy the cropped area to padding image.
-    6. Refine annotations.
-
-    Test pipeline:
-
-    1. Compute output shape according to ``test_pad_mode``.
-    2. Generate padding image with center matches the original image
-       center.
-    3. Initialize the padding image with pixel value equals to ``mean``.
-    4. Copy the ``cropped area`` to padding image.
-
-    Args:
-        crop_size (tuple | None): expected size after crop, final size will
-            computed according to ratio. Requires (h, w) in train mode, and
-            None in test mode.
-        ratios (tuple): random select a ratio from tuple and crop image to
-            (crop_size[0] * ratio) * (crop_size[1] * ratio).
-            Only available in train mode.
-        border (int): max distance from center select area to image border.
-            Only available in train mode.
-        mean (sequence): Mean values of 3 channels.
-        std (sequence): Std values of 3 channels.
-        to_rgb (bool): Whether to convert the image from BGR to RGB.
-        test_mode (bool): whether involve random variables in transform.
-            In train mode, crop_size is fixed, center coords and ratio is
-            random selected from predefined lists. In test mode, crop_size
-            is image's original shape, center coords and ratio is fixed.
-        test_pad_mode (tuple): padding method and padding shape value, only
-            available in test mode. Default is using 'logical_or' with
-            127 as padding shape value.
-
-            - 'logical_or': final_shape = input_shape | padding_shape_value
-            - 'size_divisor': final_shape = int(
-              ceil(input_shape / padding_shape_value) * padding_shape_value)
-        bbox_clip_border (bool, optional): Whether clip the objects outside
-            the border of the image. Defaults to True.
-    """
-
-    def __init__(self,
-                 crop_size=None,
-                 ratios=(0.9, 1.0, 1.1),
-                 border=128,
-                 mean=None,
-                 std=None,
-                 to_rgb=None,
-                 test_mode=False,
-                 test_pad_mode=('logical_or', 127),
-                 bbox_clip_border=True):
-        if test_mode:
-            assert crop_size is None, 'crop_size must be None in test mode'
-            assert ratios is None, 'ratios must be None in test mode'
-            assert border is None, 'border must be None in test mode'
-            assert isinstance(test_pad_mode, (list, tuple))
-            assert test_pad_mode[0] in ['logical_or', 'size_divisor']
-        else:
-            assert isinstance(crop_size, (list, tuple))
-            assert crop_size[0] > 0 and crop_size[1] > 0, (
-                'crop_size must > 0 in train mode')
-            assert isinstance(ratios, (list, tuple))
-            assert test_pad_mode is None, (
-                'test_pad_mode must be None in train mode')
-
-        self.crop_size = crop_size
-        self.ratios = ratios
-        self.border = border
-        # We do not set default value to mean, std and to_rgb because these
-        # hyper-parameters are easy to forget but could affect the performance.
-        # Please use the same setting as Normalize for performance assurance.
-        assert mean is not None and std is not None and to_rgb is not None
-        self.to_rgb = to_rgb
-        self.input_mean = mean
-        self.input_std = std
-        if to_rgb:
-            self.mean = mean[::-1]
-            self.std = std[::-1]
-        else:
-            self.mean = mean
-            self.std = std
-        self.test_mode = test_mode
-        self.test_pad_mode = test_pad_mode
-        self.bbox_clip_border = bbox_clip_border
-
-    def _get_border(self, border, size):
-        """Get final border for the target size.
-
-        This function generates a ``final_border`` according to image's shape.
-        The area between ``final_border`` and ``size - final_border`` is the
-        ``center range``. We randomly choose center from the ``center range``
-        to avoid our random center is too close to original image's border.
-        Also ``center range`` should be larger than 0.
-
-        Args:
-            border (int): The initial border, default is 128.
-            size (int): The width or height of original image.
-        Returns:
-            int: The final border.
-        """
-        k = 2 * border / size
-        i = pow(2, np.ceil(np.log2(np.ceil(k))) + (k == int(k)))
-        return border // i
-
-    def _filter_boxes(self, patch, boxes):
-        """Check whether the center of each box is in the patch.
-
-        Args:
-            patch (list[int]): The cropped area, [left, top, right, bottom].
-            boxes (numpy array, (N x 4)): Ground truth boxes.
-
-        Returns:
-            mask (numpy array, (N,)): Each box is inside or outside the patch.
-        """
-        center = (boxes[:, :2] + boxes[:, 2:]) / 2
-        mask = (center[:, 0] > patch[0]) * (center[:, 1] > patch[1]) * (
-            center[:, 0] < patch[2]) * (
-                center[:, 1] < patch[3])
-        return mask
-
-    def _crop_image_and_paste(self, image, center, size):
-        """Crop image with a given center and size, then paste the cropped
-        image to a blank image with two centers align.
-
-        This function is equivalent to generating a blank image with ``size``
-        as its shape. Then cover it on the original image with two centers (
-        the center of blank image and the random center of original image)
-        aligned. The overlap area is paste from the original image and the
-        outside area is filled with ``mean pixel``.
-
-        Args:
-            image (np array, H x W x C): Original image.
-            center (list[int]): Target crop center coord.
-            size (list[int]): Target crop size. [target_h, target_w]
-
-        Returns:
-            cropped_img (np array, target_h x target_w x C): Cropped image.
-            border (np array, 4): The distance of four border of
-                ``cropped_img`` to the original image area, [top, bottom,
-                left, right]
-            patch (list[int]): The cropped area, [left, top, right, bottom].
-        """
-        center_y, center_x = center
-        target_h, target_w = size
-        img_h, img_w, img_c = image.shape
-
-        x0 = max(0, center_x - target_w // 2)
-        x1 = min(center_x + target_w // 2, img_w)
-        y0 = max(0, center_y - target_h // 2)
-        y1 = min(center_y + target_h // 2, img_h)
-        patch = np.array((int(x0), int(y0), int(x1), int(y1)))
-
-        left, right = center_x - x0, x1 - center_x
-        top, bottom = center_y - y0, y1 - center_y
-
-        cropped_center_y, cropped_center_x = target_h // 2, target_w // 2
-        cropped_img = np.zeros((target_h, target_w, img_c), dtype=image.dtype)
-        for i in range(img_c):
-            cropped_img[:, :, i] += self.mean[i]
-        y_slice = slice(cropped_center_y - top, cropped_center_y + bottom)
-        x_slice = slice(cropped_center_x - left, cropped_center_x + right)
-        cropped_img[y_slice, x_slice, :] = image[y0:y1, x0:x1, :]
-
-        border = np.array([
-            cropped_center_y - top, cropped_center_y + bottom,
-            cropped_center_x - left, cropped_center_x + right
-        ],
-                          dtype=np.float32)
-
-        return cropped_img, border, patch
-
-    def _train_aug(self, results):
-        """Random crop and around padding the original image.
-
-        Args:
-            results (dict): Image infomations in the augment pipeline.
-
-        Returns:
-            results (dict): The updated dict.
-        """
-        img = results['img']
-        h, w, c = img.shape
-        boxes = results['gt_bboxes']
-        while True:
-            scale = random.choice(self.ratios)
-            new_h = int(self.crop_size[0] * scale)
-            new_w = int(self.crop_size[1] * scale)
-            h_border = self._get_border(self.border, h)
-            w_border = self._get_border(self.border, w)
-
-            for i in range(50):
-                center_x = random.randint(low=w_border, high=w - w_border)
-                center_y = random.randint(low=h_border, high=h - h_border)
-
-                cropped_img, border, patch = self._crop_image_and_paste(
-                    img, [center_y, center_x], [new_h, new_w])
-
-                mask = self._filter_boxes(patch, boxes)
-                # if image do not have valid bbox, any crop patch is valid.
-                if not mask.any() and len(boxes) > 0:
-                    continue
-
-                results['img'] = cropped_img
-                results['img_shape'] = cropped_img.shape
-                results['pad_shape'] = cropped_img.shape
-
-                x0, y0, x1, y1 = patch
-
-                left_w, top_h = center_x - x0, center_y - y0
-                cropped_center_x, cropped_center_y = new_w // 2, new_h // 2
-
-                # crop bboxes accordingly and clip to the image boundary
-                for key in results.get('bbox_fields', []):
-                    mask = self._filter_boxes(patch, results[key])
-                    bboxes = results[key][mask]
-                    bboxes[:, 0:4:2] += cropped_center_x - left_w - x0
-                    bboxes[:, 1:4:2] += cropped_center_y - top_h - y0
-                    if self.bbox_clip_border:
-                        bboxes[:, 0:4:2] = np.clip(bboxes[:, 0:4:2], 0, new_w)
-                        bboxes[:, 1:4:2] = np.clip(bboxes[:, 1:4:2], 0, new_h)
-                    keep = (bboxes[:, 2] > bboxes[:, 0]) & (
-                        bboxes[:, 3] > bboxes[:, 1])
-                    bboxes = bboxes[keep]
-                    results[key] = bboxes
-                    if key in ['gt_bboxes']:
-                        if 'gt_labels' in results:
-                            labels = results['gt_labels'][mask]
-                            labels = labels[keep]
-                            results['gt_labels'] = labels
-                        if 'gt_masks' in results:
-                            raise NotImplementedError(
-                                'RandomCenterCropPad only supports bbox.')
-
-                # crop semantic seg
-                for key in results.get('seg_fields', []):
-                    raise NotImplementedError(
-                        'RandomCenterCropPad only supports bbox.')
-                return results
-
-    def _test_aug(self, results):
-        """Around padding the original image without cropping.
-
-        The padding mode and value are from ``test_pad_mode``.
-
-        Args:
-            results (dict): Image infomations in the augment pipeline.
-
-        Returns:
-            results (dict): The updated dict.
-        """
-        img = results['img']
-        h, w, c = img.shape
-        results['img_shape'] = img.shape
-        if self.test_pad_mode[0] in ['logical_or']:
-            target_h = h | self.test_pad_mode[1]
-            target_w = w | self.test_pad_mode[1]
-        elif self.test_pad_mode[0] in ['size_divisor']:
-            divisor = self.test_pad_mode[1]
-            target_h = int(np.ceil(h / divisor)) * divisor
-            target_w = int(np.ceil(w / divisor)) * divisor
-        else:
-            raise NotImplementedError(
-                'RandomCenterCropPad only support two testing pad mode:'
-                'logical-or and size_divisor.')
-
-        cropped_img, border, _ = self._crop_image_and_paste(
-            img, [h // 2, w // 2], [target_h, target_w])
-        results['img'] = cropped_img
-        results['pad_shape'] = cropped_img.shape
-        results['border'] = border
-        return results
-
-    def __call__(self, results):
-        img = results['img']
-        assert img.dtype == np.float32, (
-            'RandomCenterCropPad needs the input image of dtype np.float32,'
-            ' please set "to_float32=True" in "LoadImageFromFile" pipeline')
-        h, w, c = img.shape
-        assert c == len(self.mean)
-        if self.test_mode:
-            return self._test_aug(results)
-        else:
-            return self._train_aug(results)
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(crop_size={self.crop_size}, '
-        repr_str += f'ratios={self.ratios}, '
-        repr_str += f'border={self.border}, '
-        repr_str += f'mean={self.input_mean}, '
-        repr_str += f'std={self.input_std}, '
-        repr_str += f'to_rgb={self.to_rgb}, '
-        repr_str += f'test_mode={self.test_mode}, '
-        repr_str += f'test_pad_mode={self.test_pad_mode}, '
-        repr_str += f'bbox_clip_border={self.bbox_clip_border})'
-        return repr_str
-
-
-@PIPELINES.register_module()
-class CutOut(object):
-    """CutOut operation.
-
-    Randomly drop some regions of image used in
-    `Cutout <https://arxiv.org/abs/1708.04552>`_.
-
-    Args:
-        n_holes (int | tuple[int, int]): Number of regions to be dropped.
-            If it is given as a list, number of holes will be randomly
-            selected from the closed interval [`n_holes[0]`, `n_holes[1]`].
-        cutout_shape (tuple[int, int] | list[tuple[int, int]]): The candidate
-            shape of dropped regions. It can be `tuple[int, int]` to use a
-            fixed cutout shape, or `list[tuple[int, int]]` to randomly choose
-            shape from the list.
-        cutout_ratio (tuple[float, float] | list[tuple[float, float]]): The
-            candidate ratio of dropped regions. It can be `tuple[float, float]`
-            to use a fixed ratio or `list[tuple[float, float]]` to randomly
-            choose ratio from the list. Please note that `cutout_shape`
-            and `cutout_ratio` cannot be both given at the same time.
-        fill_in (tuple[float, float, float] | tuple[int, int, int]): The value
-            of pixel to fill in the dropped regions. Default: (0, 0, 0).
-    """
-
-    def __init__(self,
-                 n_holes,
-                 cutout_shape=None,
-                 cutout_ratio=None,
-                 fill_in=(0, 0, 0)):
-
-        assert (cutout_shape is None) ^ (cutout_ratio is None), \
-            'Either cutout_shape or cutout_ratio should be specified.'
-        assert (isinstance(cutout_shape, (list, tuple))
-                or isinstance(cutout_ratio, (list, tuple)))
-        if isinstance(n_holes, tuple):
-            assert len(n_holes) == 2 and 0 <= n_holes[0] < n_holes[1]
-        else:
-            n_holes = (n_holes, n_holes)
-        self.n_holes = n_holes
-        self.fill_in = fill_in
-        self.with_ratio = cutout_ratio is not None
-        self.candidates = cutout_ratio if self.with_ratio else cutout_shape
-        if not isinstance(self.candidates, list):
-            self.candidates = [self.candidates]
-
-    def __call__(self, results):
-        """Call function to drop some regions of image."""
-        h, w, c = results['img'].shape
-        n_holes = np.random.randint(self.n_holes[0], self.n_holes[1] + 1)
-        for _ in range(n_holes):
-            x1 = np.random.randint(0, w)
-            y1 = np.random.randint(0, h)
-            index = np.random.randint(0, len(self.candidates))
-            if not self.with_ratio:
-                cutout_w, cutout_h = self.candidates[index]
-            else:
-                cutout_w = int(self.candidates[index][0] * w)
-                cutout_h = int(self.candidates[index][1] * h)
-
-            x2 = np.clip(x1 + cutout_w, 0, w)
-            y2 = np.clip(y1 + cutout_h, 0, h)
-            results['img'][y1:y2, x1:x2, :] = self.fill_in
-
-        return results
-
-    def __repr__(self):
-        repr_str = self.__class__.__name__
-        repr_str += f'(n_holes={self.n_holes}, '
-        repr_str += (f'cutout_ratio={self.candidates}, ' if self.with_ratio
-                     else f'cutout_shape={self.candidates}, ')
-        repr_str += f'fill_in={self.fill_in})'
-        return repr_str

spaces/CVPR/WALT/mmdet/models/utils/transformer.py

@@ -1,860 +0,0 @@
-import torch
-import torch.nn as nn
-from mmcv.cnn import (Linear, build_activation_layer, build_norm_layer,
-                      xavier_init)
-
-from .builder import TRANSFORMER
-
-
-class MultiheadAttention(nn.Module):
-    """A warpper for torch.nn.MultiheadAttention.
-
-    This module implements MultiheadAttention with residual connection,
-    and positional encoding used in DETR is also passed as input.
-
-    Args:
-        embed_dims (int): The embedding dimension.
-        num_heads (int): Parallel attention heads. Same as
-            `nn.MultiheadAttention`.
-        dropout (float): A Dropout layer on attn_output_weights. Default 0.0.
-    """
-
-    def __init__(self, embed_dims, num_heads, dropout=0.0):
-        super(MultiheadAttention, self).__init__()
-        assert embed_dims % num_heads == 0, 'embed_dims must be ' \
-            f'divisible by num_heads. got {embed_dims} and {num_heads}.'
-        self.embed_dims = embed_dims
-        self.num_heads = num_heads
-        self.dropout = dropout
-        self.attn = nn.MultiheadAttention(embed_dims, num_heads, dropout)
-        self.dropout = nn.Dropout(dropout)
-
-    def forward(self,
-                x,
-                key=None,
-                value=None,
-                residual=None,
-                query_pos=None,
-                key_pos=None,
-                attn_mask=None,
-                key_padding_mask=None):
-        """Forward function for `MultiheadAttention`.
-
-        Args:
-            x (Tensor): The input query with shape [num_query, bs,
-                embed_dims]. Same in `nn.MultiheadAttention.forward`.
-            key (Tensor): The key tensor with shape [num_key, bs,
-                embed_dims]. Same in `nn.MultiheadAttention.forward`.
-                Default None. If None, the `query` will be used.
-            value (Tensor): The value tensor with same shape as `key`.
-                Same in `nn.MultiheadAttention.forward`. Default None.
-                If None, the `key` will be used.
-            residual (Tensor): The tensor used for addition, with the
-                same shape as `x`. Default None. If None, `x` will be used.
-            query_pos (Tensor): The positional encoding for query, with
-                the same shape as `x`. Default None. If not None, it will
-                be added to `x` before forward function.
-            key_pos (Tensor): The positional encoding for `key`, with the
-                same shape as `key`. Default None. If not None, it will
-                be added to `key` before forward function. If None, and
-                `query_pos` has the same shape as `key`, then `query_pos`
-                will be used for `key_pos`.
-            attn_mask (Tensor): ByteTensor mask with shape [num_query,
-                num_key]. Same in `nn.MultiheadAttention.forward`.
-                Default None.
-            key_padding_mask (Tensor): ByteTensor with shape [bs, num_key].
-                Same in `nn.MultiheadAttention.forward`. Default None.
-
-        Returns:
-            Tensor: forwarded results with shape [num_query, bs, embed_dims].
-        """
-        query = x
-        if key is None:
-            key = query
-        if value is None:
-            value = key
-        if residual is None:
-            residual = x
-        if key_pos is None:
-            if query_pos is not None and key is not None:
-                if query_pos.shape == key.shape:
-                    key_pos = query_pos
-        if query_pos is not None:
-            query = query + query_pos
-        if key_pos is not None:
-            key = key + key_pos
-        out = self.attn(
-            query,
-            key,
-            value=value,
-            attn_mask=attn_mask,
-            key_padding_mask=key_padding_mask)[0]
-
-        return residual + self.dropout(out)
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(embed_dims={self.embed_dims}, '
-        repr_str += f'num_heads={self.num_heads}, '
-        repr_str += f'dropout={self.dropout})'
-        return repr_str
-
-
-class FFN(nn.Module):
-    """Implements feed-forward networks (FFNs) with residual connection.
-
-    Args:
-        embed_dims (int): The feature dimension. Same as
-            `MultiheadAttention`.
-        feedforward_channels (int): The hidden dimension of FFNs.
-        num_fcs (int, optional): The number of fully-connected layers in
-            FFNs. Defaults to 2.
-        act_cfg (dict, optional): The activation config for FFNs.
-        dropout (float, optional): Probability of an element to be
-            zeroed. Default 0.0.
-        add_residual (bool, optional): Add resudual connection.
-            Defaults to True.
-    """
-
-    def __init__(self,
-                 embed_dims,
-                 feedforward_channels,
-                 num_fcs=2,
-                 act_cfg=dict(type='ReLU', inplace=True),
-                 dropout=0.0,
-                 add_residual=True):
-        super(FFN, self).__init__()
-        assert num_fcs >= 2, 'num_fcs should be no less ' \
-            f'than 2. got {num_fcs}.'
-        self.embed_dims = embed_dims
-        self.feedforward_channels = feedforward_channels
-        self.num_fcs = num_fcs
-        self.act_cfg = act_cfg
-        self.dropout = dropout
-        self.activate = build_activation_layer(act_cfg)
-
-        layers = nn.ModuleList()
-        in_channels = embed_dims
-        for _ in range(num_fcs - 1):
-            layers.append(
-                nn.Sequential(
-                    Linear(in_channels, feedforward_channels), self.activate,
-                    nn.Dropout(dropout)))
-            in_channels = feedforward_channels
-        layers.append(Linear(feedforward_channels, embed_dims))
-        self.layers = nn.Sequential(*layers)
-        self.dropout = nn.Dropout(dropout)
-        self.add_residual = add_residual
-
-    def forward(self, x, residual=None):
-        """Forward function for `FFN`."""
-        out = self.layers(x)
-        if not self.add_residual:
-            return out
-        if residual is None:
-            residual = x
-        return residual + self.dropout(out)
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(embed_dims={self.embed_dims}, '
-        repr_str += f'feedforward_channels={self.feedforward_channels}, '
-        repr_str += f'num_fcs={self.num_fcs}, '
-        repr_str += f'act_cfg={self.act_cfg}, '
-        repr_str += f'dropout={self.dropout}, '
-        repr_str += f'add_residual={self.add_residual})'
-        return repr_str
-
-
-class TransformerEncoderLayer(nn.Module):
-    """Implements one encoder layer in DETR transformer.
-
-    Args:
-        embed_dims (int): The feature dimension. Same as `FFN`.
-        num_heads (int): Parallel attention heads.
-        feedforward_channels (int): The hidden dimension for FFNs.
-        dropout (float): Probability of an element to be zeroed. Default 0.0.
-        order (tuple[str]): The order for encoder layer. Valid examples are
-            ('selfattn', 'norm', 'ffn', 'norm') and ('norm', 'selfattn',
-            'norm', 'ffn'). Default ('selfattn', 'norm', 'ffn', 'norm').
-        act_cfg (dict): The activation config for FFNs. Default ReLU.
-        norm_cfg (dict): Config dict for normalization layer. Default
-            layer normalization.
-        num_fcs (int): The number of fully-connected layers for FFNs.
-            Default 2.
-    """
-
-    def __init__(self,
-                 embed_dims,
-                 num_heads,
-                 feedforward_channels,
-                 dropout=0.0,
-                 order=('selfattn', 'norm', 'ffn', 'norm'),
-                 act_cfg=dict(type='ReLU', inplace=True),
-                 norm_cfg=dict(type='LN'),
-                 num_fcs=2):
-        super(TransformerEncoderLayer, self).__init__()
-        assert isinstance(order, tuple) and len(order) == 4
-        assert set(order) == set(['selfattn', 'norm', 'ffn'])
-        self.embed_dims = embed_dims
-        self.num_heads = num_heads
-        self.feedforward_channels = feedforward_channels
-        self.dropout = dropout
-        self.order = order
-        self.act_cfg = act_cfg
-        self.norm_cfg = norm_cfg
-        self.num_fcs = num_fcs
-        self.pre_norm = order[0] == 'norm'
-        self.self_attn = MultiheadAttention(embed_dims, num_heads, dropout)
-        self.ffn = FFN(embed_dims, feedforward_channels, num_fcs, act_cfg,
-                       dropout)
-        self.norms = nn.ModuleList()
-        self.norms.append(build_norm_layer(norm_cfg, embed_dims)[1])
-        self.norms.append(build_norm_layer(norm_cfg, embed_dims)[1])
-
-    def forward(self, x, pos=None, attn_mask=None, key_padding_mask=None):
-        """Forward function for `TransformerEncoderLayer`.
-
-        Args:
-            x (Tensor): The input query with shape [num_key, bs,
-                embed_dims]. Same in `MultiheadAttention.forward`.
-            pos (Tensor): The positional encoding for query. Default None.
-                Same as `query_pos` in `MultiheadAttention.forward`.
-            attn_mask (Tensor): ByteTensor mask with shape [num_key,
-                num_key]. Same in `MultiheadAttention.forward`. Default None.
-            key_padding_mask (Tensor): ByteTensor with shape [bs, num_key].
-                Same in `MultiheadAttention.forward`. Default None.
-
-        Returns:
-            Tensor: forwarded results with shape [num_key, bs, embed_dims].
-        """
-        norm_cnt = 0
-        inp_residual = x
-        for layer in self.order:
-            if layer == 'selfattn':
-                # self attention
-                query = key = value = x
-                x = self.self_attn(
-                    query,
-                    key,
-                    value,
-                    inp_residual if self.pre_norm else None,
-                    query_pos=pos,
-                    key_pos=pos,
-                    attn_mask=attn_mask,
-                    key_padding_mask=key_padding_mask)
-                inp_residual = x
-            elif layer == 'norm':
-                x = self.norms[norm_cnt](x)
-                norm_cnt += 1
-            elif layer == 'ffn':
-                x = self.ffn(x, inp_residual if self.pre_norm else None)
-        return x
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(embed_dims={self.embed_dims}, '
-        repr_str += f'num_heads={self.num_heads}, '
-        repr_str += f'feedforward_channels={self.feedforward_channels}, '
-        repr_str += f'dropout={self.dropout}, '
-        repr_str += f'order={self.order}, '
-        repr_str += f'act_cfg={self.act_cfg}, '
-        repr_str += f'norm_cfg={self.norm_cfg}, '
-        repr_str += f'num_fcs={self.num_fcs})'
-        return repr_str
-
-
-class TransformerDecoderLayer(nn.Module):
-    """Implements one decoder layer in DETR transformer.
-
-    Args:
-        embed_dims (int): The feature dimension. Same as
-            `TransformerEncoderLayer`.
-        num_heads (int): Parallel attention heads.
-        feedforward_channels (int): Same as `TransformerEncoderLayer`.
-        dropout (float): Same as `TransformerEncoderLayer`. Default 0.0.
-        order (tuple[str]): The order for decoder layer. Valid examples are
-            ('selfattn', 'norm', 'multiheadattn', 'norm', 'ffn', 'norm') and
-            ('norm', 'selfattn', 'norm', 'multiheadattn', 'norm', 'ffn').
-            Default the former.
-        act_cfg (dict): Same as `TransformerEncoderLayer`. Default ReLU.
-        norm_cfg (dict): Config dict for normalization layer. Default
-            layer normalization.
-        num_fcs (int): The number of fully-connected layers in FFNs.
-    """
-
-    def __init__(self,
-                 embed_dims,
-                 num_heads,
-                 feedforward_channels,
-                 dropout=0.0,
-                 order=('selfattn', 'norm', 'multiheadattn', 'norm', 'ffn',
-                        'norm'),
-                 act_cfg=dict(type='ReLU', inplace=True),
-                 norm_cfg=dict(type='LN'),
-                 num_fcs=2):
-        super(TransformerDecoderLayer, self).__init__()
-        assert isinstance(order, tuple) and len(order) == 6
-        assert set(order) == set(['selfattn', 'norm', 'multiheadattn', 'ffn'])
-        self.embed_dims = embed_dims
-        self.num_heads = num_heads
-        self.feedforward_channels = feedforward_channels
-        self.dropout = dropout
-        self.order = order
-        self.act_cfg = act_cfg
-        self.norm_cfg = norm_cfg
-        self.num_fcs = num_fcs
-        self.pre_norm = order[0] == 'norm'
-        self.self_attn = MultiheadAttention(embed_dims, num_heads, dropout)
-        self.multihead_attn = MultiheadAttention(embed_dims, num_heads,
-                                                 dropout)
-        self.ffn = FFN(embed_dims, feedforward_channels, num_fcs, act_cfg,
-                       dropout)
-        self.norms = nn.ModuleList()
-        # 3 norm layers in official DETR's TransformerDecoderLayer
-        for _ in range(3):
-            self.norms.append(build_norm_layer(norm_cfg, embed_dims)[1])
-
-    def forward(self,
-                x,
-                memory,
-                memory_pos=None,
-                query_pos=None,
-                memory_attn_mask=None,
-                target_attn_mask=None,
-                memory_key_padding_mask=None,
-                target_key_padding_mask=None):
-        """Forward function for `TransformerDecoderLayer`.
-
-        Args:
-            x (Tensor): Input query with shape [num_query, bs, embed_dims].
-            memory (Tensor): Tensor got from `TransformerEncoder`, with shape
-                [num_key, bs, embed_dims].
-            memory_pos (Tensor): The positional encoding for `memory`. Default
-                None. Same as `key_pos` in `MultiheadAttention.forward`.
-            query_pos (Tensor): The positional encoding for `query`. Default
-                None. Same as `query_pos` in `MultiheadAttention.forward`.
-            memory_attn_mask (Tensor): ByteTensor mask for `memory`, with
-                shape [num_key, num_key]. Same as `attn_mask` in
-                `MultiheadAttention.forward`. Default None.
-            target_attn_mask (Tensor): ByteTensor mask for `x`, with shape
-                [num_query, num_query]. Same as `attn_mask` in
-                `MultiheadAttention.forward`. Default None.
-            memory_key_padding_mask (Tensor): ByteTensor for `memory`, with
-                shape [bs, num_key]. Same as `key_padding_mask` in
-                `MultiheadAttention.forward`. Default None.
-            target_key_padding_mask (Tensor): ByteTensor for `x`, with shape
-                [bs, num_query]. Same as `key_padding_mask` in
-                `MultiheadAttention.forward`. Default None.
-
-        Returns:
-            Tensor: forwarded results with shape [num_query, bs, embed_dims].
-        """
-        norm_cnt = 0
-        inp_residual = x
-        for layer in self.order:
-            if layer == 'selfattn':
-                query = key = value = x
-                x = self.self_attn(
-                    query,
-                    key,
-                    value,
-                    inp_residual if self.pre_norm else None,
-                    query_pos,
-                    key_pos=query_pos,
-                    attn_mask=target_attn_mask,
-                    key_padding_mask=target_key_padding_mask)
-                inp_residual = x
-            elif layer == 'norm':
-                x = self.norms[norm_cnt](x)
-                norm_cnt += 1
-            elif layer == 'multiheadattn':
-                query = x
-                key = value = memory
-                x = self.multihead_attn(
-                    query,
-                    key,
-                    value,
-                    inp_residual if self.pre_norm else None,
-                    query_pos,
-                    key_pos=memory_pos,
-                    attn_mask=memory_attn_mask,
-                    key_padding_mask=memory_key_padding_mask)
-                inp_residual = x
-            elif layer == 'ffn':
-                x = self.ffn(x, inp_residual if self.pre_norm else None)
-        return x
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(embed_dims={self.embed_dims}, '
-        repr_str += f'num_heads={self.num_heads}, '
-        repr_str += f'feedforward_channels={self.feedforward_channels}, '
-        repr_str += f'dropout={self.dropout}, '
-        repr_str += f'order={self.order}, '
-        repr_str += f'act_cfg={self.act_cfg}, '
-        repr_str += f'norm_cfg={self.norm_cfg}, '
-        repr_str += f'num_fcs={self.num_fcs})'
-        return repr_str
-
-
-class TransformerEncoder(nn.Module):
-    """Implements the encoder in DETR transformer.
-
-    Args:
-        num_layers (int): The number of `TransformerEncoderLayer`.
-        embed_dims (int): Same as `TransformerEncoderLayer`.
-        num_heads (int): Same as `TransformerEncoderLayer`.
-        feedforward_channels (int): Same as `TransformerEncoderLayer`.
-        dropout (float): Same as `TransformerEncoderLayer`. Default 0.0.
-        order (tuple[str]): Same as `TransformerEncoderLayer`.
-        act_cfg (dict): Same as `TransformerEncoderLayer`. Default ReLU.
-        norm_cfg (dict): Same as `TransformerEncoderLayer`. Default
-            layer normalization.
-        num_fcs (int): Same as `TransformerEncoderLayer`. Default 2.
-    """
-
-    def __init__(self,
-                 num_layers,
-                 embed_dims,
-                 num_heads,
-                 feedforward_channels,
-                 dropout=0.0,
-                 order=('selfattn', 'norm', 'ffn', 'norm'),
-                 act_cfg=dict(type='ReLU', inplace=True),
-                 norm_cfg=dict(type='LN'),
-                 num_fcs=2):
-        super(TransformerEncoder, self).__init__()
-        assert isinstance(order, tuple) and len(order) == 4
-        assert set(order) == set(['selfattn', 'norm', 'ffn'])
-        self.num_layers = num_layers
-        self.embed_dims = embed_dims
-        self.num_heads = num_heads
-        self.feedforward_channels = feedforward_channels
-        self.dropout = dropout
-        self.order = order
-        self.act_cfg = act_cfg
-        self.norm_cfg = norm_cfg
-        self.num_fcs = num_fcs
-        self.pre_norm = order[0] == 'norm'
-        self.layers = nn.ModuleList()
-        for _ in range(num_layers):
-            self.layers.append(
-                TransformerEncoderLayer(embed_dims, num_heads,
-                                        feedforward_channels, dropout, order,
-                                        act_cfg, norm_cfg, num_fcs))
-        self.norm = build_norm_layer(norm_cfg,
-                                     embed_dims)[1] if self.pre_norm else None
-
-    def forward(self, x, pos=None, attn_mask=None, key_padding_mask=None):
-        """Forward function for `TransformerEncoder`.
-
-        Args:
-            x (Tensor): Input query. Same in `TransformerEncoderLayer.forward`.
-            pos (Tensor): Positional encoding for query. Default None.
-                Same in `TransformerEncoderLayer.forward`.
-            attn_mask (Tensor): ByteTensor attention mask. Default None.
-                Same in `TransformerEncoderLayer.forward`.
-            key_padding_mask (Tensor): Same in
-                `TransformerEncoderLayer.forward`. Default None.
-
-        Returns:
-            Tensor: Results with shape [num_key, bs, embed_dims].
-        """
-        for layer in self.layers:
-            x = layer(x, pos, attn_mask, key_padding_mask)
-        if self.norm is not None:
-            x = self.norm(x)
-        return x
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(num_layers={self.num_layers}, '
-        repr_str += f'embed_dims={self.embed_dims}, '
-        repr_str += f'num_heads={self.num_heads}, '
-        repr_str += f'feedforward_channels={self.feedforward_channels}, '
-        repr_str += f'dropout={self.dropout}, '
-        repr_str += f'order={self.order}, '
-        repr_str += f'act_cfg={self.act_cfg}, '
-        repr_str += f'norm_cfg={self.norm_cfg}, '
-        repr_str += f'num_fcs={self.num_fcs})'
-        return repr_str
-
-
-class TransformerDecoder(nn.Module):
-    """Implements the decoder in DETR transformer.
-
-    Args:
-        num_layers (int): The number of `TransformerDecoderLayer`.
-        embed_dims (int): Same as `TransformerDecoderLayer`.
-        num_heads (int): Same as `TransformerDecoderLayer`.
-        feedforward_channels (int): Same as `TransformerDecoderLayer`.
-        dropout (float): Same as `TransformerDecoderLayer`. Default 0.0.
-        order (tuple[str]): Same as `TransformerDecoderLayer`.
-        act_cfg (dict): Same as `TransformerDecoderLayer`. Default ReLU.
-        norm_cfg (dict): Same as `TransformerDecoderLayer`. Default
-            layer normalization.
-        num_fcs (int): Same as `TransformerDecoderLayer`. Default 2.
-    """
-
-    def __init__(self,
-                 num_layers,
-                 embed_dims,
-                 num_heads,
-                 feedforward_channels,
-                 dropout=0.0,
-                 order=('selfattn', 'norm', 'multiheadattn', 'norm', 'ffn',
-                        'norm'),
-                 act_cfg=dict(type='ReLU', inplace=True),
-                 norm_cfg=dict(type='LN'),
-                 num_fcs=2,
-                 return_intermediate=False):
-        super(TransformerDecoder, self).__init__()
-        assert isinstance(order, tuple) and len(order) == 6
-        assert set(order) == set(['selfattn', 'norm', 'multiheadattn', 'ffn'])
-        self.num_layers = num_layers
-        self.embed_dims = embed_dims
-        self.num_heads = num_heads
-        self.feedforward_channels = feedforward_channels
-        self.dropout = dropout
-        self.order = order
-        self.act_cfg = act_cfg
-        self.norm_cfg = norm_cfg
-        self.num_fcs = num_fcs
-        self.return_intermediate = return_intermediate
-        self.layers = nn.ModuleList()
-        for _ in range(num_layers):
-            self.layers.append(
-                TransformerDecoderLayer(embed_dims, num_heads,
-                                        feedforward_channels, dropout, order,
-                                        act_cfg, norm_cfg, num_fcs))
-        self.norm = build_norm_layer(norm_cfg, embed_dims)[1]
-
-    def forward(self,
-                x,
-                memory,
-                memory_pos=None,
-                query_pos=None,
-                memory_attn_mask=None,
-                target_attn_mask=None,
-                memory_key_padding_mask=None,
-                target_key_padding_mask=None):
-        """Forward function for `TransformerDecoder`.
-
-        Args:
-            x (Tensor): Input query. Same in `TransformerDecoderLayer.forward`.
-            memory (Tensor): Same in `TransformerDecoderLayer.forward`.
-            memory_pos (Tensor): Same in `TransformerDecoderLayer.forward`.
-                Default None.
-            query_pos (Tensor): Same in `TransformerDecoderLayer.forward`.
-                Default None.
-            memory_attn_mask (Tensor): Same in
-                `TransformerDecoderLayer.forward`. Default None.
-            target_attn_mask (Tensor): Same in
-                `TransformerDecoderLayer.forward`. Default None.
-            memory_key_padding_mask (Tensor): Same in
-                `TransformerDecoderLayer.forward`. Default None.
-            target_key_padding_mask (Tensor): Same in
-                `TransformerDecoderLayer.forward`. Default None.
-
-        Returns:
-            Tensor: Results with shape [num_query, bs, embed_dims].
-        """
-        intermediate = []
-        for layer in self.layers:
-            x = layer(x, memory, memory_pos, query_pos, memory_attn_mask,
-                      target_attn_mask, memory_key_padding_mask,
-                      target_key_padding_mask)
-            if self.return_intermediate:
-                intermediate.append(self.norm(x))
-        if self.norm is not None:
-            x = self.norm(x)
-            if self.return_intermediate:
-                intermediate.pop()
-                intermediate.append(x)
-        if self.return_intermediate:
-            return torch.stack(intermediate)
-        return x.unsqueeze(0)
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(num_layers={self.num_layers}, '
-        repr_str += f'embed_dims={self.embed_dims}, '
-        repr_str += f'num_heads={self.num_heads}, '
-        repr_str += f'feedforward_channels={self.feedforward_channels}, '
-        repr_str += f'dropout={self.dropout}, '
-        repr_str += f'order={self.order}, '
-        repr_str += f'act_cfg={self.act_cfg}, '
-        repr_str += f'norm_cfg={self.norm_cfg}, '
-        repr_str += f'num_fcs={self.num_fcs}, '
-        repr_str += f'return_intermediate={self.return_intermediate})'
-        return repr_str
-
-
-@TRANSFORMER.register_module()
-class Transformer(nn.Module):
-    """Implements the DETR transformer.
-
-    Following the official DETR implementation, this module copy-paste
-    from torch.nn.Transformer with modifications:
-
-        * positional encodings are passed in MultiheadAttention
-        * extra LN at the end of encoder is removed
-        * decoder returns a stack of activations from all decoding layers
-
-    See `paper: End-to-End Object Detection with Transformers
-    <https://arxiv.org/pdf/2005.12872>`_ for details.
-
-    Args:
-        embed_dims (int): The feature dimension.
-        num_heads (int): Parallel attention heads. Same as
-            `nn.MultiheadAttention`.
-        num_encoder_layers (int): Number of `TransformerEncoderLayer`.
-        num_decoder_layers (int): Number of `TransformerDecoderLayer`.
-        feedforward_channels (int): The hidden dimension for FFNs used in both
-            encoder and decoder.
-        dropout (float): Probability of an element to be zeroed. Default 0.0.
-        act_cfg (dict): Activation config for FFNs used in both encoder
-            and decoder. Default ReLU.
-        norm_cfg (dict): Config dict for normalization used in both encoder
-            and decoder. Default layer normalization.
-        num_fcs (int): The number of fully-connected layers in FFNs, which is
-            used for both encoder and decoder.
-        pre_norm (bool): Whether the normalization layer is ordered
-            first in the encoder and decoder. Default False.
-        return_intermediate_dec (bool): Whether to return the intermediate
-            output from each TransformerDecoderLayer or only the last
-            TransformerDecoderLayer. Default False. If False, the returned
-            `hs` has shape [num_decoder_layers, bs, num_query, embed_dims].
-            If True, the returned `hs` will have shape [1, bs, num_query,
-            embed_dims].
-    """
-
-    def __init__(self,
-                 embed_dims=512,
-                 num_heads=8,
-                 num_encoder_layers=6,
-                 num_decoder_layers=6,
-                 feedforward_channels=2048,
-                 dropout=0.0,
-                 act_cfg=dict(type='ReLU', inplace=True),
-                 norm_cfg=dict(type='LN'),
-                 num_fcs=2,
-                 pre_norm=False,
-                 return_intermediate_dec=False):
-        super(Transformer, self).__init__()
-        self.embed_dims = embed_dims
-        self.num_heads = num_heads
-        self.num_encoder_layers = num_encoder_layers
-        self.num_decoder_layers = num_decoder_layers
-        self.feedforward_channels = feedforward_channels
-        self.dropout = dropout
-        self.act_cfg = act_cfg
-        self.norm_cfg = norm_cfg
-        self.num_fcs = num_fcs
-        self.pre_norm = pre_norm
-        self.return_intermediate_dec = return_intermediate_dec
-        if self.pre_norm:
-            encoder_order = ('norm', 'selfattn', 'norm', 'ffn')
-            decoder_order = ('norm', 'selfattn', 'norm', 'multiheadattn',
-                             'norm', 'ffn')
-        else:
-            encoder_order = ('selfattn', 'norm', 'ffn', 'norm')
-            decoder_order = ('selfattn', 'norm', 'multiheadattn', 'norm',
-                             'ffn', 'norm')
-        self.encoder = TransformerEncoder(num_encoder_layers, embed_dims,
-                                          num_heads, feedforward_channels,
-                                          dropout, encoder_order, act_cfg,
-                                          norm_cfg, num_fcs)
-        self.decoder = TransformerDecoder(num_decoder_layers, embed_dims,
-                                          num_heads, feedforward_channels,
-                                          dropout, decoder_order, act_cfg,
-                                          norm_cfg, num_fcs,
-                                          return_intermediate_dec)
-
-    def init_weights(self, distribution='uniform'):
-        """Initialize the transformer weights."""
-        # follow the official DETR to init parameters
-        for m in self.modules():
-            if hasattr(m, 'weight') and m.weight.dim() > 1:
-                xavier_init(m, distribution=distribution)
-
-    def forward(self, x, mask, query_embed, pos_embed):
-        """Forward function for `Transformer`.
-
-        Args:
-            x (Tensor): Input query with shape [bs, c, h, w] where
-                c = embed_dims.
-            mask (Tensor): The key_padding_mask used for encoder and decoder,
-                with shape [bs, h, w].
-            query_embed (Tensor): The query embedding for decoder, with shape
-                [num_query, c].
-            pos_embed (Tensor): The positional encoding for encoder and
-                decoder, with the same shape as `x`.
-
-        Returns:
-            tuple[Tensor]: results of decoder containing the following tensor.
-
-                - out_dec: Output from decoder. If return_intermediate_dec \
-                      is True output has shape [num_dec_layers, bs,
-                      num_query, embed_dims], else has shape [1, bs, \
-                      num_query, embed_dims].
-                - memory: Output results from encoder, with shape \
-                      [bs, embed_dims, h, w].
-        """
-        bs, c, h, w = x.shape
-        x = x.flatten(2).permute(2, 0, 1)  # [bs, c, h, w] -> [h*w, bs, c]
-        pos_embed = pos_embed.flatten(2).permute(2, 0, 1)
-        query_embed = query_embed.unsqueeze(1).repeat(
-            1, bs, 1)  # [num_query, dim] -> [num_query, bs, dim]
-        mask = mask.flatten(1)  # [bs, h, w] -> [bs, h*w]
-        memory = self.encoder(
-            x, pos=pos_embed, attn_mask=None, key_padding_mask=mask)
-        target = torch.zeros_like(query_embed)
-        # out_dec: [num_layers, num_query, bs, dim]
-        out_dec = self.decoder(
-            target,
-            memory,
-            memory_pos=pos_embed,
-            query_pos=query_embed,
-            memory_attn_mask=None,
-            target_attn_mask=None,
-            memory_key_padding_mask=mask,
-            target_key_padding_mask=None)
-        out_dec = out_dec.transpose(1, 2)
-        memory = memory.permute(1, 2, 0).reshape(bs, c, h, w)
-        return out_dec, memory
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(embed_dims={self.embed_dims}, '
-        repr_str += f'num_heads={self.num_heads}, '
-        repr_str += f'num_encoder_layers={self.num_encoder_layers}, '
-        repr_str += f'num_decoder_layers={self.num_decoder_layers}, '
-        repr_str += f'feedforward_channels={self.feedforward_channels}, '
-        repr_str += f'dropout={self.dropout}, '
-        repr_str += f'act_cfg={self.act_cfg}, '
-        repr_str += f'norm_cfg={self.norm_cfg}, '
-        repr_str += f'num_fcs={self.num_fcs}, '
-        repr_str += f'pre_norm={self.pre_norm}, '
-        repr_str += f'return_intermediate_dec={self.return_intermediate_dec})'
-        return repr_str
-
-
-@TRANSFORMER.register_module()
-class DynamicConv(nn.Module):
-    """Implements Dynamic Convolution.
-
-    This module generate parameters for each sample and
-    use bmm to implement 1*1 convolution. Code is modified
-    from the `official github repo <https://github.com/PeizeSun/
-    SparseR-CNN/blob/main/projects/SparseRCNN/sparsercnn/head.py#L258>`_ .
-
-    Args:
-        in_channels (int): The input feature channel.
-            Defaults to 256.
-        feat_channels (int): The inner feature channel.
-            Defaults to 64.
-        out_channels (int, optional): The output feature channel.
-            When not specified, it will be set to `in_channels`
-            by default
-        input_feat_shape (int): The shape of input feature.
-            Defaults to 7.
-        act_cfg (dict): The activation config for DynamicConv.
-        norm_cfg (dict): Config dict for normalization layer. Default
-            layer normalization.
-    """
-
-    def __init__(self,
-                 in_channels=256,
-                 feat_channels=64,
-                 out_channels=None,
-                 input_feat_shape=7,
-                 act_cfg=dict(type='ReLU', inplace=True),
-                 norm_cfg=dict(type='LN')):
-        super(DynamicConv, self).__init__()
-        self.in_channels = in_channels
-        self.feat_channels = feat_channels
-        self.out_channels_raw = out_channels
-        self.input_feat_shape = input_feat_shape
-        self.act_cfg = act_cfg
-        self.norm_cfg = norm_cfg
-        self.out_channels = out_channels if out_channels else in_channels
-
-        self.num_params_in = self.in_channels * self.feat_channels
-        self.num_params_out = self.out_channels * self.feat_channels
-        self.dynamic_layer = nn.Linear(
-            self.in_channels, self.num_params_in + self.num_params_out)
-
-        self.norm_in = build_norm_layer(norm_cfg, self.feat_channels)[1]
-        self.norm_out = build_norm_layer(norm_cfg, self.out_channels)[1]
-
-        self.activation = build_activation_layer(act_cfg)
-
-        num_output = self.out_channels * input_feat_shape**2
-        self.fc_layer = nn.Linear(num_output, self.out_channels)
-        self.fc_norm = build_norm_layer(norm_cfg, self.out_channels)[1]
-
-    def forward(self, param_feature, input_feature):
-        """Forward function for `DynamicConv`.
-
-        Args:
-            param_feature (Tensor): The feature can be used
-                to generate the parameter, has shape
-                (num_all_proposals, in_channels).
-            input_feature (Tensor): Feature that
-                interact with parameters, has shape
-                (num_all_proposals, in_channels, H, W).
-
-        Returns:
-            Tensor: The output feature has shape
-            (num_all_proposals, out_channels).
-        """
-        num_proposals = param_feature.size(0)
-        input_feature = input_feature.view(num_proposals, self.in_channels,
-                                           -1).permute(2, 0, 1)
-
-        input_feature = input_feature.permute(1, 0, 2)
-        parameters = self.dynamic_layer(param_feature)
-
-        param_in = parameters[:, :self.num_params_in].view(
-            -1, self.in_channels, self.feat_channels)
-        param_out = parameters[:, -self.num_params_out:].view(
-            -1, self.feat_channels, self.out_channels)
-
-        # input_feature has shape (num_all_proposals, H*W, in_channels)
-        # param_in has shape (num_all_proposals, in_channels, feat_channels)
-        # feature has shape (num_all_proposals, H*W, feat_channels)
-        features = torch.bmm(input_feature, param_in)
-        features = self.norm_in(features)
-        features = self.activation(features)
-
-        # param_out has shape (batch_size, feat_channels, out_channels)
-        features = torch.bmm(features, param_out)
-        features = self.norm_out(features)
-        features = self.activation(features)
-
-        features = features.flatten(1)
-        features = self.fc_layer(features)
-        features = self.fc_norm(features)
-        features = self.activation(features)
-
-        return features
-
-    def __repr__(self):
-        """str: a string that describes the module"""
-        repr_str = self.__class__.__name__
-        repr_str += f'(in_channels={self.in_channels}, '
-        repr_str += f'feat_channels={self.feat_channels}, '
-        repr_str += f'out_channels={self.out_channels_raw}, '
-        repr_str += f'input_feat_shape={self.input_feat_shape}, '
-        repr_str += f'act_cfg={self.act_cfg}, '
-        repr_str += f'norm_cfg={self.norm_cfg})'
-        return repr_str

spaces/Chintan-Donda/KKMS-KSSW-HF/README.md

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

spaces/CikeyQI/Yunzai/Yunzai/lib/config/redis.js

@@ -1,76 +0,0 @@
-import cfg from "./config.js"
-import common from "../common/common.js"
-import { createClient } from "redis"
-import { exec } from "node:child_process"
-
-/**
- * 初始化全局redis客户端
- */
-export default async function redisInit() {
-  const rc = cfg.redis
-  const redisUn = rc.username || ""
-  let redisPw = rc.password ? `:${rc.password}` : ""
-  if (rc.username || rc.password)
-    redisPw += "@"
-  const redisUrl = `redis://${redisUn}${redisPw}${rc.host}:${rc.port}/${rc.db}`
-  let client = createClient({ url: redisUrl })
-
-  try {
-    logger.info(`正在连接 ${logger.blue(redisUrl)}`)
-    await client.connect()
-  } catch (err) {
-    logger.error(`Redis 错误：${logger.red(err)}`)
-
-    const cmd = "redis-server --save 900 1 --save 300 10 --daemonize yes" + await aarch64()
-    logger.info("正在启动 Redis...")
-    await execSync(cmd)
-    await common.sleep(1000)
-
-    try {
-      client = createClient({ url: redisUrl })
-      await client.connect()
-    } catch (err) {
-      logger.error(`Redis 错误：${logger.red(err)}`)
-      logger.error(`请先启动 Redis：${logger.blue(cmd)}`)
-      process.exit()
-    }
-  }
-
-  client.on("error", async err => {
-    logger.error(`Redis 错误：${logger.red(err)}`)
-    const cmd = "redis-server --save 900 1 --save 300 10 --daemonize yes" + await aarch64()
-    logger.error(`请先启动 Redis：${cmd}`)
-    process.exit()
-  })
-
-  /** 全局变量 redis */
-  global.redis = client
-  logger.info("Redis 连接成功")
-  return client
-}
-
-async function aarch64() {
-  if (process.platform == "win32")
-    return ""
-  /** 判断arch */
-  const arch = await execSync("uname -m")
-  if (arch.stdout && arch.stdout.includes("aarch64")) {
-    /** 判断redis版本 */
-    let v = await execSync("redis-server -v")
-    if (v.stdout) {
-      v = v.stdout.match(/v=(\d)./)
-      /** 忽略arm警告 */
-      if (v && v[1] >= 6)
-        return " --ignore-warnings ARM64-COW-BUG"
-    }
-  }
-  return ""
-}
-
-function execSync (cmd) {
-  return new Promise((resolve, reject) => {
-    exec(cmd, (error, stdout, stderr) => {
-      resolve({ error, stdout, stderr })
-    })
-  })
-}

spaces/Cletrason/Cletrason-toad-mario-movie/config.py

@@ -1 +0,0 @@
-save_memory = False

spaces/Crow34/Comicdraw/README.md

@@ -1,13 +0,0 @@
----
-title: Comicdraw
-emoji: 💻
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/DESUCLUB/BLLAMA/README.md

@@ -1,20 +0,0 @@
----
-license: apache-2.0
-title: 'BLLAMA: ALPACA with BLIP 2'
-sdk: gradio
-emoji: 🔥
-colorFrom: red
-colorTo: purple
-pinned: true
-app_file: generate.py
----
-## 🦙🌲🤏 BLLAMA: A BLIP2 + ALPACA-LORA Pipeline
-
-# Training
- This is just a pipeline involving the use of both ALPACA and BLIP-2, without any prior finetuning. You can refer to the details in ALPACA_LORA's repo [here](https://github.com/tloen/alpaca-lora) and the BLIP-2 training details on their GitHub page [here](https://github.com/salesforce/LAVIS/tree/main/projects/blip2). For the pipeline, I have used the BLIP-2 model found on HuggingSpace [here](https://huggingface.co/spaces/Salesforce/BLIP2)
-
-
-
-## Acknowledgements
-Once again, I would like to credit the Salesforce team for creating BLIP2, as well as tloen, the original creator of alpaca-lora. I would also like to credit Meta, the original 
-creators of LLAMA, as well as the people behind the HuggingFace implementation of ALPACA