Update parquet files (step 71 of 476)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Adobe CS6 Response Code Generator A Guide to Activate Your Software.md

@@ -1,140 +0,0 @@
-
-<h1>Adobe CS6 Response Code Generator: How to Activate Adobe Products Offline</h1>
- <p>If you are a creative professional or enthusiast who uses Adobe CS6 products, such as Photoshop, Illustrator, InDesign, and more, you may have encountered situations where you need to activate your software offline. This could be because you are traveling, have internet connection issues, or work in a secure environment where online activation is not possible.</p>
- <p>In this article, we will explain what is Adobe CS6 and why do you need a response code generator for offline activation. We will also show you how to generate a response code for Adobe CS6 offline activation using an internet-enabled device and your product's serial number. Finally, we will discuss the benefits and limitations of using a response code generator for Adobe CS6 offline activation.</p>
-<h2>adobe cs6 response code generator</h2><br /><p><b><b>Download Zip</b> &bull; <a href="https://byltly.com/2uKxK2">https://byltly.com/2uKxK2</a></b></p><br /><br />
- <h2>What is Adobe CS6 and why do you need a response code generator?</h2>
- <h3>Adobe CS6 is a suite of creative software products that includes Photoshop, Illustrator, InDesign, and more.</h3>
- <p>Adobe CS6 stands for Creative Suite 6, which is a collection of software products that enable you to create, edit, design, and publish various types of digital content. Some of the most popular products in Adobe CS6 are:</p>
- <ul>
-<li>Photoshop: A powerful image editing and manipulation tool that lets you create stunning graphics, photos, illustrations, and more.</li>
-<li>Illustrator: A vector-based drawing and design tool that lets you create logos, icons, typography, and more.</li>
-<li>InDesign: A layout and publishing tool that lets you create print and digital documents, such as books, magazines, flyers, and more.</li>
-<li>Dreamweaver: A web development tool that lets you create websites and web applications using HTML, CSS, JavaScript, and more.</li>
-<li>Premiere Pro: A video editing and production tool that lets you create professional-quality videos and movies.</li>
-<li>After Effects: A motion graphics and visual effects tool that lets you create animations, transitions, effects, and more for your videos.</li>
-</ul>
- <p>These are just some of the products in Adobe CS6. There are many more products that cater to different creative needs and workflows.</p>
- <h3>A response code generator is a tool that helps you activate Adobe products offline when you cannot connect to the internet or Adobe servers.</h3>
- <p>To use Adobe products, you need to activate them with your Adobe ID and password. This process verifies that you have a valid license for the product and prevents unauthorized use or piracy.</p>
- <p>Normally, this process is done online by connecting to the internet and signing in with your Adobe ID and password. However, there may be situations where you cannot connect to the internet or Adobe servers due to various reasons. For example:</p>
- <ul>
-<li>You are traveling and do not have access to a reliable internet connection.</li>
-<li>You have internet connection issues or network problems that prevent you from connecting to Adobe servers.</li>
-<li>You work in a secure environment like government, banking, etc. where online activation is not possible due to security policies or restrictions.</li>
-</ul>
- <p>In these situations, you need to use an alternative method of activation called offline activation. Offline activation allows you to activate your Adobe products without an internet connection or access to Adobe servers.</p>
-<p>adobe cs6 activation code generator online<br />
-adobe cs6 serial number generator mac<br />
-adobe cs6 master collection response code crack<br />
-adobe cs6 offline activation code generator<br />
-adobe cs6 keygen generator download<br />
-adobe cs6 license key generator free<br />
-adobe cs6 product code generator<br />
-adobe cs6 registration code generator<br />
-adobe cs6 authorization code generator windows<br />
-adobe cs6 activation code generator for pc<br />
-adobe cs6 serial number generator windows 10<br />
-adobe cs6 master collection response code keygen<br />
-adobe cs6 offline activation code generator mac<br />
-adobe cs6 keygen generator online free<br />
-adobe cs6 license key generator online<br />
-adobe cs6 product code generator mac<br />
-adobe cs6 registration code generator online<br />
-adobe cs6 authorization code generator mac<br />
-adobe cs6 activation code generator for mac<br />
-adobe cs6 serial number generator windows 7<br />
-adobe cs6 master collection response code generator online<br />
-adobe cs6 offline activation code generator windows 10<br />
-adobe cs6 keygen generator download free<br />
-adobe cs6 license key generator mac<br />
-adobe cs6 product code generator online free<br />
-adobe cs6 registration code generator mac<br />
-adobe cs6 authorization code generator windows 10<br />
-adobe cs6 activation code generator for windows 10<br />
-adobe cs6 serial number generator windows 8.1<br />
-adobe cs6 master collection response code crack download<br />
-adobe cs6 offline activation code generator windows 7<br />
-adobe cs6 keygen generator online no survey<br />
-adobe cs6 license key generator windows 10<br />
-adobe cs6 product code generator windows 10<br />
-adobe cs6 registration code generator windows 10<br />
-adobe cs6 authorization code generator windows 7<br />
-adobe cs6 activation code generator for windows 7<br />
-adobe cs6 serial number generator windows xp<br />
-adobe cs6 master collection response code hack<br />
-adobe cs6 offline activation code generator windows 8.1<br />
-adobe cs6 keygen generator free download no survey<br />
-adobe cs6 license key generator windows 7<br />
-adobe cs6 product code generator windows 7<br />
-adobe cs6 registration code generator windows 7<br />
-adobe cs6 authorization code generator windows 8.1<br />
-adobe cs6 activation code generator for windows 8.1<br />
-adobe cs6 serial number generator mac os x<br />
-adobe cs6 master collection response code bypass<br />
-adobe cs6 offline activation code generator mac os x<br />
-adobe cs6 keygen generator mac download</p>
- <p>To perform offline activation, you need a tool called a response code generator. A response code generator is a web page that helps you generate a unique code called a response code that you can use to activate your Adobe products offline.</p>
- <h2>How to generate a response code for Adobe CS6 offline activation?</h2>
- <h3>Step 1: Follow the installation or product launch screens until you see a link that says "I cannot connect to the internet" or "Having trouble connecting to the internet". Click the link and follow the instructions to generate a request code.</h3>
- <p>The first step of offline activation is to generate a request code on your offline computer where you want to use your Adobe product. A request code is another unique code that identifies your computer and product.</p>
- <p>To generate a request code:</p>
- <ol>
-<li>Install or launch your Adobe product on your offline computer as usual.</li>
-<li>Follow the installation or product launch screens until you see a link that says "I cannot connect to the internet" or "Having trouble connecting to the internet". Click the link.</li>
-<li>You will see a screen that asks you to enter your product's serial number. Enter it and click Next.</li>
-<li>You will see another screen that shows your request code. Write it down or copy it somewhere safe. You will need it later.</li>
-</ol>
- <h3>Step 2: Use an internet-enabled device to visit https://exception.licenses.adobe.com/aoes/aoes/v1/t1?locale=en and sign in with your Adobe ID and password. Enter the request code and your product's serial number to generate a response code.</h3>
- <p>The second step of offline activation is to generate a response code using an internet-enabled device such as another computer, a smartphone, or a tablet. A response code is the final code that you can use to activate your Adobe product offline.</p>
- <p>To generate a response code:</p>
- <ol>
-<li>Use an internet-enabled device to visit https://exception.licenses.adobe.com/aoes/aoes/v1/t1?locale=en</li>
-<li>Sign in with your Adobe ID and password. If you do not have an Adobe ID, you can create one for free by clicking Create an account.</li>
-<li>Enter the request code that you generated in step 1 and your product's serial number in the corresponding fields. Click Generate Response Code.</li>
-<li>You will see your response code on the screen. Write it down or copy it somewhere safe. You will need it later.</li>
-</ol>
- <h3>Step 3: Enter the response code on the installation or launch product screen of your offline computer when you are prompted to complete the offline activation process.</h3>
- <p>The third step of offline activation is to enter the response code on your offline computer where you want to use your Adobe product. This will complete the offline activation process and allow you to use your product normally.</p>
- <p>To enter the response code:</p>
- <ol>
-<li>Go back to your offline computer where you installed or launched your Adobe product in step 1.</li>
-<li>You should see a screen that prompts you to enter your response code. Enter it exactly as it appears and click Activate. This will complete the offline activation process and allow you to use your product normally.</li>
-</ol>
- <h2>What are the benefits of using a response code generator for Adobe CS6 offline activation?</h2>
- <h3>You can activate your Adobe products without an internet connection or access to Adobe servers.</h3>
- <p>One of the main benefits of using a response code generator for Adobe CS6 offline activation is that you can activate your Adobe products without an internet connection or access to Adobe servers. This means that you can use your products anytime and anywhere, even when you are offline or in a secure environment where online activation is not possible.</p>
- <h3>You can use your Adobe products on secure environments like government, banking, etc. where online activation is not possible.</h3>
- <p>Another benefit of using a response code generator for Adobe CS6 offline activation is that you can use your Adobe products on secure environments like government, banking, etc. where online activation is not possible due to security policies or restrictions. For example, if you work in a government agency or a bank that does not allow internet access or connection to external servers, you can still use your Adobe products by activating them offline using a response code generator.</p>
- <h3>You can avoid activation errors or issues that may occur due to network problems or server outages.</h3>
- <p>A third benefit of using a response code generator for Adobe CS6 offline activation is that you can avoid activation errors or issues that may occur due to network problems or server outages. For example, if you have a slow or unstable internet connection that prevents you from connecting to Adobe servers or completing the online activation process, you can still use your Adobe products by activating them offline using a response code generator. Similarly, if Adobe servers are down or undergoing maintenance, you can still use your Adobe products by activating them offline using a response code generator.</p>
- <h2>What are the limitations of using a response code generator for Adobe CS6 offline activation?</h2>
- <h3>You need an internet-enabled device and your product's serial number to generate a response code.</h3>
- <p>One of the limitations of using a response code generator for Adobe CS6 offline activation is that you need an internet-enabled device and your product's serial number to generate a response code. This means that you cannot activate your Adobe products offline without having access to another device that has internet access and your product's serial number. For example, if you lose your product's serial number or do not have another device that has internet access, you cannot generate a response code and activate your Adobe products offline.</p>
- <h3>You need to complete the offline activation within 7 days of the first launch of your Adobe product or it will stop working.</h3>
- <p>Another limitation of using a response code generator for Adobe CS6 offline activation is that you need to complete the offline activation within 7 days of the first launch of your Adobe product or it will stop working. This means that you cannot use your Adobe products indefinitely without connecting to the internet or Adobe servers at least once every 7 days. For example, if you travel for more than 7 days without internet access or access to Adobe servers, you will not be able to use your Adobe products until you complete the online activation and registration process.</p>
- <h3>The request code is machine-specific and valid for 72 hours. If it takes longer than 72 hours to complete the offline activation, you need to generate a new request code.</h3>
- <p>A third limitation of using a response code generator for Adobe CS6 offline activation is that the request code is machine-specific and valid for 72 hours. This means that you cannot use the same request code on different computers or after 72 hours have passed since you generated it. For example, if you want to activate your Adobe products on another computer or if it takes longer than 72 hours to generate a response code and enter it on your offline computer, you need to generate a new request code and repeat the offline activation process.</p>
- <h2>Conclusion</h2>
- <p>In this article, we have explained what is Adobe CS6 and why do you need a response code generator for offline activation. We have also shown you how to generate a response code for Adobe CS6 offline activation using an internet-enabled device and your product's serial number. Finally, we have discussed the benefits and limitations of using a response code generator for Adobe CS6 offline activation.</p>
- <p>We hope that this article has helped you understand how to activate your Adobe products offline using a response code generator. If you have any questions or feedback, please feel free to leave a comment below.</p>
- <h2>Frequently Asked Questions</h2>
- <ol>
-<li><b>What is the difference between online and offline activation?</b></li>
-<p>Online activation is the process of activating your Adobe products by connecting to the internet and signing in with your Adobe ID and password. Offline activation is the process of activating your Adobe products without an internet connection or access to Adobe servers by using a response code generator.</p>
-<li><b>Can I use both online and offline activation for my Adobe products?</b></li>
-<p>Yes, you can use both online and offline activation for your Adobe products depending on your situation and preference. However, you cannot use both methods simultaneously for the same product on the same computer.</p>
-<li><b>How many times can I use offline activation for my Adobe products?</b></li>
-<p>You can use offline activation for your Adobe products as many times as you need as long as you have an internet-enabled device and your product's serial number to generate a response code. However, each time you use offline activation, you need to generate a new request code and enter it on your offline computer within 72 hours.</p>
-<li><b>What happens if I lose my product's serial number or my response code?</b></li>
-<p>If you lose your product's serial number or your response code, you will not be able to activate your Adobe products offline until you find them again. If you lose your product's serial number, you can try to recover it by contacting Adobe customer support or by checking your email confirmation or receipt when you purchased the product. If you lose your response code, you can try to generate it again by visiting https://exception.licenses.adobe.com/aoes/aoes/v1/t1?locale=en and entering the request code and your product's serial number.</p>
-<li><b>What are some alternatives to using a response code generator for Adobe CS6 offline activation?</b></li>
-<p>Some alternatives to using a response code generator for Adobe CS6 offline activation are:</p>
-<ul>
-<li>Using an online connection: If possible, try to connect to the internet and complete the online activation and registration process instead of using the offline method.</li>
-<li>Using volume licensing: If you are an enterprise customer who needs to install and activate multiple copies of Adobe products on multiple computers in secure environments where online activation is not possible, consider using volume licensing instead of individual licensing. Volume licensing allows you to activate and manage your Adobe products using a single license key and an offline activation tool. For more information, visit https://www.adobe.com/volume-licensing.html.</li>
-<li>Using Creative Cloud: If you are a creative professional or enthusiast who wants to use the latest versions of Adobe products with more features and benefits, consider switching to Creative Cloud instead of using Adobe CS6. Creative Cloud is a subscription-based service that gives you access to all Adobe creative apps and services, as well as cloud storage, collaboration tools, and more. For more information, visit https://www.adobe.com/creativecloud.html.</li>
-</ul>
-</p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Crack Version of JR Typing Tutor A Risky and Unethical Choice.md

@@ -1,24 +0,0 @@
-
-<h1>How to Download Crack Version of JR Typing Tutor for Free</h1>
-<p>JR Typing Tutor is a software that helps you learn and improve your typing skills in Hindi, English, and other languages. It is specially designed for government typing tests, such as Allahabad High Court RO/ARO, UKPSC RO/ARO, UPPCL, CPCT, M.P. High Court, U.P. Computer Operator, IA, Rajasthan LDC, Tax Assistant, RSMSSB LDC Efficiency & Type Test. It also supports various fonts and keyboard layouts, such as DevLys010, KrutiDev010, Mangal, Raavi, Asees.</p>
-<h2>crack version of jr typing tutor</h2><br /><p><b><b>DOWNLOAD</b> &#127383; <a href="https://byltly.com/2uKvsb">https://byltly.com/2uKvsb</a></b></p><br /><br />
-<p>If you want to download JR Typing Tutor for free, you may be tempted to look for a crack version of the software. A crack version is a modified version of the software that bypasses the license verification and allows you to use it without paying. However, downloading a crack version of JR Typing Tutor is not a good idea for several reasons.</p>
-<h2>Why You Should Avoid Crack Version of JR Typing Tutor</h2>
-<p>Here are some of the risks and disadvantages of downloading a crack version of JR Typing Tutor:</p>
-<ul>
-<li><b>It is illegal.</b> Downloading a crack version of JR Typing Tutor is a violation of the software's terms and conditions and a form of piracy. You may face legal consequences if you are caught using or distributing a crack version of the software.</li>
-<li><b>It is unsafe.</b> Downloading a crack version of JR Typing Tutor may expose your computer to viruses, malware, spyware, or ransomware. These malicious programs can damage your system, steal your personal information, or lock your files until you pay a ransom. You may also lose your data or compromise your privacy if you use a crack version of the software.</li>
-<li><b>It is unreliable.</b> Downloading a crack version of JR Typing Tutor may not work properly or at all. You may encounter errors, bugs, crashes, or compatibility issues with your operating system or other software. You may also miss out on the latest features, updates, and support from the official website.</li>
-<li><b>It is unethical.</b> Downloading a crack version of JR Typing Tutor is unfair to the developers who have invested their time, money, and effort to create the software. You are depriving them of their rightful income and discouraging them from improving the software or creating new products.</li>
-</ul>
-<h2>How to Download JR Typing Tutor Legally</h2>
-<p>If you want to download JR Typing Tutor legally and safely, you have two options:</p>
-<ol>
-<li><b>Download a free trial.</b> You can download a free 14-day trial of JR Typing Tutor from the official website. This will allow you to test the software and see if it meets your needs and expectations. You can access all the features and functions of the software during the trial period.</li>
-<li><b>Buy a license.</b> If you are satisfied with the software and want to continue using it after the trial period, you can buy a license from the official website. The price of the license depends on the duration and number of users. You can choose from 1 month, 3 months, 6 months, 1 year, 2 years, 3 years, or lifetime licenses. You can also choose from single user or multi user licenses. Buying a license will give you unlimited access to the software and its updates and support.</li>
-</ol>
-<h2>Conclusion</h2>
-<p>JR Typing Tutor is a useful software that can help you learn and improve your typing skills in Hindi, English, and other languages. It is specially designed for government typing tests and supports various fonts and keyboard layouts. However, downloading a crack version of JR Typing Tutor is not advisable because it is illegal, unsafe, unreliable, and unethical. Instead, you should download a free trial or buy a license from the official website to enjoy the benefits of the software legally and safely.</p>
-<p></p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download HD Tune Pro The Ultimate Tool for HDD and SSD Optimization.md

@@ -1,28 +0,0 @@
-<br />
-<h1>How to Download HD Tune Pro and Why You Need It</h1>
-<p>HD Tune Pro is a powerful tool that can help you monitor, benchmark, and optimize your hard disk drives (HDDs) and solid state drives (SSDs). It can also scan for errors, check the health status (S.M.A.R.T.), securely erase all data, and more. In this article, we will show you how to download HD Tune Pro and what features it offers.</p>
-<h2>How to Download HD Tune Pro</h2>
-<p>HD Tune Pro is a paid software that costs $34.95 USD or 24.95 EUR for a single user license. You can purchase it from the official website at <a href="http://www.hdtune.com/download.html">http://www.hdtune.com/download.html</a>. After you complete the payment, you will receive a serial number that you can use to activate the software.</p>
-<h2>download hd tune pro</h2><br /><p><b><b>Download Zip</b> === <a href="https://byltly.com/2uKA0A">https://byltly.com/2uKA0A</a></b></p><br /><br />
-<p>If you want to try out the software before buying it, you can download a 15-day trial version from the same website. The trial version has all the features of the full version, except for the file benchmark and the folder usage view. You can also download an older version of HD Tune (2.55) for free, but it has fewer features and supports fewer operating systems.</p>
-<p>To install HD Tune Pro, you need to have Windows 2000, Windows XP, Windows Vista, Windows 7, Windows 8, or Windows 10. You also need to have a hard disk (internal or external), SSD, USB stick, or memory card reader. Note that some drives may not support all functions due to hardware limitations.</p>
-<h2>What Features Does HD Tune Pro Offer</h2>
-<p>HD Tune Pro offers many features that can help you test and improve the performance of your drives. Here are some of them:</p>
-<ul>
-<li><b>Benchmark</b>: This feature allows you to measure the read and write speed of your drives under different conditions. You can also compare the results with other drives or view them as graphs.</li>
-<li><b>Error Scan</b>: This feature allows you to scan your drives for bad sectors or other errors. You can also view the error log and save it as a text file.</li>
-<li><b>Health</b>: This feature allows you to check the health status of your drives using the S.M.A.R.T. (Self-Monitoring, Analysis, and Reporting Technology) system. You can also view the log file and run a self-test.</li>
-<li><b>Secure Erase</b>: This feature allows you to securely erase all data from your drives using various methods. This can prevent data recovery and protect your privacy.</li>
-<li><b>Disk Monitor</b>: This feature allows you to monitor the temperature, transfer rate, and access time of your drives in real-time. You can also set up alerts and warnings for critical values.</li>
-<li><b>AAM</b>: This feature allows you to adjust the Automatic Acoustic Management (AAM) setting of your drives. This can reduce the noise level or increase the performance of your drives.</li>
-<li><b>Command Line Parameters</b>: This feature allows you to run HD Tune Pro from a command prompt or a batch file with various parameters.</li>
-<li><b>File Benchmark</b>: This feature allows you to measure the read and write speed of files on your drives. You can also compare the results with other files or view them as graphs.</li>
-<li><b>Folder Usage</b>: This feature allows you to view how much space each folder occupies on your drives. You can also sort the folders by size or name.</li>
-<li><b>Extra Tests</b>: This feature allows you to run some extra tests on your drives, such as random access time, burst rate, CPU usage, etc.</li>
-<li><b>Cache Test</b>: This feature allows you to test the cache size and performance of your drives.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>HD Tune Pro is a comprehensive and reliable software that can help you monitor, benchmark, and optimize your hard disk drives and solid state drives. It can also scan for errors, check the health status, securely erase all data, and more. If you want to download HD Tune Pro, you can visit the official website at <a href="http://www.hdtune.com/download.html">http</p>
-<p></p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/HD Online Player (kokurikozaka kara 720p or 1080p) la storia romantica ambientata nella Yokohama degli anni 60.md

@@ -1,141 +0,0 @@
-<br />
-<h1>HD Online Player (kokurikozaka kara 720p or 1080p)</h1>
-<p>If you are a fan of Japanese animation, you might have heard of kokurikozaka kara, or From Up on Poppy Hill, a 2011 film by Studio Ghibli. This film is a beautiful and nostalgic story set in the 1960s, about a group of high school students who try to save their clubhouse from demolition. It is also a touching romance between two young people who discover a surprising connection.</p>
-<h2>HD Online Player (kokurikozaka kara 720p or 1080p)</h2><br /><p><b><b>Download File</b> &#10002; <a href="https://byltly.com/2uKvKx">https://byltly.com/2uKvKx</a></b></p><br /><br />
-<p>In this article, we will tell you everything you need to know about kokurikozaka kara, and how you can watch it online in high definition. We will also help you decide whether to choose 720p or 1080p resolution for your viewing pleasure. So, let's get started!</p>
- <h2>What is kokurikozaka kara?</h2>
-<p>Kokurikozaka kara, or From Up on Poppy Hill, is a Japanese animated drama film directed by Gorō Miyazaki, the son of the legendary Hayao Miyazaki. It is based on a manga series of the same name by Tetsurō Sayama and Chizuru Takahashi. It was produced by Studio Ghibli, the renowned animation studio behind classics like Spirited Away, My Neighbor Totoro, and Princess Mononoke.</p>
- <h3>A brief summary of the plot and characters</h3>
-<p>The film is set in 1963 Yokohama, Japan, a year before the Tokyo Olympics. The main character is Umi Matsuzaki, a 16-year-old girl who lives in a boarding house called Coquelicot Manor with her grandmother and younger siblings. Her father was a sailor who died in the Korean War, and her mother is a medical professor studying in the United States. Every morning, Umi raises a set of signal flags with the message "I pray for safe voyages" in honor of her father.</p>
-<p>One day, Umi meets Shun Kazama, a boy who writes for the school newspaper. He is also a member of the "Latin Quarter", an old building that houses various clubs and activities. The Latin Quarter is threatened with demolition by the school board, who wants to build a new modern building instead. Umi and Shun join forces with other students to clean up and renovate the Latin Quarter, hoping to persuade the board to reconsider.</p>
-<p>Watch From Up On Poppy Hill online HD free<br />
-Kokuriko-zaka Kara full movie download 1080p<br />
-HD Online Player for Kokurikozaka Kara 720p<br />
-From Up On Poppy Hill 2011 streaming 1080p<br />
-Kokuriko-zaka Kara HD online player portable<br />
-How to watch From Up On Poppy Hill in HD<br />
-Kokurikozaka Kara 720p or 1080p download<br />
-From Up On Poppy Hill full movie online HD<br />
-Kokuriko-zaka Kara HD online player free<br />
-Watch From Up On Poppy Hill 1080p streaming<br />
-Kokurikozaka Kara full movie HD online player<br />
-From Up On Poppy Hill 720p download free<br />
-Kokuriko-zaka Kara HD online player soundcloud<br />
-Watch From Up On Poppy Hill online free HD<br />
-Kokurikozaka Kara 1080p download link<br />
-From Up On Poppy Hill HD online player burgerhouse<br />
-Kokuriko-zaka Kara HD online player elinquar<br />
-Watch From Up On Poppy Hill 720p or 1080p<br />
-Kokurikozaka Kara full movie streaming HD<br />
-From Up On Poppy Hill HD online player kindlansuxt<br />
-Kokuriko-zaka Kara HD online player upd<br />
-Watch From Up On Poppy Hill full movie HD<br />
-Kokurikozaka Kara 720p or 1080p streaming<br />
-From Up On Poppy Hill HD online player fatalitron<br />
-Kokuriko-zaka Kara HD online player black and white<br />
-Watch From Up On Poppy Hill in HD quality<br />
-Kokurikozaka Kara full movie download free HD<br />
-From Up On Poppy Hill HD online player action movies<br />
-Kokuriko-zaka Kara HD online player USA<br />
-Watch From Up On Poppy Hill 2011 online free<br />
-Kokurikozaka Kara 720p or 1080p full movie<br />
-From Up On Poppy Hill HD online player best movies 2019<br />
-Kokuriko-zaka Kara HD online player beautiful animation<br />
-Watch From Up On Poppy Hill in 1080p quality<br />
-Kokurikozaka Kara full movie watch online free HD<br />
-From Up On Poppy Hill HD online player studio ghibli<br />
-Kokuriko-zaka Kara HD online player kokurikozakakara.com<br />
-Watch From Up On Poppy Hill with subtitles HD<br />
-Kokurikozaka Kara 720p or 1080p watch online free<br />
-From Up On Poppy Hill HD online player ghibli fan club</p>
-<p>As Umi and Shun work together, they develop feelings for each other. However, they soon discover that they share a shocking secret that could tear them apart. Will they be able to overcome their past and save their future?</p>
- <h3>The production and release of the film</h3>
-<p>The film was announced by Studio Ghibli in December 2010, as Gorō Miyazaki's second directorial work after Tales from Earthsea (2006). His father, Hayao Miyazaki, co-wrote the screenplay with Keiko Niwa, based on the manga by Sayama and Takahashi. The music was composed by Satoshi Takebe, who also worked on Tales from Earthsea.</p>
-<p>The film was released in Japan on July 16, 2011, by Toho. It was a commercial success, grossing over $61 million worldwide. It was also well received by critics, who praised its animation, story, and characters. It won several awards, including the Japan Academy Prize for Animation of the Year, and was nominated for the Asia Pacific Screen Award for Best Animated Feature Film.</p>
-<p>The film was dubbed into English by GKIDS, with a voice cast that includes Sarah Bolger as Umi, Anton Yelchin as Shun, Gillian Anderson as Umi's mother Ryoko, Jamie Lee Curtis as Umi's grandmother Hana, Beau Bridges as Shun's father Yūichirō Sawamura , Bruce Dern as Shun's adoptive father Yoshio Onodera , Christina Hendricks as Miki Hokuto , Aubrey Plaza as Sachiko Hirokōji , Chris Noth as Tokumaru , Ron Howard as Akio Kazama , Jeff Dunham as Gen Shiraki , Emily Osment as Nobuko Yokoyama , Charlie Saxton as Shiro Mizunuma , Isabelle Fuhrman as Sora Matsuzaki , Alex Wolff as Riku Matsuzaki , Jake Steinfeld as Oyaji , James Marsden as Mr. Tokumaru , Masami Nagasawa as Umi Matsuzaki (Japanese version), Junichi Okada as Shun Kazama (Japanese version), Keiko Takeshita as Hana Matsuzaki (Japanese version), Yuriko Ishida as Ryoko Matsuzaki (Japanese version), Jun Fubuki as Miki Hokuto (Japanese version), Takashi Naito as Yūichirō Sawamura (Japanese version), Shunsuke Kazama as Shiro Mizunuma (Japanese version), Nao Ōmori as Yoshio Onodera (Japanese version), Teruyuki Kagawa as Tokumaru (Japanese version). It was released in North America on March 15, 2013.</p>
- <h3>The reception and awards of the film</h3>
-<p>The film received positive reviews from most critics and audiences. It has a rating of 86% on Rotten Tomatoes based on 97 reviews, with an average score of 7/10. The website's critical consensus reads: "Gentle and nostalgic, From Up on Poppy Hill is one of Studio Ghibli's sweeter efforts -- and if it doesn't push the boundaries of the genre, it remains as engagingly lovely as Ghibli fans have come to expect." </p>
-<p>On Metacritic , which assigns a normalized rating out of 100 to reviews from mainstream critics, the film has an average score of 71 based on 25 reviews, indicating "generally favorable reviews". </p>
-<p>The film won several awards, including: <ul>
-<li>The Japan Academy Prize for Animation of the Year in 2012</li>
-<li>The Mainichi Film Award for Best Animation Film in 2011</li>
-<li>The Tokyo Anime Award for Animation of the Year in 2012</li>
-<li>The Asia Pacific Screen Award for Best Animated Feature Film nomination in 2012</li>
-<li>The Satellite Award for Best Animated or Mixed Media Feature nomination in 2013</li>
-</ul></p>
- <h2>Why watch kokurikozaka kara online?</h2>
-<p>If you are interested in watching kokurikozaka kara, you might wonder why you should stream it online instead of buying or renting a DVD or Blu-ray disc. Here are some reasons why watching it online is a good idea:</p>
- <h3>The benefits of streaming the film online</h3>
-<p>Streaming kokurikozaka kara online has many advantages, such as: <ul>
-<li>You can watch it anytime and anywhere you want, as long as you have an internet connection and a compatible device.</li>
-<li>You can choose between different platforms and services that offer different prices and features.</li>
-<li>You can avoid paying extra fees for shipping or late returns.</li>
-<li>You can avoid damaging or losing your physical copy of the film.</li>
-<li>You can enjoy high-quality video and audio without any scratches or glitches.</li>
-<li>You can access bonus features and extras that might not be available on discs.</li>
-</ul></p>
- <h3>The best platforms and devices to watch the film online</h3>
-<p>There are many options for streaming kokurikozaka kara online, but some are better than others. Here are some of the best platforms and devices to watch the film online:</p>
- <table><tr><th>Platform</th><th>Device</th><th>Features</th></tr><tr><td>Netflix</td><td>Smart TV, laptop, tablet, smartphone, gaming console, <h3>The themes and messages of the film</h3>
-<p>Kokurikozaka kara is not only a romantic and nostalgic film, but also a film that explores various themes and messages that are relevant to today's society. Some of the themes and messages are:</p>
-<ul>
-<li>The importance of preserving history and culture. The film shows how the students of the Latin Quarter value their old building and its memories, and how they fight to save it from destruction. The film also depicts the contrast between the traditional and the modern, the old and the new, and the rural and the urban in Japan during the 1960s.</li>
-<li>The impact of war and loss on families and individuals. The film portrays how Umi and Shun cope with the absence of their fathers, who died in the Korean War. The film also reveals how their fathers' pasts affect their present and future. The film also touches on the issues of identity, belonging, and inheritance.</li>
-<li>The power of love and friendship. The film illustrates how Umi and Shun's relationship grows from friendship to romance, and how they support each other through their challenges. The film also shows how their friends and family help them along the way, and how they form a community of solidarity and harmony.</li>
-</ul>
-<p>The film conveys a message of hope and optimism, despite the difficulties and uncertainties of life. It celebrates the beauty and joy of everyday life, and the potential of young people to make a difference in the world.</p>
- <h2>Why watch kokurikozaka kara online?</h2>
-<p>If you are interested in watching kokurikozaka kara, you might wonder why you should stream it online instead of buying or renting a DVD or Blu-ray disc. Here are some reasons why watching it online is a good idea:</p>
- <h3>The benefits of streaming the film online</h3>
-<p>Streaming kokurikozaka kara online has many advantages, such as: <ul>
-<li>You can watch it anytime and anywhere you want, as long as you have an internet connection and a compatible device.</li>
-<li>You can choose between different platforms and services that offer different prices and features.</li>
-<li>You can avoid paying extra fees for shipping or late returns.</li>
-<li>You can avoid damaging or losing your physical copy of the film.</li>
-<li>You can enjoy high-quality video and audio without any scratches or glitches.</li>
-<li>You can access bonus features and extras that might not be available on discs.</li>
-</ul></p>
- <h3>The best platforms and devices to watch the film online</h3>
-<p>There are many options for streaming kokurikozaka kara online, but some are better than others. Here are some of the best platforms and devices to watch the film online:</p>
- <table><tr><th>Platform</th><th>Device</th><th>Features</th></tr><tr><td>Netflix</td><td>Smart TV, laptop, tablet, smartphone, gaming console, streaming device</td><td>- Offers a wide range of movies and shows, including kokurikozaka kara<br>- Allows you to download content for offline viewing<br>- Supports HD quality and 5.1 surround sound<br>- Has a user-friendly interface and personalized recommendations<br>- Charges a monthly fee based on your plan<br>- Requires an internet connection of at least 5 Mbps for HD streaming</td></tr><tr><td>Amazon Prime Video</td><td>Smart TV, laptop, tablet, smartphone, gaming console, streaming device</td><td>- Offers a large library of movies and shows, including kokurikozaka kara<br>- Allows you to rent or buy content that is not included in your subscription<br>- Supports HD quality and 5.1 surround sound<br>- Has a simple interface and parental controls<br>- Charges an annual or monthly fee for Prime membership<br>- Requires an internet connection of at least 5 Mbps for HD streaming</td></tr><tr><td>Hulu</td><td>Smart TV, laptop, tablet, smartphone, gaming console, streaming device</td><td>- Offers a variety of movies and shows, including kokurikozaka kara<br>- Allows you to add live TV channels and premium networks to your subscription<br>- Supports HD quality and 5.1 surround sound<br>- Has a sleek interface and multiple profiles<br>- Charges a monthly fee based on your plan<br>- Requires an internet connection of at least 6 Mbps for HD streaming</td></tr></table>
- <h3>The tips and tricks to enhance your viewing experience</h3>
-<p>To make sure you enjoy watching kokurikozaka kara online, here are some tips and tricks to follow:</p>
-<ul>
-<li>Choose a platform that suits your preferences and budget.</li>
-<li>Check your internet speed and bandwidth before streaming.</li>
-<li>Select a device that has a good screen and sound quality.</li>
-<li>Adjust your brightness and volume settings according to your environment.</li>
-<li>Use headphones or speakers for better audio effects.</li>
-<li>Avoid spoilers and distractions while watching.</li>
-<li>Watch with friends or family for more fun.</li>
-</ul>
- <h2>How to choose between 720p and 1080p?</h2>
-<p>One of the questions you might have when streaming kokurikozaka kara online is whether to choose 720p or 1080p resolution. What is the difference between them, and which one is better for you? Let's find out!</p>
- <h3>The difference between 720p and 1080p resolution</h3>
-<p>The resolution of a video refers to the number of pixels that make up its image. The more pixels there are, the sharper and clearer the image will be. The term 720p means that the video has 720 horizontal lines of pixels, while 1080p means that it has 1080 horizontal lines of pixels. Therefore, 1080p has more pixels than 720p, resulting in higher image quality.</p>
- <h3>The factors that affect your resolution choice</h3>
-<p>However, choosing between 720p and 1080p is not as simple as picking the one with more pixels. There are other factors that affect your resolution choice, such as:</p>
-<ul>
-<li>Your device's screen size and resolution. If your device has a small screen or a low resolution, you might not notice much difference between 720p and 1080p. On the other hand, if your device has a large screen or a high resolution, you might appreciate the extra details that 1080p offers.</li>
-<li>Your internet speed and data usage. Streaming 1080p requires more bandwidth than streaming 720p, which means it will consume more data and load slower if your internet connection is weak or unstable. If you have a fast and reliable internet connection, you can enjoy smooth streaming at 1080p. However, if you have a slow or limited internet connection, you might want to stick with 720p to avoid buffering or extra charges.</li>
-<li>Your personal preference and realism, you might prefer 1080p. If you are more concerned about speed and data, you might opt for 720p.</li>
-</ul>
- <h3>The pros and cons of 720p and 1080p for kokurikozaka kara</h3>
-<p>To help you decide between 720p and 1080p for kokurikozaka kara, here are some pros and cons of each resolution:</p>
- <table><tr><th>Resolution</th><th>Pros</th><th>Cons</th></tr><tr><td>720p</td><td>- Faster loading and streaming<br>- Less data consumption<br>- Suitable for smaller screens<br>- Good enough for most animated films</td><td>- Lower image quality<br>- Less details and sharpness<br>- Not ideal for larger screens<br>- Might miss some nuances and subtleties of the film</td></tr><tr><td>1080p</td><td>- Higher image quality<br>- More details and sharpness<br>- Ideal for larger screens<br>- Can appreciate the artistry and beauty of the film</td><td>- Slower loading and streaming<br>- More data consumption<br>- Might not be supported by some devices<br>- Might not notice much difference on some animated films</td></tr></table>
- <h2>Conclusion</h2>
-<p>Kokurikozaka kara, or From Up on Poppy Hill, is a wonderful film that you can enjoy watching online in high definition. It is a film that tells a story of love, friendship, and history, set in the 1960s Japan. It is also a film that showcases the talent and charm of Studio Ghibli and its creators.</p>
-<p>If you want to watch kokurikozaka kara online, you have many options to choose from. You can stream it on various platforms and devices, depending on your preferences and budget. You can also choose between 720p and 1080p resolution, depending on your device's screen size and resolution, your internet speed and data usage, and your personal expectations.</p>
-<p>No matter what you choose, we hope you have a great time watching kokurikozaka kara online. It is a film that will make you smile, cry, and dream.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about kokurikozaka kara and watching it online:</p>
-<ul>
-<li>Q: Is kokurikozaka kara based on a true story?<br>A: No, kokurikozaka kara is not based on a true story. It is based on a manga series by Tetsurō Sayama and Chizuru Takahashi. However, it does depict some historical events and aspects of Japan in the 1960s.</li>
-<li>Q: Is kokurikozaka kara suitable for children?<br>A: Yes, kokurikozaka kara is suitable for children. It is rated PG by the MPAA for mild thematic elements and some incidental smoking images. It is also rated U by the BBFC for very mild threat. It is a family-friendly film that can be enjoyed by people of all ages.</li>
-<li>Q: Where can I find the soundtrack of kokurikozaka kara?<br>A: You can find the soundtrack of kokurikozaka kara on various music platforms and services, such as Spotify , Apple Music , YouTube Music , Amazon Music , etc. You can also buy the CD or digital album from online stores, such as Amazon , iTunes , etc.</li>
-<li>Q: Who sings the theme song of kokurikozaka kara?<br>A: The theme song of kokurikozaka kara is called "Summer of Farewells — From Up on Poppy Hill" (「さよならの夏～コクリコ坂から～」, "Sayonara no Natsu ~Kokuriko-zaka kara~"). It is sung by Aoi Teshima , a Japanese singer and voice actress who also voiced Theru in Tales from Earthsea . She also sings another song in the film called "Breakfast Song" (「朝ご飯の歌」, "Asagohan no Uta").</li>
-<li>Q: What are some other films by Studio Ghibli that I can watch online?<br>A: There are many other films by Studio Ghibli that you can watch online, such as Spirited Away , My Neighbor Totoro , Princess Mononoke , Howl's Moving Castle , Ponyo , The Wind Rises , etc. You can find them on various streaming platforms and services, such as Netflix , Amazon Prime Video , Hulu , HBO Max , etc.</li>
-</ul>
- </p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/ActivationacronisTIH 6514 6.md

@@ -1,10 +0,0 @@
-<br />
-<p>If you've recently installed antivirus programs or adware, then search your computer for 'activationacronistih.exe' to detect them. While activationacronistih.exe activationacronistih.exe viruses, you can delete activationacronistih.exe. Malware may not always change the name, but removing it is always advisable. Find activationacronistih.exe and delete it.</p>
-<h2>activationacronisTIH 6514 6</h2><br /><p><b><b>Download</b> &#11088; <a href="https://imgfil.com/2uy1xQ">https://imgfil.com/2uy1xQ</a></b></p><br /><br />
-<p>Deleting the files responsible for the problem may help in stopping them from activating. First, follow the instructions in the preceding article to locate the activationacronistih.exe file and delete it. If you are not sure which program is causing the activationacronistih.exe problems, you can use a Web browser to access your control panel, and then locate the window or icon that has activationacronistih.exe on the error screen.</p>
-<p>After the restore finishes, then you can restart your computer. If this doesn't resolve your activationacronistih.exe problem, you can proceed with the next step, which is to run a virus scan on your hard drive.</p>
-<p>ActivationAcronisTIH is an helpful tool that can be run on the infected PC to help fix. It can fix the activationacronistih.exe errors, optimize the PC's performance, and protect it from other threats. The tool is safe, it does not void your product’s license. The activationacronistih.exe is a part of Microsoft Windows Operating System program developed by not by Acronis.Some activationacronistih.exe errors may have the following reasons:</p>
-<p></p>
-<p> - Some system files have been incorrectly installed, corrupted or removed. - Some other programs are misbehaving on your system. Fixing activationacronistih.exe may require you to perform different steps, depending on the cause of the error.</p> 899543212b<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download Trucker - Overloaded Trucks APK and Haul Ore for Profit.md

@@ -1,132 +0,0 @@
-
-<h1>Trucker - Overloaded Trucks APK: A Fun and Challenging Driving Game</h1>
-<p>Do you love driving big trucks and hauling heavy loads? Do you enjoy testing your skills and reflexes on different terrains and weather conditions? If you answered yes, then you should try Trucker - Overloaded Trucks APK, a fun and challenging driving game for Android devices.</p>
-<h2>trucker overloaded trucks apk</h2><br /><p><b><b>Download</b> &middot;&middot;&middot;&middot;&middot; <a href="https://jinyurl.com/2uNRL2">https://jinyurl.com/2uNRL2</a></b></p><br /><br />
-<h2>What is Trucker - Overloaded Trucks APK?</h2>
-<p>Trucker - Overloaded Trucks APK is a game developed by LQG, a studio that specializes in creating realistic and immersive simulation games. In this game, you will take the role of a truck driver who has to deliver various cargoes across different locations. You will have to deal with different obstacles, such as traffic, bridges, tunnels, hills, mud, snow, and more. You will also have to manage your fuel, speed, brakes, and steering to avoid accidents and damages.</p>
-<h3>The gameplay of Trucker - Overloaded Trucks APK</h3>
-<p>The gameplay of Trucker - Overloaded Trucks APK is simple but addictive. You will start with a basic truck and a simple cargo. You will have to drive from point A to point B without losing your cargo or crashing your truck. You will earn money for each successful delivery. You can use the money to upgrade your truck or buy new trucks with different features and capacities. You can also unlock new cargoes and locations as you progress in the game.</p>
-<h3>The features of Trucker - Overloaded Trucks APK</h3>
-<p>Trucker - Overloaded Trucks APK has many features that make it an enjoyable and realistic driving game. Some of these features are:</p>
-<ul>
-<li>High-quality graphics and sound effects that create a realistic atmosphere.</li>
-<li>Multiple camera angles that let you view your truck from different perspectives.</li>
-<li>A variety of trucks and cargoes that have different characteristics and challenges.</li>
-<li>A dynamic weather system that affects the driving conditions and the physics of your truck.</li>
-<li>A map that shows your current location, destination, and route.</li>
-<li>A leaderboard that ranks your performance against other players around the world.</li>
-</ul>
-<h2>How to download and install Trucker - Overloaded Trucks APK on your Android device?</h2>
-<p>If you want to play Trucker - Overloaded Trucks APK on your Android device, you will need to download and install it from a reliable source. Here are the requirements and steps for doing so:</p>
-<h3>The requirements for Trucker - Overloaded Trucks APK</h3>
-<p>To play Trucker - Overloaded Trucks APK on your Android device, you will need:</p>
-<p>trucker overloaded trucks game download<br />
-trucker overloaded trucks simulator apk<br />
-trucker overloaded trucks mod apk<br />
-trucker overloaded trucks android app<br />
-trucker overloaded trucks online emulator<br />
-trucker overloaded trucks free apk<br />
-trucker overloaded trucks gameplay<br />
-trucker overloaded trucks latest version apk<br />
-trucker overloaded trucks ore transport<br />
-trucker overloaded trucks dump truck driver<br />
-trucker overloaded trucks apk for pc<br />
-trucker overloaded trucks review<br />
-trucker overloaded trucks cheats<br />
-trucker overloaded trucks tips and tricks<br />
-trucker overloaded trucks best price<br />
-trucker overloaded trucks apk mirror<br />
-trucker overloaded trucks offline apk<br />
-trucker overloaded trucks unlimited money apk<br />
-trucker overloaded trucks realistic physics<br />
-trucker overloaded trucks graphics quality<br />
-trucker overloaded trucks update apk<br />
-trucker overloaded trucks trailer<br />
-trucker overloaded trucks features<br />
-trucker overloaded trucks how to play<br />
-trucker overloaded trucks system requirements<br />
-trucker overloaded trucks apk pure<br />
-trucker overloaded trucks hack apk<br />
-trucker overloaded trucks premium apk<br />
-trucker overloaded trucks full version apk<br />
-trucker overloaded trucks no ads apk<br />
-trucker overloaded trucks fun and addictive<br />
-trucker overloaded trucks challenges and missions<br />
-trucker overloaded trucks buy and sell ore<br />
-trucker overloaded trucks earn money and upgrade<br />
-trucker overloaded trucks different types of ore<br />
-trucker overloaded trucks various locations and routes<br />
-trucker overloaded trucks realistic sound effects<br />
-trucker overloaded trucks easy controls and interface<br />
-trucker overloaded trucks support and feedback<br />
-trucker overloaded trucks bug fixes and improvements</p>
-<ul>
-<li>An Android device that runs on Android 4.4 or higher.</li>
-<li>At least 65 MB of free storage space on your device.</li>
-<li>A stable internet connection to download the game and access its online features.</li>
-</ul>
-<h3>The steps to download and install Trucker - Overloaded Trucks APK</h3>
-<p>To download and install Trucker - Overloaded Trucks APK on your Android device, follow these steps:</p>
-<ol>
-<li>Go to [this link](^1^) to download the latest version of Trucker - Overloaded Trucks APK.</li>
-<li>Once the download is complete, locate the file on your device and tap on it to start the installation process.</li>
-<li>If you see a warning message that says "For your security, your phone is not allowed to install unknown apps from this source", go to your device settings and enable the option to install apps from unknown sources.</li>
-<li>Follow the on-screen instructions to complete the installation process.</li>
-<li>Once the installation is done, you can launch the game from your app drawer or home screen and enjoy playing Trucker - Overloaded Trucks APK.</li>
-</ol>
-<h2>How to play Trucker - Overloaded Trucks APK?</h2>
-<p>Playing Trucker - Overloaded Trucks APK is easy and fun. Here are the controls and tips for playing the game:</p>
-<h3>The controls of Trucker - Overloaded Trucks APK</h3>
-<p>The controls of Trucker - Overloaded Trucks APK are simple and intuitive. You can use the following buttons on your screen to control your truck:</p>
-<ul>
-<li>The gas pedal to accelerate your truck.</li>
-<li>The brake pedal to slow down or stop your truck.</li>
-<li>The steering wheel to turn your truck left or right.</li>
-<li>The horn to honk at other vehicles or pedestrians.</li>
-<li>The camera button to switch between different camera angles.</li>
-<li>The pause button to pause the game or access the settings menu.</li>
-</ul>
-<h3>The tips and tricks for Trucker - Overloaded Trucks APK</h3>
-<p>To play Trucker - Overloaded Trucks APK well, you will need some tips and tricks. Here are some of them:</p>
-<ul>
-<li>Pay attention to the road signs and traffic rules. They will help you avoid accidents and penalties.</li>
-<li>Balance your speed and fuel consumption. Driving too fast will consume more fuel and increase the risk of losing control. Driving too slow will waste time and reduce your earnings.</li>
-<li>Choose the right truck and cargo for each mission. Different trucks and cargoes have different advantages and disadvantages. For example, some trucks have more power and speed, but less fuel efficiency and maneuverability. Some cargoes are lighter and easier to transport, but less valuable and rewarding.</li>
-<li>Upgrade your truck or buy new trucks as you earn more money. Upgrading your truck will improve its performance and durability. Buying new trucks will give you access to more missions and challenges.</li>
-<li>Use the map to plan your route and avoid getting lost. The map will show you your current location, destination, and route. You can also zoom in or out of the map to see more details.</li>
-</ul>
-<h2>Why should you play Trucker - Overloaded Trucks APK?</h2>
-<p>Trucker - Overloaded Trucks APK is a game that will give you a lot of fun and satisfaction. Here are some reasons why you should play it:</p>
-<h3>The benefits of playing Trucker - Overloaded Trucks APK</h3>
-<p>Playing Trucker - Overloaded Trucks APK will give you many benefits, such as:</p>
-<ul>
-<li>Improving your driving skills and reflexes. You will learn how to drive a big truck in different situations and environments.</li>
-<li>Enhancing your creativity and problem-solving abilities. You will have to find the best way to deliver your cargo safely and efficiently.</li>
-<li>Relaxing your mind and relieving your stress. You will enjoy the scenery and the sound of your truck engine as you drive along the road.</li>
-<li>Entertaining yourself and killing time. You will never get bored with the variety of missions and challenges that the game offers.</li>
-</ul>
-<h3>The drawbacks of playing Trucker - Overloaded Trucks APK</h3>
-<p>Playing Trucker - Overloaded Trucks APK also has some drawbacks, such as:</p>
-<ul>
-<li>Taking up some storage space on your device. The game requires at least 65 MB of free storage space on your device, which may be a problem if you have a low-end device or limited storage space.</li>
-<li>Consuming some battery power on your device. The game uses high-quality graphics and sound effects, which may drain your battery faster than usual.</li>
-<li>Requiring an internet connection to access some features. The game needs an internet connection to download the game, update the game, access the leaderboard, and share your achievements with other players.</li>
-</ul>
- <h2>Conclusion</h2>
- <p>In conclusion, Trucker - Overloaded Trucks APK is a fun and challenging driving game that will test your skills and reflexes as a truck driver. You will have to deliver various cargoes across different locations while dealing with different obstacles, such as traffic, bridges, tunnels, hills, mud, snow, and more. You will also have to manage your fuel, speed, brakes, and steering to avoid accidents and damages. You will earn money for each successful delivery, which you can use to upgrade your truck or buy new trucks with different features and capacities and capacities. You can also unlock new cargoes and locations as you progress in the game. The game has high-quality graphics and sound effects that create a realistic atmosphere. The game also has multiple camera angles that let you view your truck from different perspectives. The game also has a dynamic weather system that affects the driving conditions and the physics of your truck. The game also has a map that shows your current location, destination, and route. The game also has a leaderboard that ranks your performance against other players around the world. Playing Trucker - Overloaded Trucks APK will improve your driving skills and reflexes, enhance your creativity and problem-solving abilities, relax your mind and relieve your stress, and entertain yourself and kill time. However, playing Trucker - Overloaded Trucks APK also has some drawbacks, such as taking up some storage space on your device, consuming some battery power on your device, and requiring an internet connection to access some features. If you are looking for a fun and challenging driving game for your Android device, you should try Trucker - Overloaded Trucks APK.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about Trucker - Overloaded Trucks APK:</p>
-<ol>
-<li>What is the latest version of Trucker - Overloaded Trucks APK?</li>
-<p>The latest version of Trucker - Overloaded Trucks APK is 1.0.3, which was released on June 15, 2023.</p>
-<li>How many trucks and cargoes are available in Trucker - Overloaded Trucks APK?</li>
-<p>There are 10 trucks and 20 cargoes available in Trucker - Overloaded Trucks APK, each with different characteristics and challenges.</p>
-<li>How can I share my achievements with other players in Trucker - Overloaded Trucks APK?</li>
-<p>You can share your achievements with other players in Trucker - Overloaded Trucks APK by connecting your game to your Facebook account. You can also invite your friends to play the game with you.</p>
-<li>How can I contact the developer of Trucker - Overloaded Trucks APK?</li>
-<p>You can contact the developer of Trucker - Overloaded Trucks APK by sending an email to [email protected] or visiting their website at https://lqgstudio.com/.</p>
-<li>Is Trucker - Overloaded Trucks APK safe to download and install?</li>
-<p>Yes, Trucker - Overloaded Trucks APK is safe to download and install from a reliable source. However, you should always scan the file for viruses before installing it on your device.</p>
-</ol></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download apk 5play.ru No ads no limits no worries.md

@@ -1,121 +0,0 @@
-
-<h1>How to Download APK 5play.ru for Android</h1>
-<p>If you are a fan of android games, you might have heard of APK 5play.ru. It is a website that offers free downloads of android games, including mods, hacks, and premium versions. In this article, we will tell you everything you need to know about APK 5play.ru, including what it is, why you should download it, how to download it, how to use it, and what are its benefits and drawbacks.</p>
- <h2>What is APK 5play.ru?</h2>
-<p>APK 5play.ru is a website that provides free android games for download. It has a huge collection of games from various genres and categories, such as action, adventure, arcade, puzzle, racing, simulation, sports, strategy, and more. You can find popular games like PUBG Mobile, Minecraft, GTA San Andreas, Among Us, Genshin Impact, etc., as well as indie games from different developers. You can also download mods and hacks for some games, which give you unlimited resources, features, or cheats.</p>
-<h2>download apk 5play.ru</h2><br /><p><b><b>Download</b> &#128504; <a href="https://jinyurl.com/2uNSy8">https://jinyurl.com/2uNSy8</a></b></p><br /><br />
- <p>APK 5play.ru is not only a website but also a platform that supports android gamers. It has a user-friendly interface that allows you to easily search, browse, and download games. It also has a community that provides feedback and ratings for each game. You can read the reviews of other users, leave your own comments, and rate the games according to your experience. You can also request new games or mods from the developers or other users.</p>
- <h2>Why download APK 5play.ru?</h2>
-<p>There are many reasons why you should download APK 5play.ru for your android device. Here are some of them:</p>
- <h3>To enjoy the latest and best android games for free</h3>
-<p>One of the main reasons why you should download APK 5play.ru is that it gives you free access to premium and paid games. You don't have to spend any money to enjoy the latest and best android games. You can download them directly from the website without any registration or subscription. You can also update them regularly to get new features and fixes.</p>
- <h3>To access exclusive mods and hacks for popular games</h3>
-<p>Another reason why you should download APK 5play.ru is that it offers exclusive mods and hacks for popular games. You can get unlimited resources, features, or cheats for games like PUBG Mobile, GTA San Andreas, Among Us, Genshin Impact, etc. You can also customize the games according to your preferences and needs. You can change the graphics, the gameplay, the characters, the items, and more. You can also unlock new levels, modes, skins, and weapons.</p>
- <h3>To discover new and interesting games from different developers</h3>
-<p>A third reason why you should download APK 5play.ru is that it helps you discover new and interesting games from different developers. You can find games that are not available on the Google Play Store or other platforms. You can also find games that are unique, creative, and innovative. You can explore different genres and categories of games and find the ones that suit your taste and mood.</p>
- <h2>How to download APK 5play.ru?</h2>
-<p>Downloading APK 5play.ru for your android device is very easy and simple. You just need to follow these steps:</p>
- <h3>Step 1: Visit the official website of APK 5play.ru</h3>
-<p>The first step is to visit the official website of APK 5play.ru. You can use any browser on your device to access the website. The website has a domain name of https://5play.ru/en/. You can also use a VPN or proxy service if the website is blocked or restricted in your region.</p>
-<p>download apk 5play.ru games<br />
-download apk 5play.ru mods<br />
-download apk 5play.ru android<br />
-download apk 5play.ru obb<br />
-download apk 5play.ru latest version<br />
-download apk 5play.ru free<br />
-download apk 5play.ru offline<br />
-download apk 5play.ru online<br />
-download apk 5play.ru action<br />
-download apk 5play.ru adventure<br />
-download apk 5play.ru simulation<br />
-download apk 5play.ru strategy<br />
-download apk 5play.ru racing<br />
-download apk 5play.ru sports<br />
-download apk 5play.ru puzzle<br />
-download apk 5play.ru arcade<br />
-download apk 5play.ru rpg<br />
-download apk 5play.ru shooter<br />
-download apk 5play.ru horror<br />
-download apk 5play.ru casual<br />
-download apk 5play.ru sandbox<br />
-download apk 5play.ru platformer<br />
-download apk 5play.ru fighting<br />
-download apk 5play.ru stealth<br />
-download apk 5play.ru survival<br />
-download apk 5play.ru tower defense<br />
-download apk 5play.ru card<br />
-download apk 5play.ru board<br />
-download apk 5play.ru trivia<br />
-download apk 5play.ru word<br />
-download apk 5play.ru educational<br />
-download apk 5play.ru music<br />
-download apk 5play.ru role playing<br />
-download apk 5play.ru multiplayer<br />
-download apk 5play.ru co-op<br />
-download apk 5play.ru vr<br />
-download apk 5play.ru ar<br />
-download apk 5play.ru premium<br />
-download apk 5play.ru unlocked<br />
-download apk 5play.ru hacked<br />
-download apk 5play.ru cracked<br />
-download apk 5play.ru patched<br />
-download apk 5play.ru full version<br />
-download apk 5play.ru pro version<br />
-download apk 5play.ru modded version<br />
-download apk 5play.ru unlimited money<br />
-download apk 5play.ru unlimited gems<br />
-download apk 5play.ru unlimited coins<br />
-download apk 5play.ru unlimited lives</p>
- <h3>Step 2: Choose the game you want to download</h3>
-<p>The second step is to choose the game you want to download. You can use the search bar on the top of the website to type the name of the game or the keyword related to it. You can also use the filters on the left side of the website to narrow down your search by genre, category, rating, popularity, etc. You can also browse through the featured, new, or updated games on the homepage of the website.</p>
- <h3>Step 3: Click on the download button and select the APK or OBB file</h3>
-<p>The third step is to click on the download button and select the APK or OBB file. Once you have found the game you want to download, click on its name or image to open its page. On the game page, you will see a green download button on the right side. Click on it and you will see a list of files available for download. You can choose either the APK file or the OBB file depending on your preference. The APK file is the application file that installs the game on your device. The OBB file is the data file that contains the additional content of the game such as graphics, sounds, etc.</p>
- <h3>Step 4: Install the APK file on your device and copy the OBB file to the appropriate folder</h3>
-<p>The fourth step is to install the APK file on your device and copy the OBB file to the appropriate folder. After downloading the files, you need to install the APK file on your device. To do that, you need to enable the installation of unknown sources on your device. You can do that by going to the settings of your device, then security, then unknown sources. Once you have enabled that, you can tap on the APK file and follow the instructions to install it. If you have downloaded the OBB file, you need to copy it to the right folder on your device. You can do that by using a file manager app or a USB cable. The OBB file should be copied to the folder named Android/obb/ on your device's internal or external storage. Make sure that the OBB file has the same name as the game's package name.</p>
- <h3>Step 5: Launch the game and enjoy</h3>
-<p>The fifth and final step is to launch the game and enjoy. Once you have installed the APK file and copied the OBB file, you can launch the game from your device's app drawer or home screen. You can also create a shortcut for the game on your device's desktop for easy access. You can now enjoy the game with all its features and mods.</p>
- <h2>How to use APK 5play.ru?</h2>
-<p>Using APK 5play.ru is very easy and simple as well. You just need to follow these tips:</p>
- <h3>Browse through the different categories and genres of games</h3>
-<p>One of the best ways to use APK 5play.ru is to browse through the different categories and genres of games. You can find games from various genres such as action, adventure, arcade, puzzle, racing, simulation, sports, strategy, and more. You can also find games from different categories such as online, offline, multiplayer, single-player, 3D, 2D, etc. You can also sort the games by popularity, rating, date, or alphabet.</p>
- <h3>Read the description and reviews of each game</h3>
-<p>Another way to use APK 5play.ru is to read the description and reviews of each game. You can find useful information about each game such as its features, gameplay, graphics, controls, requirements, etc. You can also read the reviews of other users who have downloaded and played the game. You can see their ratings, comments, feedback, and suggestions. You can also leave your own review and rating for each game.</p>
- <h3>Check the compatibility and requirements of each game</h3>
-<p>A third way to use APK 5play.ru is to check the compatibility and requirements of each game. You can see if the game is compatible with your device's model, version of android, screen size, etc. You can also see if the game requires any additional permissions or data such as internet connection, storage space, location access, etc. You can also see if the game has any in-app purchases or ads.</p>
- <h3>Update the games regularly to get new features and fixes</h3>
-<p>A fourth way to use APK 5play.ru is to update the games regularly to get new features and fixes. You can see if there are any new versions or updates available for each game on the website. You can also enable notifications for updates on your device's settings. You can download and install the updates easily from the website or from your device's app manager.</p>
- <h2>What are the benefits of APK 5play.ru?</h2>
-<p>APK 5play.ru has many benefits for android gamers. Here are some of them:</p>
- <h3>Free access to premium and paid games</h3>
-<p>One of the main benefits of APK 5play.ru is that it gives you free access to premium and paid games. You don't have to spend any money to enjoy the latest and best android games. You can download them directly from the website without any registration or subscription. You can also update them regularly to get new features and fixes.</p>
- <h3>Unlimited resources and features with mods and hacks</h3>
-<p>Another benefit of APK 5play.ru is that it offers unlimited resources and features with mods and hacks for some games. You can get unlimited coins, gems, lives, ammo, health, etc. for games like PUBG Mobile, GTA San Andreas, Among Us, Genshin Impact, etc. You can also customize the games according to your preferences and needs. You can change the graphics, the gameplay, the characters, the items, and more. You can also unlock new levels, modes, skins, and weapons.</p>
- <h3>High-quality graphics and performance with optimized games</h3>
-<p>A third benefit of APK 5play.ru is that it provides high-quality graphics and performance with optimized games. You can enjoy the games with smooth and fast gameplay, stunning visuals, realistic sounds, and immersive effects. You can also adjust the settings of the games to match your device's capabilities and preferences. You can also save battery and data by playing offline or online games.</p>
- <h3>Safe and secure downloads with no viruses or malware</h3>
-<p>A fourth benefit of APK 5play.ru is that it ensures safe and secure downloads with no viruses or malware. You don't have to worry about harming your device or compromising your privacy by downloading games from the website. The website has a strict policy of checking and verifying each game before uploading it to the website. The website also uses encryption and protection technologies to prevent any unauthorized access or interference.</p>
- <h2>What are the drawbacks of APK 5play.ru?</h2>
-<p>APK 5play.ru has some drawbacks as well for android gamers. Here are some of them:</p>
- <h3>Potential risk of violating the terms and conditions of some games</h3>
-<p>One of the main drawbacks of APK 5play.ru is that it poses a potential risk of violating the terms and conditions of some games. You might be breaking the rules or laws of some games by downloading or using mods or hacks for them. You might also be infringing the intellectual property rights or copyrights of some game developers or publishers by downloading or using their games without their permission. This could result in legal actions or penalties against you.</p>
- <h3>Possible compatibility issues with some devices or versions of android</h3>
-<p>Another drawback of APK 5play.ru is that it might cause compatibility issues with some devices or versions of android. You might not be able to download or install some games on your device due to its model, version of android, screen size, etc. You might also experience crashes, glitches, errors, or bugs with some games due to their requirements, permissions, data, etc. You might also face difficulties in updating or uninstalling some games from your device.</p>
- <h3>Occasional bugs or errors with some games or mods</h3>
-<p>A third drawback of APK 5play.ru is that it might have occasional bugs or errors with some games or mods. You might encounter problems with some games or mods such as missing content, corrupted files, wrong language, invalid links, etc. You might also find some games or mods that are outdated, incomplete, or fake. You might also face issues with some games or mods that are not compatible with each other or with your device.</p>
- <h2>Conclusion</h2>
-<p>APK 5play.ru is a website that offers free downloads of android games, including mods, hacks, and premium versions. It has many benefits for android gamers such as free access to premium and paid games, unlimited resources and features with mods and hacks, high-quality graphics and performance with optimized games, and safe and secure downloads with no viruses or malware. It also has some drawbacks such as potential risk of violating the terms and conditions of some games, possible compatibility issues with some devices or versions of android, and occasional bugs or errors with some games or mods.</p>
- <p>If you are interested in downloading APK 5play.ru for your android device, you can follow the steps mentioned above in this article. You can also use the tips provided above to use APK 5play.ru effectively and efficiently. However, you should also be aware of the risks and consequences involved in downloading or using APK 5play.ru. You should always respect the rights and rules of the game developers and publishers as well as your own device's security and privacy.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about APK 5play.ru:</p>
- <h4>Q: Is APK 5play.ru legal?</h4>
-<p>A: APK 5play.ru is not legal in some countries or regions where downloading or using pirated or modded games is prohibited by law. You should also check the laws and regulations of your country or region before downloading or using APK 5play.ru.</p>
- <h4>Q: Is APK 5play.ru safe?</h4>
-<p>A: APK 5play.ru is safe in terms of downloading and installing games without any viruses or malware. The website has a strict policy of checking and verifying each game before uploading it to the website. The website also uses encryption and protection technologies to prevent any unauthorized access or interference. However, APK 5play.ru is not safe in terms of violating the terms and conditions of some games or compromising your device's security or privacy. You should always be careful and cautious when downloading or using APK 5play.ru.</p>
- <h4>Q: How to update APK 5play.ru?</h4>
-<p>A: You can update APK 5play.ru by visiting the official website of APK 5play.ru and downloading the latest version of the games you want. You can also enable notifications for updates on your device's settings. You can download and install the updates easily from the website or from your device's app manager.</p>
- <h4>Q: How to uninstall APK 5play.ru?</h4>
-<p>A: You can uninstall APK 5play.ru by deleting the APK file and the OBB file from your device's storage. You can also use a file manager app or a USB cable to do that. You can also uninstall the games you have downloaded from APK 5play.ru by using your device's app manager or settings.</p>
- <h4>Q: How to contact APK 5play.ru?</h4>
-<p>A: You can contact APK 5play.ru by using the feedback form on the website. You can also use the email address, phone number, or social media accounts provided on the website. You can also use the comment section on each game page to communicate with other users or developers.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/4eJIoBek/Stable_Diffusion_1.4_openvino/README.md

@@ -1,12 +0,0 @@
----
-title: (Not working for now) Stable Diffusion 1.4 openvino
-emoji: 🌚
-colorFrom: blue
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.15.2
-app_file: demo_web.py
-pinned: false
-license: apache-2.0
-duplicated_from: timboie/test
----

spaces/AI-Hobbyist/Hoyo-RVC/go-web.bat

@@ -1,2 +0,0 @@
-runtime\python.exe infer-web.py --pycmd runtime\python.exe --port 7897
-pause

spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/image_degradation/bsrgan_light.py

@@ -1,650 +0,0 @@
-# -*- coding: utf-8 -*-
-import numpy as np
-import cv2
-import torch
-
-from functools import partial
-import random
-from scipy import ndimage
-import scipy
-import scipy.stats as ss
-from scipy.interpolate import interp2d
-from scipy.linalg import orth
-import albumentations
-
-import ldm.modules.image_degradation.utils_image as util
-
-"""
-# --------------------------------------------
-# Super-Resolution
-# --------------------------------------------
-#
-# Kai Zhang ([email protected])
-# https://github.com/cszn
-# From 2019/03--2021/08
-# --------------------------------------------
-"""
-
-
-def modcrop_np(img, sf):
-    '''
-    Args:
-        img: numpy image, WxH or WxHxC
-        sf: scale factor
-    Return:
-        cropped image
-    '''
-    w, h = img.shape[:2]
-    im = np.copy(img)
-    return im[:w - w % sf, :h - h % sf, ...]
-
-
-"""
-# --------------------------------------------
-# anisotropic Gaussian kernels
-# --------------------------------------------
-"""
-
-
-def analytic_kernel(k):
-    """Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)"""
-    k_size = k.shape[0]
-    # Calculate the big kernels size
-    big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2))
-    # Loop over the small kernel to fill the big one
-    for r in range(k_size):
-        for c in range(k_size):
-            big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k
-    # Crop the edges of the big kernel to ignore very small values and increase run time of SR
-    crop = k_size // 2
-    cropped_big_k = big_k[crop:-crop, crop:-crop]
-    # Normalize to 1
-    return cropped_big_k / cropped_big_k.sum()
-
-
-def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6):
-    """ generate an anisotropic Gaussian kernel
-    Args:
-        ksize : e.g., 15, kernel size
-        theta : [0,  pi], rotation angle range
-        l1    : [0.1,50], scaling of eigenvalues
-        l2    : [0.1,l1], scaling of eigenvalues
-        If l1 = l2, will get an isotropic Gaussian kernel.
-    Returns:
-        k     : kernel
-    """
-
-    v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.]))
-    V = np.array([[v[0], v[1]], [v[1], -v[0]]])
-    D = np.array([[l1, 0], [0, l2]])
-    Sigma = np.dot(np.dot(V, D), np.linalg.inv(V))
-    k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize)
-
-    return k
-
-
-def gm_blur_kernel(mean, cov, size=15):
-    center = size / 2.0 + 0.5
-    k = np.zeros([size, size])
-    for y in range(size):
-        for x in range(size):
-            cy = y - center + 1
-            cx = x - center + 1
-            k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov)
-
-    k = k / np.sum(k)
-    return k
-
-
-def shift_pixel(x, sf, upper_left=True):
-    """shift pixel for super-resolution with different scale factors
-    Args:
-        x: WxHxC or WxH
-        sf: scale factor
-        upper_left: shift direction
-    """
-    h, w = x.shape[:2]
-    shift = (sf - 1) * 0.5
-    xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0)
-    if upper_left:
-        x1 = xv + shift
-        y1 = yv + shift
-    else:
-        x1 = xv - shift
-        y1 = yv - shift
-
-    x1 = np.clip(x1, 0, w - 1)
-    y1 = np.clip(y1, 0, h - 1)
-
-    if x.ndim == 2:
-        x = interp2d(xv, yv, x)(x1, y1)
-    if x.ndim == 3:
-        for i in range(x.shape[-1]):
-            x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1)
-
-    return x
-
-
-def blur(x, k):
-    '''
-    x: image, NxcxHxW
-    k: kernel, Nx1xhxw
-    '''
-    n, c = x.shape[:2]
-    p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2
-    x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate')
-    k = k.repeat(1, c, 1, 1)
-    k = k.view(-1, 1, k.shape[2], k.shape[3])
-    x = x.view(1, -1, x.shape[2], x.shape[3])
-    x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c)
-    x = x.view(n, c, x.shape[2], x.shape[3])
-
-    return x
-
-
-def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0):
-    """"
-    # modified version of https://github.com/assafshocher/BlindSR_dataset_generator
-    # Kai Zhang
-    # min_var = 0.175 * sf  # variance of the gaussian kernel will be sampled between min_var and max_var
-    # max_var = 2.5 * sf
-    """
-    # Set random eigen-vals (lambdas) and angle (theta) for COV matrix
-    lambda_1 = min_var + np.random.rand() * (max_var - min_var)
-    lambda_2 = min_var + np.random.rand() * (max_var - min_var)
-    theta = np.random.rand() * np.pi  # random theta
-    noise = -noise_level + np.random.rand(*k_size) * noise_level * 2
-
-    # Set COV matrix using Lambdas and Theta
-    LAMBDA = np.diag([lambda_1, lambda_2])
-    Q = np.array([[np.cos(theta), -np.sin(theta)],
-                  [np.sin(theta), np.cos(theta)]])
-    SIGMA = Q @ LAMBDA @ Q.T
-    INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :]
-
-    # Set expectation position (shifting kernel for aligned image)
-    MU = k_size // 2 - 0.5 * (scale_factor - 1)  # - 0.5 * (scale_factor - k_size % 2)
-    MU = MU[None, None, :, None]
-
-    # Create meshgrid for Gaussian
-    [X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1]))
-    Z = np.stack([X, Y], 2)[:, :, :, None]
-
-    # Calcualte Gaussian for every pixel of the kernel
-    ZZ = Z - MU
-    ZZ_t = ZZ.transpose(0, 1, 3, 2)
-    raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise)
-
-    # shift the kernel so it will be centered
-    # raw_kernel_centered = kernel_shift(raw_kernel, scale_factor)
-
-    # Normalize the kernel and return
-    # kernel = raw_kernel_centered / np.sum(raw_kernel_centered)
-    kernel = raw_kernel / np.sum(raw_kernel)
-    return kernel
-
-
-def fspecial_gaussian(hsize, sigma):
-    hsize = [hsize, hsize]
-    siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0]
-    std = sigma
-    [x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1))
-    arg = -(x * x + y * y) / (2 * std * std)
-    h = np.exp(arg)
-    h[h < scipy.finfo(float).eps * h.max()] = 0
-    sumh = h.sum()
-    if sumh != 0:
-        h = h / sumh
-    return h
-
-
-def fspecial_laplacian(alpha):
-    alpha = max([0, min([alpha, 1])])
-    h1 = alpha / (alpha + 1)
-    h2 = (1 - alpha) / (alpha + 1)
-    h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]]
-    h = np.array(h)
-    return h
-
-
-def fspecial(filter_type, *args, **kwargs):
-    '''
-    python code from:
-    https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py
-    '''
-    if filter_type == 'gaussian':
-        return fspecial_gaussian(*args, **kwargs)
-    if filter_type == 'laplacian':
-        return fspecial_laplacian(*args, **kwargs)
-
-
-"""
-# --------------------------------------------
-# degradation models
-# --------------------------------------------
-"""
-
-
-def bicubic_degradation(x, sf=3):
-    '''
-    Args:
-        x: HxWxC image, [0, 1]
-        sf: down-scale factor
-    Return:
-        bicubicly downsampled LR image
-    '''
-    x = util.imresize_np(x, scale=1 / sf)
-    return x
-
-
-def srmd_degradation(x, k, sf=3):
-    ''' blur + bicubic downsampling
-    Args:
-        x: HxWxC image, [0, 1]
-        k: hxw, double
-        sf: down-scale factor
-    Return:
-        downsampled LR image
-    Reference:
-        @inproceedings{zhang2018learning,
-          title={Learning a single convolutional super-resolution network for multiple degradations},
-          author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
-          booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
-          pages={3262--3271},
-          year={2018}
-        }
-    '''
-    x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')  # 'nearest' | 'mirror'
-    x = bicubic_degradation(x, sf=sf)
-    return x
-
-
-def dpsr_degradation(x, k, sf=3):
-    ''' bicubic downsampling + blur
-    Args:
-        x: HxWxC image, [0, 1]
-        k: hxw, double
-        sf: down-scale factor
-    Return:
-        downsampled LR image
-    Reference:
-        @inproceedings{zhang2019deep,
-          title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels},
-          author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
-          booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
-          pages={1671--1681},
-          year={2019}
-        }
-    '''
-    x = bicubic_degradation(x, sf=sf)
-    x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
-    return x
-
-
-def classical_degradation(x, k, sf=3):
-    ''' blur + downsampling
-    Args:
-        x: HxWxC image, [0, 1]/[0, 255]
-        k: hxw, double
-        sf: down-scale factor
-    Return:
-        downsampled LR image
-    '''
-    x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
-    # x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2))
-    st = 0
-    return x[st::sf, st::sf, ...]
-
-
-def add_sharpening(img, weight=0.5, radius=50, threshold=10):
-    """USM sharpening. borrowed from real-ESRGAN
-    Input image: I; Blurry image: B.
-    1. K = I + weight * (I - B)
-    2. Mask = 1 if abs(I - B) > threshold, else: 0
-    3. Blur mask:
-    4. Out = Mask * K + (1 - Mask) * I
-    Args:
-        img (Numpy array): Input image, HWC, BGR; float32, [0, 1].
-        weight (float): Sharp weight. Default: 1.
-        radius (float): Kernel size of Gaussian blur. Default: 50.
-        threshold (int):
-    """
-    if radius % 2 == 0:
-        radius += 1
-    blur = cv2.GaussianBlur(img, (radius, radius), 0)
-    residual = img - blur
-    mask = np.abs(residual) * 255 > threshold
-    mask = mask.astype('float32')
-    soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0)
-
-    K = img + weight * residual
-    K = np.clip(K, 0, 1)
-    return soft_mask * K + (1 - soft_mask) * img
-
-
-def add_blur(img, sf=4):
-    wd2 = 4.0 + sf
-    wd = 2.0 + 0.2 * sf
-
-    wd2 = wd2/4
-    wd = wd/4
-
-    if random.random() < 0.5:
-        l1 = wd2 * random.random()
-        l2 = wd2 * random.random()
-        k = anisotropic_Gaussian(ksize=random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2)
-    else:
-        k = fspecial('gaussian', random.randint(2, 4) + 3, wd * random.random())
-    img = ndimage.filters.convolve(img, np.expand_dims(k, axis=2), mode='mirror')
-
-    return img
-
-
-def add_resize(img, sf=4):
-    rnum = np.random.rand()
-    if rnum > 0.8:  # up
-        sf1 = random.uniform(1, 2)
-    elif rnum < 0.7:  # down
-        sf1 = random.uniform(0.5 / sf, 1)
-    else:
-        sf1 = 1.0
-    img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3]))
-    img = np.clip(img, 0.0, 1.0)
-
-    return img
-
-
-# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
-#     noise_level = random.randint(noise_level1, noise_level2)
-#     rnum = np.random.rand()
-#     if rnum > 0.6:  # add color Gaussian noise
-#         img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
-#     elif rnum < 0.4:  # add grayscale Gaussian noise
-#         img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
-#     else:  # add  noise
-#         L = noise_level2 / 255.
-#         D = np.diag(np.random.rand(3))
-#         U = orth(np.random.rand(3, 3))
-#         conv = np.dot(np.dot(np.transpose(U), D), U)
-#         img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
-#     img = np.clip(img, 0.0, 1.0)
-#     return img
-
-def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
-    noise_level = random.randint(noise_level1, noise_level2)
-    rnum = np.random.rand()
-    if rnum > 0.6:  # add color Gaussian noise
-        img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
-    elif rnum < 0.4:  # add grayscale Gaussian noise
-        img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
-    else:  # add  noise
-        L = noise_level2 / 255.
-        D = np.diag(np.random.rand(3))
-        U = orth(np.random.rand(3, 3))
-        conv = np.dot(np.dot(np.transpose(U), D), U)
-        img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
-    img = np.clip(img, 0.0, 1.0)
-    return img
-
-
-def add_speckle_noise(img, noise_level1=2, noise_level2=25):
-    noise_level = random.randint(noise_level1, noise_level2)
-    img = np.clip(img, 0.0, 1.0)
-    rnum = random.random()
-    if rnum > 0.6:
-        img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
-    elif rnum < 0.4:
-        img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
-    else:
-        L = noise_level2 / 255.
-        D = np.diag(np.random.rand(3))
-        U = orth(np.random.rand(3, 3))
-        conv = np.dot(np.dot(np.transpose(U), D), U)
-        img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
-    img = np.clip(img, 0.0, 1.0)
-    return img
-
-
-def add_Poisson_noise(img):
-    img = np.clip((img * 255.0).round(), 0, 255) / 255.
-    vals = 10 ** (2 * random.random() + 2.0)  # [2, 4]
-    if random.random() < 0.5:
-        img = np.random.poisson(img * vals).astype(np.float32) / vals
-    else:
-        img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114])
-        img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255.
-        noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray
-        img += noise_gray[:, :, np.newaxis]
-    img = np.clip(img, 0.0, 1.0)
-    return img
-
-
-def add_JPEG_noise(img):
-    quality_factor = random.randint(80, 95)
-    img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR)
-    result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor])
-    img = cv2.imdecode(encimg, 1)
-    img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB)
-    return img
-
-
-def random_crop(lq, hq, sf=4, lq_patchsize=64):
-    h, w = lq.shape[:2]
-    rnd_h = random.randint(0, h - lq_patchsize)
-    rnd_w = random.randint(0, w - lq_patchsize)
-    lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :]
-
-    rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf)
-    hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :]
-    return lq, hq
-
-
-def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None):
-    """
-    This is the degradation model of BSRGAN from the paper
-    "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
-    ----------
-    img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf)
-    sf: scale factor
-    isp_model: camera ISP model
-    Returns
-    -------
-    img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
-    hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
-    """
-    isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
-    sf_ori = sf
-
-    h1, w1 = img.shape[:2]
-    img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...]  # mod crop
-    h, w = img.shape[:2]
-
-    if h < lq_patchsize * sf or w < lq_patchsize * sf:
-        raise ValueError(f'img size ({h1}X{w1}) is too small!')
-
-    hq = img.copy()
-
-    if sf == 4 and random.random() < scale2_prob:  # downsample1
-        if np.random.rand() < 0.5:
-            img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])),
-                             interpolation=random.choice([1, 2, 3]))
-        else:
-            img = util.imresize_np(img, 1 / 2, True)
-        img = np.clip(img, 0.0, 1.0)
-        sf = 2
-
-    shuffle_order = random.sample(range(7), 7)
-    idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
-    if idx1 > idx2:  # keep downsample3 last
-        shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
-
-    for i in shuffle_order:
-
-        if i == 0:
-            img = add_blur(img, sf=sf)
-
-        elif i == 1:
-            img = add_blur(img, sf=sf)
-
-        elif i == 2:
-            a, b = img.shape[1], img.shape[0]
-            # downsample2
-            if random.random() < 0.75:
-                sf1 = random.uniform(1, 2 * sf)
-                img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])),
-                                 interpolation=random.choice([1, 2, 3]))
-            else:
-                k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
-                k_shifted = shift_pixel(k, sf)
-                k_shifted = k_shifted / k_shifted.sum()  # blur with shifted kernel
-                img = ndimage.filters.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror')
-                img = img[0::sf, 0::sf, ...]  # nearest downsampling
-            img = np.clip(img, 0.0, 1.0)
-
-        elif i == 3:
-            # downsample3
-            img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
-            img = np.clip(img, 0.0, 1.0)
-
-        elif i == 4:
-            # add Gaussian noise
-            img = add_Gaussian_noise(img, noise_level1=2, noise_level2=8)
-
-        elif i == 5:
-            # add JPEG noise
-            if random.random() < jpeg_prob:
-                img = add_JPEG_noise(img)
-
-        elif i == 6:
-            # add processed camera sensor noise
-            if random.random() < isp_prob and isp_model is not None:
-                with torch.no_grad():
-                    img, hq = isp_model.forward(img.copy(), hq)
-
-    # add final JPEG compression noise
-    img = add_JPEG_noise(img)
-
-    # random crop
-    img, hq = random_crop(img, hq, sf_ori, lq_patchsize)
-
-    return img, hq
-
-
-# todo no isp_model?
-def degradation_bsrgan_variant(image, sf=4, isp_model=None):
-    """
-    This is the degradation model of BSRGAN from the paper
-    "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
-    ----------
-    sf: scale factor
-    isp_model: camera ISP model
-    Returns
-    -------
-    img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
-    hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
-    """
-    image = util.uint2single(image)
-    isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
-    sf_ori = sf
-
-    h1, w1 = image.shape[:2]
-    image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...]  # mod crop
-    h, w = image.shape[:2]
-
-    hq = image.copy()
-
-    if sf == 4 and random.random() < scale2_prob:  # downsample1
-        if np.random.rand() < 0.5:
-            image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])),
-                               interpolation=random.choice([1, 2, 3]))
-        else:
-            image = util.imresize_np(image, 1 / 2, True)
-        image = np.clip(image, 0.0, 1.0)
-        sf = 2
-
-    shuffle_order = random.sample(range(7), 7)
-    idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
-    if idx1 > idx2:  # keep downsample3 last
-        shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
-
-    for i in shuffle_order:
-
-        if i == 0:
-            image = add_blur(image, sf=sf)
-
-        # elif i == 1:
-        #     image = add_blur(image, sf=sf)
-
-        if i == 0:
-            pass
-
-        elif i == 2:
-            a, b = image.shape[1], image.shape[0]
-            # downsample2
-            if random.random() < 0.8:
-                sf1 = random.uniform(1, 2 * sf)
-                image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])),
-                                   interpolation=random.choice([1, 2, 3]))
-            else:
-                k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
-                k_shifted = shift_pixel(k, sf)
-                k_shifted = k_shifted / k_shifted.sum()  # blur with shifted kernel
-                image = ndimage.filters.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror')
-                image = image[0::sf, 0::sf, ...]  # nearest downsampling
-
-            image = np.clip(image, 0.0, 1.0)
-
-        elif i == 3:
-            # downsample3
-            image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
-            image = np.clip(image, 0.0, 1.0)
-
-        elif i == 4:
-            # add Gaussian noise
-            image = add_Gaussian_noise(image, noise_level1=1, noise_level2=2)
-
-        elif i == 5:
-            # add JPEG noise
-            if random.random() < jpeg_prob:
-                image = add_JPEG_noise(image)
-        #
-        # elif i == 6:
-        #     # add processed camera sensor noise
-        #     if random.random() < isp_prob and isp_model is not None:
-        #         with torch.no_grad():
-        #             img, hq = isp_model.forward(img.copy(), hq)
-
-    # add final JPEG compression noise
-    image = add_JPEG_noise(image)
-    image = util.single2uint(image)
-    example = {"image": image}
-    return example
-
-
-
-
-if __name__ == '__main__':
-    print("hey")
-    img = util.imread_uint('utils/test.png', 3)
-    img = img[:448, :448]
-    h = img.shape[0] // 4
-    print("resizing to", h)
-    sf = 4
-    deg_fn = partial(degradation_bsrgan_variant, sf=sf)
-    for i in range(20):
-        print(i)
-        img_hq = img
-        img_lq = deg_fn(img)["image"]
-        img_hq, img_lq = util.uint2single(img_hq), util.uint2single(img_lq)
-        print(img_lq)
-        img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img_hq)["image"]
-        print(img_lq.shape)
-        print("bicubic", img_lq_bicubic.shape)
-        print(img_hq.shape)
-        lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
-                                interpolation=0)
-        lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic),
-                                        (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
-                                        interpolation=0)
-        img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1)
-        util.imsave(img_concat, str(i) + '.png')

spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/commons/transformer.py

@@ -1,747 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import Parameter, Linear
-from text_to_speech.modules.commons.layers import LayerNorm, Embedding
-from text_to_speech.utils.nn.seq_utils import get_incremental_state, set_incremental_state, softmax, make_positions
-import torch.nn.functional as F
-
-DEFAULT_MAX_SOURCE_POSITIONS = 2000
-DEFAULT_MAX_TARGET_POSITIONS = 2000
-
-
-class SinusoidalPositionalEmbedding(nn.Module):
-    """This module produces sinusoidal positional embeddings of any length.
-
-    Padding symbols are ignored.
-    """
-
-    def __init__(self, embedding_dim, padding_idx, init_size=1024):
-        super().__init__()
-        self.embedding_dim = embedding_dim
-        self.padding_idx = padding_idx
-        self.weights = SinusoidalPositionalEmbedding.get_embedding(
-            init_size,
-            embedding_dim,
-            padding_idx,
-        )
-        self.register_buffer('_float_tensor', torch.FloatTensor(1))
-
-    @staticmethod
-    def get_embedding(num_embeddings, embedding_dim, padding_idx=None):
-        """Build sinusoidal embeddings.
-
-        This matches the implementation in tensor2tensor, but differs slightly
-        from the description in Section 3.5 of "Attention Is All You Need".
-        """
-        half_dim = embedding_dim // 2
-        emb = math.log(10000) / (half_dim - 1)
-        emb = torch.exp(torch.arange(half_dim, dtype=torch.float) * -emb)
-        emb = torch.arange(num_embeddings, dtype=torch.float).unsqueeze(1) * emb.unsqueeze(0)
-        emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1).view(num_embeddings, -1)
-        if embedding_dim % 2 == 1:
-            # zero pad
-            emb = torch.cat([emb, torch.zeros(num_embeddings, 1)], dim=1)
-        if padding_idx is not None:
-            emb[padding_idx, :] = 0
-        return emb
-
-    def forward(self, input, incremental_state=None, timestep=None, positions=None, **kwargs):
-        """Input is expected to be of size [bsz x seqlen]."""
-        bsz, seq_len = input.shape[:2]
-        max_pos = self.padding_idx + 1 + seq_len
-        if self.weights is None or max_pos > self.weights.size(0):
-            # recompute/expand embeddings if needed
-            self.weights = SinusoidalPositionalEmbedding.get_embedding(
-                max_pos,
-                self.embedding_dim,
-                self.padding_idx,
-            )
-        self.weights = self.weights.to(self._float_tensor)
-
-        if incremental_state is not None:
-            # positions is the same for every token when decoding a single step
-            pos = timestep.view(-1)[0] + 1 if timestep is not None else seq_len
-            return self.weights[self.padding_idx + pos, :].expand(bsz, 1, -1)
-
-        positions = make_positions(input, self.padding_idx) if positions is None else positions
-        return self.weights.index_select(0, positions.view(-1)).view(bsz, seq_len, -1).detach()
-
-    def max_positions(self):
-        """Maximum number of supported positions."""
-        return int(1e5)  # an arbitrary large number
-
-
-class TransformerFFNLayer(nn.Module):
-    def __init__(self, hidden_size, filter_size, padding="SAME", kernel_size=1, dropout=0., act='gelu'):
-        super().__init__()
-        self.kernel_size = kernel_size
-        self.dropout = dropout
-        self.act = act
-        if padding == 'SAME':
-            self.ffn_1 = nn.Conv1d(hidden_size, filter_size, kernel_size, padding=kernel_size // 2)
-        elif padding == 'LEFT':
-            self.ffn_1 = nn.Sequential(
-                nn.ConstantPad1d((kernel_size - 1, 0), 0.0),
-                nn.Conv1d(hidden_size, filter_size, kernel_size)
-            )
-        self.ffn_2 = Linear(filter_size, hidden_size)
-
-    def forward(self, x, incremental_state=None):
-        # x: T x B x C
-        if incremental_state is not None:
-            saved_state = self._get_input_buffer(incremental_state)
-            if 'prev_input' in saved_state:
-                prev_input = saved_state['prev_input']
-                x = torch.cat((prev_input, x), dim=0)
-            x = x[-self.kernel_size:]
-            saved_state['prev_input'] = x
-            self._set_input_buffer(incremental_state, saved_state)
-
-        x = self.ffn_1(x.permute(1, 2, 0)).permute(2, 0, 1)
-        x = x * self.kernel_size ** -0.5
-
-        if incremental_state is not None:
-            x = x[-1:]
-        if self.act == 'gelu':
-            x = F.gelu(x)
-        if self.act == 'relu':
-            x = F.relu(x)
-        x = F.dropout(x, self.dropout, training=self.training)
-        x = self.ffn_2(x)
-        return x
-
-    def _get_input_buffer(self, incremental_state):
-        return get_incremental_state(
-            self,
-            incremental_state,
-            'f',
-        ) or {}
-
-    def _set_input_buffer(self, incremental_state, buffer):
-        set_incremental_state(
-            self,
-            incremental_state,
-            'f',
-            buffer,
-        )
-
-    def clear_buffer(self, incremental_state):
-        if incremental_state is not None:
-            saved_state = self._get_input_buffer(incremental_state)
-            if 'prev_input' in saved_state:
-                del saved_state['prev_input']
-            self._set_input_buffer(incremental_state, saved_state)
-
-
-class MultiheadAttention(nn.Module):
-    def __init__(self, embed_dim, num_heads, kdim=None, vdim=None, dropout=0., bias=True,
-                 add_bias_kv=False, add_zero_attn=False, self_attention=False,
-                 encoder_decoder_attention=False):
-        super().__init__()
-        self.embed_dim = embed_dim
-        self.kdim = kdim if kdim is not None else embed_dim
-        self.vdim = vdim if vdim is not None else embed_dim
-        self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim
-
-        self.num_heads = num_heads
-        self.dropout = dropout
-        self.head_dim = embed_dim // num_heads
-        assert self.head_dim * num_heads == self.embed_dim, "embed_dim must be divisible by num_heads"
-        self.scaling = self.head_dim ** -0.5
-
-        self.self_attention = self_attention
-        self.encoder_decoder_attention = encoder_decoder_attention
-
-        assert not self.self_attention or self.qkv_same_dim, 'Self-attention requires query, key and ' \
-                                                             'value to be of the same size'
-
-        if self.qkv_same_dim:
-            self.in_proj_weight = Parameter(torch.Tensor(3 * embed_dim, embed_dim))
-        else:
-            self.k_proj_weight = Parameter(torch.Tensor(embed_dim, self.kdim))
-            self.v_proj_weight = Parameter(torch.Tensor(embed_dim, self.vdim))
-            self.q_proj_weight = Parameter(torch.Tensor(embed_dim, embed_dim))
-
-        if bias:
-            self.in_proj_bias = Parameter(torch.Tensor(3 * embed_dim))
-        else:
-            self.register_parameter('in_proj_bias', None)
-
-        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
-
-        if add_bias_kv:
-            self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))
-            self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))
-        else:
-            self.bias_k = self.bias_v = None
-
-        self.add_zero_attn = add_zero_attn
-
-        self.reset_parameters()
-
-        self.enable_torch_version = False
-        if hasattr(F, "multi_head_attention_forward"):
-            self.enable_torch_version = True
-        else:
-            self.enable_torch_version = False
-        self.last_attn_probs = None
-
-    def reset_parameters(self):
-        if self.qkv_same_dim:
-            nn.init.xavier_uniform_(self.in_proj_weight)
-        else:
-            nn.init.xavier_uniform_(self.k_proj_weight)
-            nn.init.xavier_uniform_(self.v_proj_weight)
-            nn.init.xavier_uniform_(self.q_proj_weight)
-
-        nn.init.xavier_uniform_(self.out_proj.weight)
-        if self.in_proj_bias is not None:
-            nn.init.constant_(self.in_proj_bias, 0.)
-            nn.init.constant_(self.out_proj.bias, 0.)
-        if self.bias_k is not None:
-            nn.init.xavier_normal_(self.bias_k)
-        if self.bias_v is not None:
-            nn.init.xavier_normal_(self.bias_v)
-
-    def forward(
-            self,
-            query, key, value,
-            key_padding_mask=None,
-            incremental_state=None,
-            need_weights=True,
-            static_kv=False,
-            attn_mask=None,
-            before_softmax=False,
-            need_head_weights=False,
-            enc_dec_attn_constraint_mask=None,
-            reset_attn_weight=None
-    ):
-        """Input shape: Time x Batch x Channel
-
-        Args:
-            key_padding_mask (ByteTensor, optional): mask to exclude
-                keys that are pads, of shape `(batch, src_len)`, where
-                padding elements are indicated by 1s.
-            need_weights (bool, optional): return the attention weights,
-                averaged over heads (default: False).
-            attn_mask (ByteTensor, optional): typically used to
-                implement causal attention, where the mask prevents the
-                attention from looking forward in time (default: None).
-            before_softmax (bool, optional): return the raw attention
-                weights and values before the attention softmax.
-            need_head_weights (bool, optional): return the attention
-                weights for each head. Implies *need_weights*. Default:
-                return the average attention weights over all heads.
-        """
-        if need_head_weights:
-            need_weights = True
-
-        tgt_len, bsz, embed_dim = query.size()
-        assert embed_dim == self.embed_dim
-        assert list(query.size()) == [tgt_len, bsz, embed_dim]
-        if self.enable_torch_version and incremental_state is None and not static_kv and reset_attn_weight is None:
-            if self.qkv_same_dim:
-                return F.multi_head_attention_forward(query, key, value,
-                                                      self.embed_dim, self.num_heads,
-                                                      self.in_proj_weight,
-                                                      self.in_proj_bias, self.bias_k, self.bias_v,
-                                                      self.add_zero_attn, self.dropout,
-                                                      self.out_proj.weight, self.out_proj.bias,
-                                                      self.training, key_padding_mask, need_weights,
-                                                      attn_mask)
-            else:
-                return F.multi_head_attention_forward(query, key, value,
-                                                      self.embed_dim, self.num_heads,
-                                                      torch.empty([0]),
-                                                      self.in_proj_bias, self.bias_k, self.bias_v,
-                                                      self.add_zero_attn, self.dropout,
-                                                      self.out_proj.weight, self.out_proj.bias,
-                                                      self.training, key_padding_mask, need_weights,
-                                                      attn_mask, use_separate_proj_weight=True,
-                                                      q_proj_weight=self.q_proj_weight,
-                                                      k_proj_weight=self.k_proj_weight,
-                                                      v_proj_weight=self.v_proj_weight)
-
-        if incremental_state is not None:
-            saved_state = self._get_input_buffer(incremental_state)
-            if 'prev_key' in saved_state:
-                # previous time steps are cached - no need to recompute
-                # key and value if they are static
-                if static_kv:
-                    assert self.encoder_decoder_attention and not self.self_attention
-                    key = value = None
-        else:
-            saved_state = None
-
-        if self.self_attention:
-            # self-attention
-            q, k, v = self.in_proj_qkv(query)
-        elif self.encoder_decoder_attention:
-            # encoder-decoder attention
-            q = self.in_proj_q(query)
-            if key is None:
-                assert value is None
-                k = v = None
-            else:
-                k = self.in_proj_k(key)
-                v = self.in_proj_v(key)
-
-        else:
-            q = self.in_proj_q(query)
-            k = self.in_proj_k(key)
-            v = self.in_proj_v(value)
-        q *= self.scaling
-
-        if self.bias_k is not None:
-            assert self.bias_v is not None
-            k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])
-            v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])
-            if attn_mask is not None:
-                attn_mask = torch.cat([attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1)
-            if key_padding_mask is not None:
-                key_padding_mask = torch.cat(
-                    [key_padding_mask, key_padding_mask.new_zeros(key_padding_mask.size(0), 1)], dim=1)
-
-        q = q.contiguous().view(tgt_len, bsz * self.num_heads, self.head_dim).transpose(0, 1)
-        if k is not None:
-            k = k.contiguous().view(-1, bsz * self.num_heads, self.head_dim).transpose(0, 1)
-        if v is not None:
-            v = v.contiguous().view(-1, bsz * self.num_heads, self.head_dim).transpose(0, 1)
-
-        if saved_state is not None:
-            # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)
-            if 'prev_key' in saved_state:
-                prev_key = saved_state['prev_key'].view(bsz * self.num_heads, -1, self.head_dim)
-                if static_kv:
-                    k = prev_key
-                else:
-                    k = torch.cat((prev_key, k), dim=1)
-            if 'prev_value' in saved_state:
-                prev_value = saved_state['prev_value'].view(bsz * self.num_heads, -1, self.head_dim)
-                if static_kv:
-                    v = prev_value
-                else:
-                    v = torch.cat((prev_value, v), dim=1)
-            if 'prev_key_padding_mask' in saved_state and saved_state['prev_key_padding_mask'] is not None:
-                prev_key_padding_mask = saved_state['prev_key_padding_mask']
-                if static_kv:
-                    key_padding_mask = prev_key_padding_mask
-                else:
-                    key_padding_mask = torch.cat((prev_key_padding_mask, key_padding_mask), dim=1)
-
-            saved_state['prev_key'] = k.view(bsz, self.num_heads, -1, self.head_dim)
-            saved_state['prev_value'] = v.view(bsz, self.num_heads, -1, self.head_dim)
-            saved_state['prev_key_padding_mask'] = key_padding_mask
-
-            self._set_input_buffer(incremental_state, saved_state)
-
-        src_len = k.size(1)
-
-        # This is part of a workaround to get around fork/join parallelism
-        # not supporting Optional types.
-        if key_padding_mask is not None and key_padding_mask.shape == torch.Size([]):
-            key_padding_mask = None
-
-        if key_padding_mask is not None:
-            assert key_padding_mask.size(0) == bsz
-            assert key_padding_mask.size(1) == src_len
-
-        if self.add_zero_attn:
-            src_len += 1
-            k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)
-            v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)
-            if attn_mask is not None:
-                attn_mask = torch.cat([attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1)
-            if key_padding_mask is not None:
-                key_padding_mask = torch.cat(
-                    [key_padding_mask, torch.zeros(key_padding_mask.size(0), 1).type_as(key_padding_mask)], dim=1)
-
-        attn_weights = torch.bmm(q, k.transpose(1, 2))
-        attn_weights = self.apply_sparse_mask(attn_weights, tgt_len, src_len, bsz)
-
-        assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]
-
-        if attn_mask is not None:
-            if len(attn_mask.shape) == 2:
-                attn_mask = attn_mask.unsqueeze(0)
-            elif len(attn_mask.shape) == 3:
-                attn_mask = attn_mask[:, None].repeat([1, self.num_heads, 1, 1]).reshape(
-                    bsz * self.num_heads, tgt_len, src_len)
-            attn_weights = attn_weights + attn_mask
-
-        if enc_dec_attn_constraint_mask is not None:  # bs x head x L_kv
-            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
-            attn_weights = attn_weights.masked_fill(
-                enc_dec_attn_constraint_mask.unsqueeze(2).bool(),
-                -1e8,
-            )
-            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
-
-        if key_padding_mask is not None:
-            # don't attend to padding symbols
-            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
-            attn_weights = attn_weights.masked_fill(
-                key_padding_mask.unsqueeze(1).unsqueeze(2),
-                -1e8,
-            )
-            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
-
-        attn_logits = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
-
-        if before_softmax:
-            return attn_weights, v
-
-        attn_weights_float = softmax(attn_weights, dim=-1)
-        attn_weights = attn_weights_float.type_as(attn_weights)
-        attn_probs = F.dropout(attn_weights_float.type_as(attn_weights), p=self.dropout, training=self.training)
-
-        if reset_attn_weight is not None:
-            if reset_attn_weight:
-                self.last_attn_probs = attn_probs.detach()
-            else:
-                assert self.last_attn_probs is not None
-                attn_probs = self.last_attn_probs
-        attn = torch.bmm(attn_probs, v)
-        assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]
-        attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
-        attn = self.out_proj(attn)
-
-        if need_weights:
-            attn_weights = attn_weights_float.view(bsz, self.num_heads, tgt_len, src_len).transpose(1, 0)
-            if not need_head_weights:
-                # average attention weights over heads
-                attn_weights = attn_weights.mean(dim=0)
-        else:
-            attn_weights = None
-
-        return attn, (attn_weights, attn_logits)
-
-    def in_proj_qkv(self, query):
-        return self._in_proj(query).chunk(3, dim=-1)
-
-    def in_proj_q(self, query):
-        if self.qkv_same_dim:
-            return self._in_proj(query, end=self.embed_dim)
-        else:
-            bias = self.in_proj_bias
-            if bias is not None:
-                bias = bias[:self.embed_dim]
-            return F.linear(query, self.q_proj_weight, bias)
-
-    def in_proj_k(self, key):
-        if self.qkv_same_dim:
-            return self._in_proj(key, start=self.embed_dim, end=2 * self.embed_dim)
-        else:
-            weight = self.k_proj_weight
-            bias = self.in_proj_bias
-            if bias is not None:
-                bias = bias[self.embed_dim:2 * self.embed_dim]
-            return F.linear(key, weight, bias)
-
-    def in_proj_v(self, value):
-        if self.qkv_same_dim:
-            return self._in_proj(value, start=2 * self.embed_dim)
-        else:
-            weight = self.v_proj_weight
-            bias = self.in_proj_bias
-            if bias is not None:
-                bias = bias[2 * self.embed_dim:]
-            return F.linear(value, weight, bias)
-
-    def _in_proj(self, input, start=0, end=None):
-        weight = self.in_proj_weight
-        bias = self.in_proj_bias
-        weight = weight[start:end, :]
-        if bias is not None:
-            bias = bias[start:end]
-        return F.linear(input, weight, bias)
-
-    def _get_input_buffer(self, incremental_state):
-        return get_incremental_state(
-            self,
-            incremental_state,
-            'attn_state',
-        ) or {}
-
-    def _set_input_buffer(self, incremental_state, buffer):
-        set_incremental_state(
-            self,
-            incremental_state,
-            'attn_state',
-            buffer,
-        )
-
-    def apply_sparse_mask(self, attn_weights, tgt_len, src_len, bsz):
-        return attn_weights
-
-    def clear_buffer(self, incremental_state=None):
-        if incremental_state is not None:
-            saved_state = self._get_input_buffer(incremental_state)
-            if 'prev_key' in saved_state:
-                del saved_state['prev_key']
-            if 'prev_value' in saved_state:
-                del saved_state['prev_value']
-            self._set_input_buffer(incremental_state, saved_state)
-
-
-class EncSALayer(nn.Module):
-    def __init__(self, c, num_heads, dropout, attention_dropout=0.1,
-                 relu_dropout=0.1, kernel_size=9, padding='SAME', act='gelu'):
-        super().__init__()
-        self.c = c
-        self.dropout = dropout
-        self.num_heads = num_heads
-        if num_heads > 0:
-            self.layer_norm1 = LayerNorm(c)
-            self.self_attn = MultiheadAttention(
-                self.c, num_heads, self_attention=True, dropout=attention_dropout, bias=False)
-        self.layer_norm2 = LayerNorm(c)
-        self.ffn = TransformerFFNLayer(
-            c, 4 * c, kernel_size=kernel_size, dropout=relu_dropout, padding=padding, act=act)
-
-    def forward(self, x, encoder_padding_mask=None, **kwargs):
-        layer_norm_training = kwargs.get('layer_norm_training', None)
-        if layer_norm_training is not None:
-            self.layer_norm1.training = layer_norm_training
-            self.layer_norm2.training = layer_norm_training
-        if self.num_heads > 0:
-            residual = x
-            x = self.layer_norm1(x)
-            x, _, = self.self_attn(
-                query=x,
-                key=x,
-                value=x,
-                key_padding_mask=encoder_padding_mask
-            )
-            x = F.dropout(x, self.dropout, training=self.training)
-            x = residual + x
-            x = x * (1 - encoder_padding_mask.float()).transpose(0, 1)[..., None]
-
-        residual = x
-        x = self.layer_norm2(x)
-        x = self.ffn(x)
-        x = F.dropout(x, self.dropout, training=self.training)
-        x = residual + x
-        x = x * (1 - encoder_padding_mask.float()).transpose(0, 1)[..., None]
-        return x
-
-
-class DecSALayer(nn.Module):
-    def __init__(self, c, num_heads, dropout, attention_dropout=0.1, relu_dropout=0.1,
-                 kernel_size=9, act='gelu'):
-        super().__init__()
-        self.c = c
-        self.dropout = dropout
-        self.layer_norm1 = LayerNorm(c)
-        self.self_attn = MultiheadAttention(
-            c, num_heads, self_attention=True, dropout=attention_dropout, bias=False
-        )
-        self.layer_norm2 = LayerNorm(c)
-        self.encoder_attn = MultiheadAttention(
-            c, num_heads, encoder_decoder_attention=True, dropout=attention_dropout, bias=False,
-        )
-        self.layer_norm3 = LayerNorm(c)
-        self.ffn = TransformerFFNLayer(
-            c, 4 * c, padding='LEFT', kernel_size=kernel_size, dropout=relu_dropout, act=act)
-
-    def forward(
-            self,
-            x,
-            encoder_out=None,
-            encoder_padding_mask=None,
-            incremental_state=None,
-            self_attn_mask=None,
-            self_attn_padding_mask=None,
-            attn_out=None,
-            reset_attn_weight=None,
-            **kwargs,
-    ):
-        layer_norm_training = kwargs.get('layer_norm_training', None)
-        if layer_norm_training is not None:
-            self.layer_norm1.training = layer_norm_training
-            self.layer_norm2.training = layer_norm_training
-            self.layer_norm3.training = layer_norm_training
-        residual = x
-        x = self.layer_norm1(x)
-        x, _ = self.self_attn(
-            query=x,
-            key=x,
-            value=x,
-            key_padding_mask=self_attn_padding_mask,
-            incremental_state=incremental_state,
-            attn_mask=self_attn_mask
-        )
-        x = F.dropout(x, self.dropout, training=self.training)
-        x = residual + x
-
-        attn_logits = None
-        if encoder_out is not None or attn_out is not None:
-            residual = x
-            x = self.layer_norm2(x)
-        if encoder_out is not None:
-            x, attn = self.encoder_attn(
-                query=x,
-                key=encoder_out,
-                value=encoder_out,
-                key_padding_mask=encoder_padding_mask,
-                incremental_state=incremental_state,
-                static_kv=True,
-                enc_dec_attn_constraint_mask=get_incremental_state(self, incremental_state,
-                                                                   'enc_dec_attn_constraint_mask'),
-                reset_attn_weight=reset_attn_weight
-            )
-            attn_logits = attn[1]
-        elif attn_out is not None:
-            x = self.encoder_attn.in_proj_v(attn_out)
-        if encoder_out is not None or attn_out is not None:
-            x = F.dropout(x, self.dropout, training=self.training)
-            x = residual + x
-
-        residual = x
-        x = self.layer_norm3(x)
-        x = self.ffn(x, incremental_state=incremental_state)
-        x = F.dropout(x, self.dropout, training=self.training)
-        x = residual + x
-        return x, attn_logits
-
-    def clear_buffer(self, input, encoder_out=None, encoder_padding_mask=None, incremental_state=None):
-        self.encoder_attn.clear_buffer(incremental_state)
-        self.ffn.clear_buffer(incremental_state)
-
-    def set_buffer(self, name, tensor, incremental_state):
-        return set_incremental_state(self, incremental_state, name, tensor)
-
-
-class TransformerEncoderLayer(nn.Module):
-    def __init__(self, hidden_size, dropout, kernel_size=9, num_heads=2):
-        super().__init__()
-        self.hidden_size = hidden_size
-        self.dropout = dropout
-        self.num_heads = num_heads
-        self.op = EncSALayer(
-            hidden_size, num_heads, dropout=dropout,
-            attention_dropout=0.0, relu_dropout=dropout,
-            kernel_size=kernel_size)
-
-    def forward(self, x, **kwargs):
-        return self.op(x, **kwargs)
-
-
-class TransformerDecoderLayer(nn.Module):
-    def __init__(self, hidden_size, dropout, kernel_size=9, num_heads=2):
-        super().__init__()
-        self.hidden_size = hidden_size
-        self.dropout = dropout
-        self.num_heads = num_heads
-        self.op = DecSALayer(
-            hidden_size, num_heads, dropout=dropout,
-            attention_dropout=0.0, relu_dropout=dropout,
-            kernel_size=kernel_size)
-
-    def forward(self, x, **kwargs):
-        return self.op(x, **kwargs)
-
-    def clear_buffer(self, *args):
-        return self.op.clear_buffer(*args)
-
-    def set_buffer(self, *args):
-        return self.op.set_buffer(*args)
-
-
-class FFTBlocks(nn.Module):
-    def __init__(self, hidden_size, num_layers, ffn_kernel_size=9, dropout=0.0,
-                 num_heads=2, use_pos_embed=True, use_last_norm=True,
-                 use_pos_embed_alpha=True):
-        super().__init__()
-        self.num_layers = num_layers
-        embed_dim = self.hidden_size = hidden_size
-        self.dropout = dropout
-        self.use_pos_embed = use_pos_embed
-        self.use_last_norm = use_last_norm
-        if use_pos_embed:
-            self.max_source_positions = DEFAULT_MAX_TARGET_POSITIONS
-            self.padding_idx = 0
-            self.pos_embed_alpha = nn.Parameter(torch.Tensor([1])) if use_pos_embed_alpha else 1
-            self.embed_positions = SinusoidalPositionalEmbedding(
-                embed_dim, self.padding_idx, init_size=DEFAULT_MAX_TARGET_POSITIONS,
-            )
-
-        self.layers = nn.ModuleList([])
-        self.layers.extend([
-            TransformerEncoderLayer(self.hidden_size, self.dropout,
-                                    kernel_size=ffn_kernel_size, num_heads=num_heads)
-            for _ in range(self.num_layers)
-        ])
-        if self.use_last_norm:
-            self.layer_norm = nn.LayerNorm(embed_dim)
-        else:
-            self.layer_norm = None
-
-    def forward(self, x, padding_mask=None, attn_mask=None, return_hiddens=False):
-        """
-        :param x: [B, T, C]
-        :param padding_mask: [B, T]
-        :return: [B, T, C] or [L, B, T, C]
-        """
-        padding_mask = x.abs().sum(-1).eq(0).data if padding_mask is None else padding_mask
-        nonpadding_mask_TB = 1 - padding_mask.transpose(0, 1).float()[:, :, None]  # [T, B, 1]
-        if self.use_pos_embed:
-            positions = self.pos_embed_alpha * self.embed_positions(x[..., 0])
-            x = x + positions
-            x = F.dropout(x, p=self.dropout, training=self.training)
-        # B x T x C -> T x B x C
-        x = x.transpose(0, 1) * nonpadding_mask_TB
-        hiddens = []
-        for layer in self.layers:
-            x = layer(x, encoder_padding_mask=padding_mask, attn_mask=attn_mask) * nonpadding_mask_TB
-            hiddens.append(x)
-        if self.use_last_norm:
-            x = self.layer_norm(x) * nonpadding_mask_TB
-        if return_hiddens:
-            x = torch.stack(hiddens, 0)  # [L, T, B, C]
-            x = x.transpose(1, 2)  # [L, B, T, C]
-        else:
-            x = x.transpose(0, 1)  # [B, T, C]
-        return x
-
-
-class FastSpeechEncoder(FFTBlocks):
-    def __init__(self, dict_size, hidden_size=256, num_layers=4, kernel_size=9, num_heads=2,
-                 dropout=0.0):
-        super().__init__(hidden_size, num_layers, kernel_size, num_heads=num_heads,
-                         use_pos_embed=False, dropout=dropout)  # use_pos_embed_alpha for compatibility
-        self.embed_tokens = Embedding(dict_size, hidden_size, 0)
-        self.embed_scale = math.sqrt(hidden_size)
-        self.padding_idx = 0
-        self.embed_positions = SinusoidalPositionalEmbedding(
-            hidden_size, self.padding_idx, init_size=DEFAULT_MAX_TARGET_POSITIONS,
-        )
-
-    def forward(self, txt_tokens, attn_mask=None):
-        """
-
-        :param txt_tokens: [B, T]
-        :return: {
-            'encoder_out': [B x T x C]
-        }
-        """
-        encoder_padding_mask = txt_tokens.eq(self.padding_idx).data
-        x = self.forward_embedding(txt_tokens)  # [B, T, H]
-        if self.num_layers > 0:
-            x = super(FastSpeechEncoder, self).forward(x, encoder_padding_mask, attn_mask=attn_mask)
-        return x
-
-    def forward_embedding(self, txt_tokens):
-        # embed tokens and positions
-        x = self.embed_scale * self.embed_tokens(txt_tokens)
-        if self.use_pos_embed:
-            positions = self.embed_positions(txt_tokens)
-            x = x + positions
-        x = F.dropout(x, p=self.dropout, training=self.training)
-        return x
-
-
-class FastSpeechDecoder(FFTBlocks):
-    def __init__(self, hidden_size=256, num_layers=4, kernel_size=9, num_heads=2):
-        super().__init__(hidden_size, num_layers, kernel_size, num_heads=num_heads)

spaces/ALSv/FSW/roop/metadata.py

@@ -1,2 +0,0 @@
-name = 'roop'
-version = '1.3.2'

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/label/Label.js

@@ -1,297 +0,0 @@
-import Sizer from '../sizer/Sizer.js';
-import AddChildMask from '../../../plugins/gameobjects/container/containerlite/mask/AddChildMask.js';
-import SetDisplaySize from '../../../plugins/utils/size/SetDisplaySize.js';
-import Methods from './methods/Methods.js';
-
-const GetValue = Phaser.Utils.Objects.GetValue;
-
-class Label extends Sizer {
-    constructor(scene, config) {
-        // Create sizer
-        super(scene, config);
-        this.type = 'rexLabel';
-
-        // Add elements
-        var background = GetValue(config, 'background', undefined);
-        var icon = GetValue(config, 'icon', undefined);
-        var iconMask = GetValue(config, 'iconMask', undefined);
-        var text = GetValue(config, 'text', undefined);
-        var action = GetValue(config, 'action', undefined);
-        var actionMask = GetValue(config, 'actionMask', undefined);
-        // Align
-        var align = GetValue(config, 'align', undefined); // undefined/left/top: no space
-
-
-        if (background) {
-            this.addBackground(background);
-        }
-
-        // Add space
-        if (
-            (align === 'right') ||
-            (align === 'bottom') ||
-            (align === 'center')
-        ) {
-            this.addSpace();
-        }
-
-        if (icon) {
-            var iconSpace = GetValue(config, 'space.icon', 0);
-            var padding;
-            if (this.orientation === 0) {
-                if (text || action) {
-                    padding = { right: iconSpace };
-                }
-            } else {
-                if (text || action) {
-                    padding = { bottom: iconSpace };
-                }
-            }
-            var fitRatio = GetValue(config, 'squareFitIcon', false) ? 1 : 0;
-
-            this.add(
-                icon,
-                { proportion: 0, padding: padding, fitRatio: fitRatio }
-            );
-
-            if (iconMask) {
-                iconMask = AddChildMask.call(this, icon, icon, 1); // Circle mask
-            }
-
-            if (!fitRatio) {
-                var iconSize = GetValue(config, 'iconSize', undefined);
-                this.setIconSize(
-                    GetValue(config, 'iconWidth', iconSize),
-                    GetValue(config, 'iconHeight', iconSize)
-                );
-            }
-        }
-
-
-        if (text) {
-            var textSpace = GetValue(config, 'space.text', 0);
-            var expandTextWidth = GetValue(config, 'expandTextWidth', false);
-            var expandTextHeight = GetValue(config, 'expandTextHeight', false);
-            var proportion, padding, expand;
-            if (this.orientation === 0) {
-                proportion = (expandTextWidth) ? 1 : 0;
-                if (action) {
-                    padding = { right: textSpace };
-                }
-                expand = expandTextHeight;
-            } else {
-                proportion = (expandTextHeight) ? 1 : 0;
-                if (action) {
-                    padding = { bottom: textSpace };
-                }
-                expand = expandTextWidth;
-            }
-
-            this.add(
-                text,
-                { proportion: proportion, expand: expand, padding: padding, }
-            );
-        }
-
-        if (action) {
-            var fitRatio = GetValue(config, 'squareFitAction', false) ? 1 : 0;
-            this.add(
-                action,
-                { proportion: 0, fitRatio: fitRatio }
-            );
-
-            if (actionMask) {
-                actionMask = AddChildMask.call(this, action, action, 1); // Circle mask
-            }
-
-            if (!fitRatio) {
-                var actionSize = GetValue(config, 'actionSize');
-                this.setActionSize(
-                    GetValue(config, 'actionWidth', actionSize),
-                    GetValue(config, 'actionHeight', actionSize)
-                );
-            }
-        }
-
-        // Add space
-        if (align === 'center') {
-            this.addSpace();
-        }
-
-        this.addChildrenMap('background', background);
-        this.addChildrenMap('icon', icon);
-        this.addChildrenMap('iconMask', iconMask);
-        this.addChildrenMap('text', text);
-        this.addChildrenMap('action', action);
-        this.addChildrenMap('actionMask', actionMask);
-    }
-
-    // Access text game object
-    get text() {
-        var textObject = this.childrenMap.text;
-        if (textObject === undefined) {
-            return '';
-        }
-        return textObject.text;
-    }
-
-    set text(value) {
-        var textObject = this.childrenMap.text;
-        if (textObject === undefined) {
-            return;
-        }
-        textObject.setText(value);
-    }
-
-    setText(value) {
-        this.text = value;
-        return this;
-    }
-
-    // Access icon game object
-    setIconTexture(key, frame) {
-        var imageObject = this.childrenMap.icon;
-        if (imageObject === undefined) {
-            return this;
-        }
-        imageObject.setTexture(key, frame);
-
-        if (this.iconWidth !== undefined) {
-            SetDisplaySize(imageObject, this.iconWidth, this.iconHeight);
-            this.resetChildScaleState(imageObject);
-        }
-
-        return this;
-    }
-
-    setTexture(key, frame) {
-        this.setIconTexture(key, frame);
-        return this;
-    }
-
-    setIconSize(width, height) {
-        if (height === undefined) {
-            height = width;
-        }
-
-        this.iconWidth = width;
-        this.iconHeight = height;
-
-        return this;
-    }
-
-    get texture() {
-        var imageObject = this.childrenMap.icon;
-        if (imageObject === undefined) {
-            return undefined;
-        }
-        return imageObject.texture;
-    }
-
-    get frame() {
-        var imageObject = this.childrenMap.icon;
-        if (imageObject === undefined) {
-            return undefined;
-        }
-        return imageObject.frame;
-    }
-
-    setActionTexture(key, frame) {
-        var imageObject = this.childrenMap.action;
-        if (imageObject === undefined) {
-            return this;
-        }
-        imageObject.setTexture(key, frame);
-
-        if (this.actionWidth !== undefined) {
-            SetDisplaySize(imageObject, this.actionWidth, this.actionHeight);
-            this.resetChildScaleState(imageObject);
-        }
-
-        return this;
-    }
-
-    get actionTexture() {
-        var imageObject = this.childrenMap.action;
-        if (imageObject === undefined) {
-            return undefined;
-        }
-        return imageObject.texture;
-    }
-
-    get actionFrame() {
-        var imageObject = this.childrenMap.action;
-        if (imageObject === undefined) {
-            return undefined;
-        }
-        return imageObject.frame;
-    }
-
-    setActionSize(width, height) {
-        if (height === undefined) {
-            height = width;
-        }
-
-        this.actionWidth = width;
-        this.actionHeight = height;
-
-        return this;
-    }
-
-    preLayout() {
-        var icon = this.childrenMap.icon;
-        if (icon && (this.iconWidth !== undefined)) {
-            SetDisplaySize(icon, this.iconWidth, this.iconHeight);
-        }
-
-        var action = this.childrenMap.action;
-        if (action && (this.actionWidth !== undefined)) {
-            SetDisplaySize(action, this.actionWidth, this.actionHeight);
-        }
-
-        super.preLayout();
-    }
-
-    runLayout(parent, newWidth, newHeight) {
-        if (this.ignoreLayout) {
-            return this;
-        }
-
-        super.runLayout(parent, newWidth, newHeight);
-        // Pin icon-mask to icon game object
-        var iconMask = this.childrenMap.iconMask;
-        if (iconMask) {
-            iconMask.setPosition();
-            this.resetChildPositionState(iconMask);
-        }
-        // Pin action-mask to action game object
-        var actionMask = this.childrenMap.actionMask;
-        if (actionMask) {
-            actionMask.setPosition();
-            this.resetChildPositionState(actionMask);
-        }
-        return this;
-    }
-
-    resize(width, height) {
-        super.resize(width, height);
-        // Resize icon-mask to icon game object
-        var iconMask = this.childrenMap.iconMask;
-        if (iconMask) {
-            iconMask.resize();
-        }
-        // Resize action-mask to icon game object
-        var actionMask = this.childrenMap.actionMask;
-        if (actionMask) {
-            actionMask.resize();
-        }
-        return this;
-    }
-}
-
-Object.assign(
-    Label.prototype,
-    Methods,
-)
-
-export default Label;

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

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

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

@@ -1,244 +0,0 @@
-from typing import List, Tuple, Union, Optional
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from saicinpainting.training.modules.base import get_conv_block_ctor, get_activation
-from saicinpainting.training.modules.pix2pixhd import ResnetBlock
-
-
-class ResNetHead(nn.Module):
-    def __init__(self, input_nc, ngf=64, n_downsampling=3, n_blocks=9, norm_layer=nn.BatchNorm2d,
-                 padding_type='reflect', conv_kind='default', activation=nn.ReLU(True)):
-        assert (n_blocks >= 0)
-        super(ResNetHead, self).__init__()
-
-        conv_layer = get_conv_block_ctor(conv_kind)
-
-        model = [nn.ReflectionPad2d(3),
-                 conv_layer(input_nc, ngf, kernel_size=7, padding=0),
-                 norm_layer(ngf),
-                 activation]
-
-        ### downsample
-        for i in range(n_downsampling):
-            mult = 2 ** i
-            model += [conv_layer(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1),
-                      norm_layer(ngf * mult * 2),
-                      activation]
-
-        mult = 2 ** n_downsampling
-
-        ### resnet blocks
-        for i in range(n_blocks):
-            model += [ResnetBlock(ngf * mult, padding_type=padding_type, activation=activation, norm_layer=norm_layer,
-                                  conv_kind=conv_kind)]
-
-        self.model = nn.Sequential(*model)
-
-    def forward(self, input):
-        return self.model(input)
-
-
-class ResNetTail(nn.Module):
-    def __init__(self, output_nc, ngf=64, n_downsampling=3, n_blocks=9, norm_layer=nn.BatchNorm2d,
-                 padding_type='reflect', conv_kind='default', activation=nn.ReLU(True),
-                 up_norm_layer=nn.BatchNorm2d, up_activation=nn.ReLU(True), add_out_act=False, out_extra_layers_n=0,
-                 add_in_proj=None):
-        assert (n_blocks >= 0)
-        super(ResNetTail, self).__init__()
-
-        mult = 2 ** n_downsampling
-
-        model = []
-
-        if add_in_proj is not None:
-            model.append(nn.Conv2d(add_in_proj, ngf * mult, kernel_size=1))
-
-        ### resnet blocks
-        for i in range(n_blocks):
-            model += [ResnetBlock(ngf * mult, padding_type=padding_type, activation=activation, norm_layer=norm_layer,
-                                  conv_kind=conv_kind)]
-
-        ### upsample
-        for i in range(n_downsampling):
-            mult = 2 ** (n_downsampling - i)
-            model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2), kernel_size=3, stride=2, padding=1,
-                                         output_padding=1),
-                      up_norm_layer(int(ngf * mult / 2)),
-                      up_activation]
-        self.model = nn.Sequential(*model)
-
-        out_layers = []
-        for _ in range(out_extra_layers_n):
-            out_layers += [nn.Conv2d(ngf, ngf, kernel_size=1, padding=0),
-                           up_norm_layer(ngf),
-                           up_activation]
-        out_layers += [nn.ReflectionPad2d(3),
-                       nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]
-
-        if add_out_act:
-            out_layers.append(get_activation('tanh' if add_out_act is True else add_out_act))
-
-        self.out_proj = nn.Sequential(*out_layers)
-
-    def forward(self, input, return_last_act=False):
-        features = self.model(input)
-        out = self.out_proj(features)
-        if return_last_act:
-            return out, features
-        else:
-            return out
-
-
-class MultiscaleResNet(nn.Module):
-    def __init__(self, input_nc, output_nc, ngf=64, n_downsampling=2, n_blocks_head=2, n_blocks_tail=6, n_scales=3,
-                 norm_layer=nn.BatchNorm2d, padding_type='reflect', conv_kind='default', activation=nn.ReLU(True),
-                 up_norm_layer=nn.BatchNorm2d, up_activation=nn.ReLU(True), add_out_act=False, out_extra_layers_n=0,
-                 out_cumulative=False, return_only_hr=False):
-        super().__init__()
-
-        self.heads = nn.ModuleList([ResNetHead(input_nc, ngf=ngf, n_downsampling=n_downsampling,
-                                               n_blocks=n_blocks_head, norm_layer=norm_layer, padding_type=padding_type,
-                                               conv_kind=conv_kind, activation=activation)
-                                    for i in range(n_scales)])
-        tail_in_feats = ngf * (2 ** n_downsampling) + ngf
-        self.tails = nn.ModuleList([ResNetTail(output_nc,
-                                               ngf=ngf, n_downsampling=n_downsampling,
-                                               n_blocks=n_blocks_tail, norm_layer=norm_layer, padding_type=padding_type,
-                                               conv_kind=conv_kind, activation=activation, up_norm_layer=up_norm_layer,
-                                               up_activation=up_activation, add_out_act=add_out_act,
-                                               out_extra_layers_n=out_extra_layers_n,
-                                               add_in_proj=None if (i == n_scales - 1) else tail_in_feats)
-                                    for i in range(n_scales)])
-
-        self.out_cumulative = out_cumulative
-        self.return_only_hr = return_only_hr
-
-    @property
-    def num_scales(self):
-        return len(self.heads)
-
-    def forward(self, ms_inputs: List[torch.Tensor], smallest_scales_num: Optional[int] = None) \
-        -> Union[torch.Tensor, List[torch.Tensor]]:
-        """
-        :param ms_inputs: List of inputs of different resolutions from HR to LR
-        :param smallest_scales_num: int or None, number of smallest scales to take at input
-        :return: Depending on return_only_hr:
-            True: Only the most HR output
-            False: List of outputs of different resolutions from HR to LR
-        """
-        if smallest_scales_num is None:
-            assert len(self.heads) == len(ms_inputs), (len(self.heads), len(ms_inputs), smallest_scales_num)
-            smallest_scales_num = len(self.heads)
-        else:
-            assert smallest_scales_num == len(ms_inputs) <= len(self.heads), (len(self.heads), len(ms_inputs), smallest_scales_num)
-
-        cur_heads = self.heads[-smallest_scales_num:]
-        ms_features = [cur_head(cur_inp) for cur_head, cur_inp in zip(cur_heads, ms_inputs)]
-
-        all_outputs = []
-        prev_tail_features = None
-        for i in range(len(ms_features)):
-            scale_i = -i - 1
-
-            cur_tail_input = ms_features[-i - 1]
-            if prev_tail_features is not None:
-                if prev_tail_features.shape != cur_tail_input.shape:
-                    prev_tail_features = F.interpolate(prev_tail_features, size=cur_tail_input.shape[2:],
-                                                       mode='bilinear', align_corners=False)
-                cur_tail_input = torch.cat((cur_tail_input, prev_tail_features), dim=1)
-
-            cur_out, cur_tail_feats = self.tails[scale_i](cur_tail_input, return_last_act=True)
-
-            prev_tail_features = cur_tail_feats
-            all_outputs.append(cur_out)
-
-        if self.out_cumulative:
-            all_outputs_cum = [all_outputs[0]]
-            for i in range(1, len(ms_features)):
-                cur_out = all_outputs[i]
-                cur_out_cum = cur_out + F.interpolate(all_outputs_cum[-1], size=cur_out.shape[2:],
-                                                      mode='bilinear', align_corners=False)
-                all_outputs_cum.append(cur_out_cum)
-            all_outputs = all_outputs_cum
-
-        if self.return_only_hr:
-            return all_outputs[-1]
-        else:
-            return all_outputs[::-1]
-
-
-class MultiscaleDiscriminatorSimple(nn.Module):
-    def __init__(self, ms_impl):
-        super().__init__()
-        self.ms_impl = nn.ModuleList(ms_impl)
-
-    @property
-    def num_scales(self):
-        return len(self.ms_impl)
-
-    def forward(self, ms_inputs: List[torch.Tensor], smallest_scales_num: Optional[int] = None) \
-            -> List[Tuple[torch.Tensor, List[torch.Tensor]]]:
-        """
-        :param ms_inputs: List of inputs of different resolutions from HR to LR
-        :param smallest_scales_num: int or None, number of smallest scales to take at input
-        :return: List of pairs (prediction, features) for different resolutions from HR to LR
-        """
-        if smallest_scales_num is None:
-            assert len(self.ms_impl) == len(ms_inputs), (len(self.ms_impl), len(ms_inputs), smallest_scales_num)
-            smallest_scales_num = len(self.heads)
-        else:
-            assert smallest_scales_num == len(ms_inputs) <= len(self.ms_impl), \
-                (len(self.ms_impl), len(ms_inputs), smallest_scales_num)
-
-        return [cur_discr(cur_input) for cur_discr, cur_input in zip(self.ms_impl[-smallest_scales_num:], ms_inputs)]
-
-
-class SingleToMultiScaleInputMixin:
-    def forward(self, x: torch.Tensor) -> List:
-        orig_height, orig_width = x.shape[2:]
-        factors = [2 ** i for i in range(self.num_scales)]
-        ms_inputs = [F.interpolate(x, size=(orig_height // f, orig_width // f), mode='bilinear', align_corners=False)
-                     for f in factors]
-        return super().forward(ms_inputs)
-
-
-class GeneratorMultiToSingleOutputMixin:
-    def forward(self, x):
-        return super().forward(x)[0]
-
-
-class DiscriminatorMultiToSingleOutputMixin:
-    def forward(self, x):
-        out_feat_tuples = super().forward(x)
-        return out_feat_tuples[0][0], [f for _, flist in out_feat_tuples for f in flist]
-
-
-class DiscriminatorMultiToSingleOutputStackedMixin:
-    def __init__(self, *args, return_feats_only_levels=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.return_feats_only_levels = return_feats_only_levels
-
-    def forward(self, x):
-        out_feat_tuples = super().forward(x)
-        outs = [out for out, _ in out_feat_tuples]
-        scaled_outs = [outs[0]] + [F.interpolate(cur_out, size=outs[0].shape[-2:],
-                                                 mode='bilinear', align_corners=False)
-                                   for cur_out in outs[1:]]
-        out = torch.cat(scaled_outs, dim=1)
-        if self.return_feats_only_levels is not None:
-            feat_lists = [out_feat_tuples[i][1] for i in self.return_feats_only_levels]
-        else:
-            feat_lists = [flist for _, flist in out_feat_tuples]
-        feats = [f for flist in feat_lists for f in flist]
-        return out, feats
-
-
-class MultiscaleDiscrSingleInput(SingleToMultiScaleInputMixin, DiscriminatorMultiToSingleOutputStackedMixin, MultiscaleDiscriminatorSimple):
-    pass
-
-
-class MultiscaleResNetSingle(GeneratorMultiToSingleOutputMixin, SingleToMultiScaleInputMixin, MultiscaleResNet):
-    pass

spaces/Alpaca233/SadTalker/src/face3d/extract_kp_videos.py

@@ -1,108 +0,0 @@
-import os
-import cv2
-import time
-import glob
-import argparse
-import face_alignment
-import numpy as np
-from PIL import Image
-from tqdm import tqdm
-from itertools import cycle
-
-from torch.multiprocessing import Pool, Process, set_start_method
-
-class KeypointExtractor():
-    def __init__(self, device):
-        self.detector = face_alignment.FaceAlignment(face_alignment.LandmarksType._2D, 
-                                                     device=device)   
-
-    def extract_keypoint(self, images, name=None, info=True):
-        if isinstance(images, list):
-            keypoints = []
-            if info:
-                i_range = tqdm(images,desc='landmark Det:')
-            else:
-                i_range = images
-
-            for image in i_range:
-                current_kp = self.extract_keypoint(image)
-                if np.mean(current_kp) == -1 and keypoints:
-                    keypoints.append(keypoints[-1])
-                else:
-                    keypoints.append(current_kp[None])
-
-            keypoints = np.concatenate(keypoints, 0)
-            np.savetxt(os.path.splitext(name)[0]+'.txt', keypoints.reshape(-1))
-            return keypoints
-        else:
-            while True:
-                try:
-                    keypoints = self.detector.get_landmarks_from_image(np.array(images))[0]
-                    break
-                except RuntimeError as e:
-                    if str(e).startswith('CUDA'):
-                        print("Warning: out of memory, sleep for 1s")
-                        time.sleep(1)
-                    else:
-                        print(e)
-                        break    
-                except TypeError:
-                    print('No face detected in this image')
-                    shape = [68, 2]
-                    keypoints = -1. * np.ones(shape)                    
-                    break
-            if name is not None:
-                np.savetxt(os.path.splitext(name)[0]+'.txt', keypoints.reshape(-1))
-            return keypoints
-
-def read_video(filename):
-    frames = []
-    cap = cv2.VideoCapture(filename)
-    while cap.isOpened():
-        ret, frame = cap.read()
-        if ret:
-            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            frame = Image.fromarray(frame)
-            frames.append(frame)
-        else:
-            break
-    cap.release()
-    return frames
-
-def run(data):
-    filename, opt, device = data
-    os.environ['CUDA_VISIBLE_DEVICES'] = device
-    kp_extractor = KeypointExtractor()
-    images = read_video(filename)
-    name = filename.split('/')[-2:]
-    os.makedirs(os.path.join(opt.output_dir, name[-2]), exist_ok=True)
-    kp_extractor.extract_keypoint(
-        images, 
-        name=os.path.join(opt.output_dir, name[-2], name[-1])
-    )
-
-if __name__ == '__main__':
-    set_start_method('spawn')
-    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument('--input_dir', type=str, help='the folder of the input files')
-    parser.add_argument('--output_dir', type=str, help='the folder of the output files')
-    parser.add_argument('--device_ids', type=str, default='0,1')
-    parser.add_argument('--workers', type=int, default=4)
-
-    opt = parser.parse_args()
-    filenames = list()
-    VIDEO_EXTENSIONS_LOWERCASE = {'mp4'}
-    VIDEO_EXTENSIONS = VIDEO_EXTENSIONS_LOWERCASE.union({f.upper() for f in VIDEO_EXTENSIONS_LOWERCASE})
-    extensions = VIDEO_EXTENSIONS
-    
-    for ext in extensions:
-        os.listdir(f'{opt.input_dir}')
-        print(f'{opt.input_dir}/*.{ext}')
-        filenames = sorted(glob.glob(f'{opt.input_dir}/*.{ext}'))
-    print('Total number of videos:', len(filenames))
-    pool = Pool(opt.workers)
-    args_list = cycle([opt])
-    device_ids = opt.device_ids.split(",")
-    device_ids = cycle(device_ids)
-    for data in tqdm(pool.imap_unordered(run, zip(filenames, args_list, device_ids))):
-        None

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/__init__.py

@@ -1,188 +0,0 @@
-from ..utils import (
-    OptionalDependencyNotAvailable,
-    is_flax_available,
-    is_k_diffusion_available,
-    is_librosa_available,
-    is_note_seq_available,
-    is_onnx_available,
-    is_torch_available,
-    is_transformers_available,
-)
-
-
-try:
-    if not is_torch_available():
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_pt_objects import *  # noqa F403
-else:
-    from .auto_pipeline import AutoPipelineForImage2Image, AutoPipelineForInpainting, AutoPipelineForText2Image
-    from .consistency_models import ConsistencyModelPipeline
-    from .dance_diffusion import DanceDiffusionPipeline
-    from .ddim import DDIMPipeline
-    from .ddpm import DDPMPipeline
-    from .dit import DiTPipeline
-    from .latent_diffusion import LDMSuperResolutionPipeline
-    from .latent_diffusion_uncond import LDMPipeline
-    from .pipeline_utils import AudioPipelineOutput, DiffusionPipeline, ImagePipelineOutput
-    from .pndm import PNDMPipeline
-    from .repaint import RePaintPipeline
-    from .score_sde_ve import ScoreSdeVePipeline
-    from .stochastic_karras_ve import KarrasVePipeline
-
-try:
-    if not (is_torch_available() and is_librosa_available()):
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_torch_and_librosa_objects import *  # noqa F403
-else:
-    from .audio_diffusion import AudioDiffusionPipeline, Mel
-
-try:
-    if not (is_torch_available() and is_transformers_available()):
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_torch_and_transformers_objects import *  # noqa F403
-else:
-    from .alt_diffusion import AltDiffusionImg2ImgPipeline, AltDiffusionPipeline
-    from .audioldm import AudioLDMPipeline
-    from .controlnet import (
-        StableDiffusionControlNetImg2ImgPipeline,
-        StableDiffusionControlNetInpaintPipeline,
-        StableDiffusionControlNetPipeline,
-        StableDiffusionXLControlNetPipeline,
-    )
-    from .deepfloyd_if import (
-        IFImg2ImgPipeline,
-        IFImg2ImgSuperResolutionPipeline,
-        IFInpaintingPipeline,
-        IFInpaintingSuperResolutionPipeline,
-        IFPipeline,
-        IFSuperResolutionPipeline,
-    )
-    from .kandinsky import (
-        KandinskyCombinedPipeline,
-        KandinskyImg2ImgCombinedPipeline,
-        KandinskyImg2ImgPipeline,
-        KandinskyInpaintCombinedPipeline,
-        KandinskyInpaintPipeline,
-        KandinskyPipeline,
-        KandinskyPriorPipeline,
-    )
-    from .kandinsky2_2 import (
-        KandinskyV22CombinedPipeline,
-        KandinskyV22ControlnetImg2ImgPipeline,
-        KandinskyV22ControlnetPipeline,
-        KandinskyV22Img2ImgCombinedPipeline,
-        KandinskyV22Img2ImgPipeline,
-        KandinskyV22InpaintCombinedPipeline,
-        KandinskyV22InpaintPipeline,
-        KandinskyV22Pipeline,
-        KandinskyV22PriorEmb2EmbPipeline,
-        KandinskyV22PriorPipeline,
-    )
-    from .latent_diffusion import LDMTextToImagePipeline
-    from .paint_by_example import PaintByExamplePipeline
-    from .semantic_stable_diffusion import SemanticStableDiffusionPipeline
-    from .shap_e import ShapEImg2ImgPipeline, ShapEPipeline
-    from .stable_diffusion import (
-        CycleDiffusionPipeline,
-        StableDiffusionAttendAndExcitePipeline,
-        StableDiffusionDepth2ImgPipeline,
-        StableDiffusionDiffEditPipeline,
-        StableDiffusionImageVariationPipeline,
-        StableDiffusionImg2ImgPipeline,
-        StableDiffusionInpaintPipeline,
-        StableDiffusionInpaintPipelineLegacy,
-        StableDiffusionInstructPix2PixPipeline,
-        StableDiffusionLatentUpscalePipeline,
-        StableDiffusionLDM3DPipeline,
-        StableDiffusionModelEditingPipeline,
-        StableDiffusionPanoramaPipeline,
-        StableDiffusionParadigmsPipeline,
-        StableDiffusionPipeline,
-        StableDiffusionPix2PixZeroPipeline,
-        StableDiffusionSAGPipeline,
-        StableDiffusionUpscalePipeline,
-        StableUnCLIPImg2ImgPipeline,
-        StableUnCLIPPipeline,
-    )
-    from .stable_diffusion_safe import StableDiffusionPipelineSafe
-    from .stable_diffusion_xl import (
-        StableDiffusionXLImg2ImgPipeline,
-        StableDiffusionXLInpaintPipeline,
-        StableDiffusionXLInstructPix2PixPipeline,
-        StableDiffusionXLPipeline,
-    )
-    from .t2i_adapter import StableDiffusionAdapterPipeline
-    from .text_to_video_synthesis import TextToVideoSDPipeline, TextToVideoZeroPipeline, VideoToVideoSDPipeline
-    from .unclip import UnCLIPImageVariationPipeline, UnCLIPPipeline
-    from .unidiffuser import ImageTextPipelineOutput, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder
-    from .versatile_diffusion import (
-        VersatileDiffusionDualGuidedPipeline,
-        VersatileDiffusionImageVariationPipeline,
-        VersatileDiffusionPipeline,
-        VersatileDiffusionTextToImagePipeline,
-    )
-    from .vq_diffusion import VQDiffusionPipeline
-
-
-try:
-    if not is_onnx_available():
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_onnx_objects import *  # noqa F403
-else:
-    from .onnx_utils import OnnxRuntimeModel
-
-try:
-    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
-else:
-    from .stable_diffusion import (
-        OnnxStableDiffusionImg2ImgPipeline,
-        OnnxStableDiffusionInpaintPipeline,
-        OnnxStableDiffusionInpaintPipelineLegacy,
-        OnnxStableDiffusionPipeline,
-        OnnxStableDiffusionUpscalePipeline,
-        StableDiffusionOnnxPipeline,
-    )
-
-try:
-    if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
-else:
-    from .stable_diffusion import StableDiffusionKDiffusionPipeline
-
-try:
-    if not is_flax_available():
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_flax_objects import *  # noqa F403
-else:
-    from .pipeline_flax_utils import FlaxDiffusionPipeline
-
-
-try:
-    if not (is_flax_available() and is_transformers_available()):
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_flax_and_transformers_objects import *  # noqa F403
-else:
-    from .controlnet import FlaxStableDiffusionControlNetPipeline
-    from .stable_diffusion import (
-        FlaxStableDiffusionImg2ImgPipeline,
-        FlaxStableDiffusionInpaintPipeline,
-        FlaxStableDiffusionPipeline,
-    )
-try:
-    if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
-        raise OptionalDependencyNotAvailable()
-except OptionalDependencyNotAvailable:
-    from ..utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
-else:
-    from .spectrogram_diffusion import MidiProcessor, SpectrogramDiffusionPipeline

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

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

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/schedulers/test_scheduler_euler.py

@@ -1,146 +0,0 @@
-import torch
-
-from diffusers import EulerDiscreteScheduler
-from diffusers.utils import torch_device
-
-from .test_schedulers import SchedulerCommonTest
-
-
-class EulerDiscreteSchedulerTest(SchedulerCommonTest):
-    scheduler_classes = (EulerDiscreteScheduler,)
-    num_inference_steps = 10
-
-    def get_scheduler_config(self, **kwargs):
-        config = {
-            "num_train_timesteps": 1100,
-            "beta_start": 0.0001,
-            "beta_end": 0.02,
-            "beta_schedule": "linear",
-        }
-
-        config.update(**kwargs)
-        return config
-
-    def test_timesteps(self):
-        for timesteps in [10, 50, 100, 1000]:
-            self.check_over_configs(num_train_timesteps=timesteps)
-
-    def test_betas(self):
-        for beta_start, beta_end in zip([0.00001, 0.0001, 0.001], [0.0002, 0.002, 0.02]):
-            self.check_over_configs(beta_start=beta_start, beta_end=beta_end)
-
-    def test_schedules(self):
-        for schedule in ["linear", "scaled_linear"]:
-            self.check_over_configs(beta_schedule=schedule)
-
-    def test_prediction_type(self):
-        for prediction_type in ["epsilon", "v_prediction"]:
-            self.check_over_configs(prediction_type=prediction_type)
-
-    def test_full_loop_no_noise(self):
-        scheduler_class = self.scheduler_classes[0]
-        scheduler_config = self.get_scheduler_config()
-        scheduler = scheduler_class(**scheduler_config)
-
-        scheduler.set_timesteps(self.num_inference_steps)
-
-        generator = torch.manual_seed(0)
-
-        model = self.dummy_model()
-        sample = self.dummy_sample_deter * scheduler.init_noise_sigma
-        sample = sample.to(torch_device)
-
-        for i, t in enumerate(scheduler.timesteps):
-            sample = scheduler.scale_model_input(sample, t)
-
-            model_output = model(sample, t)
-
-            output = scheduler.step(model_output, t, sample, generator=generator)
-            sample = output.prev_sample
-
-        result_sum = torch.sum(torch.abs(sample))
-        result_mean = torch.mean(torch.abs(sample))
-
-        assert abs(result_sum.item() - 10.0807) < 1e-2
-        assert abs(result_mean.item() - 0.0131) < 1e-3
-
-    def test_full_loop_with_v_prediction(self):
-        scheduler_class = self.scheduler_classes[0]
-        scheduler_config = self.get_scheduler_config(prediction_type="v_prediction")
-        scheduler = scheduler_class(**scheduler_config)
-
-        scheduler.set_timesteps(self.num_inference_steps)
-
-        generator = torch.manual_seed(0)
-
-        model = self.dummy_model()
-        sample = self.dummy_sample_deter * scheduler.init_noise_sigma
-        sample = sample.to(torch_device)
-
-        for i, t in enumerate(scheduler.timesteps):
-            sample = scheduler.scale_model_input(sample, t)
-
-            model_output = model(sample, t)
-
-            output = scheduler.step(model_output, t, sample, generator=generator)
-            sample = output.prev_sample
-
-        result_sum = torch.sum(torch.abs(sample))
-        result_mean = torch.mean(torch.abs(sample))
-
-        assert abs(result_sum.item() - 0.0002) < 1e-2
-        assert abs(result_mean.item() - 2.2676e-06) < 1e-3
-
-    def test_full_loop_device(self):
-        scheduler_class = self.scheduler_classes[0]
-        scheduler_config = self.get_scheduler_config()
-        scheduler = scheduler_class(**scheduler_config)
-
-        scheduler.set_timesteps(self.num_inference_steps, device=torch_device)
-
-        generator = torch.manual_seed(0)
-
-        model = self.dummy_model()
-        sample = self.dummy_sample_deter * scheduler.init_noise_sigma.cpu()
-        sample = sample.to(torch_device)
-
-        for t in scheduler.timesteps:
-            sample = scheduler.scale_model_input(sample, t)
-
-            model_output = model(sample, t)
-
-            output = scheduler.step(model_output, t, sample, generator=generator)
-            sample = output.prev_sample
-
-        result_sum = torch.sum(torch.abs(sample))
-        result_mean = torch.mean(torch.abs(sample))
-
-        assert abs(result_sum.item() - 10.0807) < 1e-2
-        assert abs(result_mean.item() - 0.0131) < 1e-3
-
-    def test_full_loop_device_karras_sigmas(self):
-        scheduler_class = self.scheduler_classes[0]
-        scheduler_config = self.get_scheduler_config()
-        scheduler = scheduler_class(**scheduler_config, use_karras_sigmas=True)
-
-        scheduler.set_timesteps(self.num_inference_steps, device=torch_device)
-
-        generator = torch.manual_seed(0)
-
-        model = self.dummy_model()
-        sample = self.dummy_sample_deter * scheduler.init_noise_sigma.cpu()
-        sample = sample.to(torch_device)
-
-        for t in scheduler.timesteps:
-            sample = scheduler.scale_model_input(sample, t)
-
-            model_output = model(sample, t)
-
-            output = scheduler.step(model_output, t, sample, generator=generator)
-            sample = output.prev_sample
-
-        result_sum = torch.sum(torch.abs(sample))
-        result_mean = torch.mean(torch.abs(sample))
-
-        assert abs(result_sum.item() - 124.52299499511719) < 1e-2
-        assert abs(result_mean.item() - 0.16213932633399963) < 1e-3

spaces/Andy1621/uniformer_image_segmentation/configs/emanet/emanet_r101-d8_769x769_80k_cityscapes.py

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

spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_d6_r50b-d16_512x1024_80k_cityscapes.py

@@ -1,2 +0,0 @@
-_base_ = './fcn_d6_r50-d16_512x1024_80k_cityscapes.py'
-model = dict(pretrained='torchvision://resnet50', backbone=dict(type='ResNet'))

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

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

spaces/Anonymous-sub/Rerender/flow/flow_utils.py

@@ -1,218 +0,0 @@
-import os
-import sys
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-
-parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-gmflow_dir = os.path.join(parent_dir, 'gmflow_module')
-sys.path.insert(0, gmflow_dir)
-
-from gmflow.gmflow import GMFlow  # noqa: E702 E402 F401
-from utils.utils import InputPadder  # noqa: E702 E402
-
-import huggingface_hub
-
-repo_name = 'Anonymous-sub/Rerender'
-
-global_device = 'cuda' if torch.cuda.is_available() else 'cpu'
-gmflow_path = huggingface_hub.hf_hub_download(
-    repo_name, 'models/gmflow_sintel-0c07dcb3.pth', local_dir='./')
-
-
-def coords_grid(b, h, w, homogeneous=False, device=None):
-    y, x = torch.meshgrid(torch.arange(h), torch.arange(w))  # [H, W]
-
-    stacks = [x, y]
-
-    if homogeneous:
-        ones = torch.ones_like(x)  # [H, W]
-        stacks.append(ones)
-
-    grid = torch.stack(stacks, dim=0).float()  # [2, H, W] or [3, H, W]
-
-    grid = grid[None].repeat(b, 1, 1, 1)  # [B, 2, H, W] or [B, 3, H, W]
-
-    if device is not None:
-        grid = grid.to(global_device)
-
-    return grid
-
-
-def bilinear_sample(img,
-                    sample_coords,
-                    mode='bilinear',
-                    padding_mode='zeros',
-                    return_mask=False):
-    # img: [B, C, H, W]
-    # sample_coords: [B, 2, H, W] in image scale
-    if sample_coords.size(1) != 2:  # [B, H, W, 2]
-        sample_coords = sample_coords.permute(0, 3, 1, 2)
-
-    b, _, h, w = sample_coords.shape
-
-    # Normalize to [-1, 1]
-    x_grid = 2 * sample_coords[:, 0] / (w - 1) - 1
-    y_grid = 2 * sample_coords[:, 1] / (h - 1) - 1
-
-    grid = torch.stack([x_grid, y_grid], dim=-1)  # [B, H, W, 2]
-
-    img = F.grid_sample(img,
-                        grid,
-                        mode=mode,
-                        padding_mode=padding_mode,
-                        align_corners=True)
-
-    if return_mask:
-        mask = (x_grid >= -1) & (y_grid >= -1) & (x_grid <= 1) & (
-            y_grid <= 1)  # [B, H, W]
-
-        return img, mask
-
-    return img
-
-
-def flow_warp(feature,
-              flow,
-              mask=False,
-              mode='bilinear',
-              padding_mode='zeros'):
-    b, c, h, w = feature.size()
-    assert flow.size(1) == 2
-
-    grid = coords_grid(b, h, w).to(flow.device) + flow  # [B, 2, H, W]
-
-    return bilinear_sample(feature,
-                           grid,
-                           mode=mode,
-                           padding_mode=padding_mode,
-                           return_mask=mask)
-
-
-def forward_backward_consistency_check(fwd_flow,
-                                       bwd_flow,
-                                       alpha=0.01,
-                                       beta=0.5):
-    # fwd_flow, bwd_flow: [B, 2, H, W]
-    # alpha and beta values are following UnFlow
-    # (https://arxiv.org/abs/1711.07837)
-    assert fwd_flow.dim() == 4 and bwd_flow.dim() == 4
-    assert fwd_flow.size(1) == 2 and bwd_flow.size(1) == 2
-    flow_mag = torch.norm(fwd_flow, dim=1) + torch.norm(bwd_flow,
-                                                        dim=1)  # [B, H, W]
-
-    warped_bwd_flow = flow_warp(bwd_flow, fwd_flow)  # [B, 2, H, W]
-    warped_fwd_flow = flow_warp(fwd_flow, bwd_flow)  # [B, 2, H, W]
-
-    diff_fwd = torch.norm(fwd_flow + warped_bwd_flow, dim=1)  # [B, H, W]
-    diff_bwd = torch.norm(bwd_flow + warped_fwd_flow, dim=1)
-
-    threshold = alpha * flow_mag + beta
-
-    fwd_occ = (diff_fwd > threshold).float()  # [B, H, W]
-    bwd_occ = (diff_bwd > threshold).float()
-
-    return fwd_occ, bwd_occ
-
-
-@torch.no_grad()
-def get_warped_and_mask(flow_model,
-                        image1,
-                        image2,
-                        image3=None,
-                        pixel_consistency=False):
-    if image3 is None:
-        image3 = image1
-    padder = InputPadder(image1.shape, padding_factor=8)
-    image1, image2 = padder.pad(image1[None].to(global_device),
-                                image2[None].to(global_device))
-    results_dict = flow_model(image1,
-                              image2,
-                              attn_splits_list=[2],
-                              corr_radius_list=[-1],
-                              prop_radius_list=[-1],
-                              pred_bidir_flow=True)
-    flow_pr = results_dict['flow_preds'][-1]  # [B, 2, H, W]
-    fwd_flow = padder.unpad(flow_pr[0]).unsqueeze(0)  # [1, 2, H, W]
-    bwd_flow = padder.unpad(flow_pr[1]).unsqueeze(0)  # [1, 2, H, W]
-    fwd_occ, bwd_occ = forward_backward_consistency_check(
-        fwd_flow, bwd_flow)  # [1, H, W] float
-    if pixel_consistency:
-        warped_image1 = flow_warp(image1, bwd_flow)
-        bwd_occ = torch.clamp(
-            bwd_occ +
-            (abs(image2 - warped_image1).mean(dim=1) > 255 * 0.25).float(), 0,
-            1).unsqueeze(0)
-    warped_results = flow_warp(image3, bwd_flow)
-    return warped_results, bwd_occ, bwd_flow
-
-
-class FlowCalc():
-
-    def __init__(self, model_path='./models/gmflow_sintel-0c07dcb3.pth'):
-        flow_model = GMFlow(
-            feature_channels=128,
-            num_scales=1,
-            upsample_factor=8,
-            num_head=1,
-            attention_type='swin',
-            ffn_dim_expansion=4,
-            num_transformer_layers=6,
-        ).to(global_device)
-        checkpoint = torch.load(model_path,
-                                map_location=lambda storage, loc: storage)
-        weights = checkpoint['model'] if 'model' in checkpoint else checkpoint
-        flow_model.load_state_dict(weights, strict=False)
-        flow_model.eval()
-        self.model = flow_model
-
-    @torch.no_grad()
-    def get_flow(self, image1, image2, save_path=None):
-        if save_path is not None and os.path.exists(save_path):
-            bwd_flow = read_flow(save_path)
-            return bwd_flow
-
-        image1 = torch.from_numpy(image1).permute(2, 0, 1).float()
-        image2 = torch.from_numpy(image2).permute(2, 0, 1).float()
-        padder = InputPadder(image1.shape, padding_factor=8)
-        image1, image2 = padder.pad(image1[None].to(global_device),
-                                    image2[None].to(global_device))
-        results_dict = self.model(image1,
-                                  image2,
-                                  attn_splits_list=[2],
-                                  corr_radius_list=[-1],
-                                  prop_radius_list=[-1],
-                                  pred_bidir_flow=True)
-        flow_pr = results_dict['flow_preds'][-1]  # [B, 2, H, W]
-        bwd_flow = padder.unpad(flow_pr[1]).unsqueeze(0)  # [1, 2, H, W]
-        if save_path is not None:
-            flow_np = bwd_flow.cpu().numpy()
-            np.save(save_path, flow_np)
-
-        return bwd_flow
-
-    def warp(self, img, flow, mode='bilinear'):
-        expand = False
-        if len(img.shape) == 2:
-            expand = True
-            img = np.expand_dims(img, 2)
-
-        img = torch.from_numpy(img).permute(2, 0, 1).unsqueeze(0)
-        dtype = img.dtype
-        img = img.to(torch.float)
-        res = flow_warp(img, flow, mode=mode)
-        res = res.to(dtype)
-        res = res[0].cpu().permute(1, 2, 0).numpy()
-        if expand:
-            res = res[:, :, 0]
-        return res
-
-
-def read_flow(save_path):
-    flow_np = np.load(save_path)
-    bwd_flow = torch.from_numpy(flow_np)
-    return bwd_flow
-
-
-flow_calc = FlowCalc()

spaces/AnthonyTruchetPoC/persistent-docker/scripts/run-coverage.sh

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-poetry run coverage run --parallel -m pytest
-poetry run coverage combine
-poetry run coverage report

spaces/Apex-X/nono/app.py

@@ -1,69 +0,0 @@
-# -* coding:UTF-8 -*
-# !/usr/bin/env python
-import numpy as np
-import gradio as gr
-import roop.globals
-from roop.core import (
-    start,
-    decode_execution_providers,
-    suggest_max_memory,
-    suggest_execution_threads,
-)
-from roop.processors.frame.core import get_frame_processors_modules
-from roop.utilities import normalize_output_path
-import os
-from PIL import Image
-
-
-def swap_face(source_file, target_file):
-
-    source_path = "input.jpg"
-    target_path = "target.jpg"
-
-    source_image = Image.fromarray(source_file)
-    source_image.save(source_path)
-    target_image = Image.fromarray(target_file)
-    target_image.save(target_path)
-
-    print("source_path: ", source_path)
-    print("target_path: ", target_path)
-
-    roop.globals.source_path = source_path
-    roop.globals.target_path = target_path
-    output_path = "output.jpg"
-    roop.globals.output_path = normalize_output_path(
-        roop.globals.source_path, roop.globals.target_path, output_path
-    )
-    roop.globals.frame_processors = ["face_swapper"]
-    roop.globals.headless = True
-    roop.globals.keep_fps = True
-    roop.globals.keep_audio = True
-    roop.globals.keep_frames = False
-    roop.globals.many_faces = False
-    roop.globals.video_encoder = "libx264"
-    roop.globals.video_quality = 18
-    roop.globals.max_memory = suggest_max_memory()
-    roop.globals.execution_providers = decode_execution_providers(["cpu"])
-    roop.globals.execution_threads = suggest_execution_threads()
-
-    print(
-        "start process",
-        roop.globals.source_path,
-        roop.globals.target_path,
-        roop.globals.output_path,
-    )
-
-    for frame_processor in get_frame_processors_modules(
-        roop.globals.frame_processors
-    ):
-        if not frame_processor.pre_check():
-            return
-
-    start()
-    return output_path
-
-
-app = gr.Interface(
-    fn=swap_face, inputs=[gr.Image(), gr.Image()], outputs="image"
-)
-app.launch()

spaces/Aqdas/YouTube_Video_OpenAI_whisper/whisper.py

@@ -1,18 +0,0 @@
-def dowload_youtube_video(url):
-    from pytube import YouTube
-    yt = YouTube(url)
-    global audio_stream
-    audio_stream = yt.streams.filter(only_audio=True, file_extension='mp4').first()
-    audio_stream.download()
-    return 'download successfully'
-
-
-def transcribe_audio():
-    import openai
-    from openai import OpenAI
-    import os
-    client = OpenAI(api_key=os.environ['openai_api_key']) 
-    file = open(audio_stream.default_filename, "rb")
-    transcription = client.audio.transcriptions.create(model="whisper-1", file=file, response_format='text', language='ur')
-    
-    return transcription

spaces/Artrajz/vits-simple-api/logger.py

@@ -1,40 +0,0 @@
-import os
-import sys
-import logging
-import logzero
-import config
-from logging.handlers import TimedRotatingFileHandler
-
-logzero.loglevel(logging.WARNING)
-logger = logging.getLogger("vits-simple-api")
-level = getattr(config, "LOGGING_LEVEL", "DEBUG")
-level_dict = {'DEBUG': logging.DEBUG, 'INFO': logging.INFO, 'WARNING': logging.WARNING, 'ERROR': logging.ERROR,
-              'CRITICAL': logging.CRITICAL}
-logging.basicConfig(level=level_dict[level])
-logging.getLogger('numba').setLevel(logging.WARNING)
-logging.getLogger("langid.langid").setLevel(logging.INFO)
-logging.getLogger("apscheduler.scheduler").setLevel(logging.INFO)
-
-os.makedirs(config.LOGS_PATH, exist_ok=True)
-log_file = os.path.join(config.LOGS_PATH, 'latest.log')
-backup_count = getattr(config, "LOGS_BACKUPCOUNT", 30)
-handler = TimedRotatingFileHandler(log_file, when="midnight", interval=1, backupCount=backup_count, encoding='utf-8')
-handler.suffix = "%Y-%m-%d.log"
-formatter = logging.Formatter('%(levelname)s:%(name)s %(message)s')
-handler.setFormatter(formatter)
-
-logging.getLogger().addHandler(handler)
-
-
-# Custom function to handle uncaught exceptions
-def handle_exception(exc_type, exc_value, exc_traceback):
-    # If it's a keyboard interrupt, don't handle it, just return
-    if issubclass(exc_type, KeyboardInterrupt):
-        sys.__excepthook__(exc_type, exc_value, exc_traceback)
-        return
-
-    logger.error("Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
-
-
-# Set the global exception handler in Python
-sys.excepthook = handle_exception

spaces/AsakuraMizu/moe-tts/text/ngu_dialect.py

@@ -1,30 +0,0 @@
-import re
-import opencc
-
-
-dialects = {'SZ': 'suzhou', 'WX': 'wuxi', 'CZ': 'changzhou', 'HZ': 'hangzhou',
-            'SX': 'shaoxing', 'NB': 'ningbo', 'JJ': 'jingjiang', 'YX': 'yixing',
-            'JD': 'jiading', 'ZR': 'zhenru', 'PH': 'pinghu', 'TX': 'tongxiang',
-            'JS': 'jiashan', 'HN': 'xiashi', 'LP': 'linping', 'XS': 'xiaoshan',
-            'FY': 'fuyang', 'RA': 'ruao', 'CX': 'cixi', 'SM': 'sanmen',
-            'TT': 'tiantai', 'WZ': 'wenzhou', 'SC': 'suichang', 'YB': 'youbu'}
-
-converters = {}
-
-for dialect in dialects.values():
-    try:
-        converters[dialect] = opencc.OpenCC("chinese_dialect_lexicons/"+dialect)
-    except:
-        pass
-
-
-def ngu_dialect_to_ipa(text, dialect):
-    dialect = dialects[dialect]
-    text = converters[dialect].convert(text).replace('-','').replace('$',' ')
-    text = re.sub(r'[、；：]', '，', text)
-    text = re.sub(r'\s*，\s*', ', ', text)
-    text = re.sub(r'\s*。\s*', '. ', text)
-    text = re.sub(r'\s*？\s*', '? ', text)
-    text = re.sub(r'\s*！\s*', '! ', text)
-    text = re.sub(r'\s*$', '', text)
-    return text

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/README_D2.md

@@ -1,62 +0,0 @@
-<img src=".github/Detectron2-Logo-Horz.svg" width="300" >
-
-Detectron2 is Facebook AI Research's next generation software system
-that implements state-of-the-art object detection algorithms.
-It is a ground-up rewrite of the previous version,
-[Detectron](https://github.com/facebookresearch/Detectron/),
-and it originates from [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark/).
-
-<div align="center">
-  <img src="https://user-images.githubusercontent.com/1381301/66535560-d3422200-eace-11e9-9123-5535d469db19.png"/>
-</div>
-
-### What's New
-* It is powered by the [PyTorch](https://pytorch.org) deep learning framework.
-* Includes more features such as panoptic segmentation, Densepose, Cascade R-CNN, rotated bounding boxes, PointRend,
-  DeepLab, etc.
-* Can be used as a library to support [different projects](projects/) on top of it.
-  We'll open source more research projects in this way.
-* It [trains much faster](https://detectron2.readthedocs.io/notes/benchmarks.html).
-* Models can be exported to TorchScript format or Caffe2 format for deployment.
-
-See our [blog post](https://ai.facebook.com/blog/-detectron2-a-pytorch-based-modular-object-detection-library-/)
-to see more demos and learn about detectron2.
-
-## Installation
-
-See [INSTALL.md](INSTALL.md).
-
-## Getting Started
-
-Follow the [installation instructions](https://detectron2.readthedocs.io/tutorials/install.html) to
-install detectron2.
-
-See [Getting Started with Detectron2](https://detectron2.readthedocs.io/tutorials/getting_started.html),
-and the [Colab Notebook](https://colab.research.google.com/drive/16jcaJoc6bCFAQ96jDe2HwtXj7BMD_-m5)
-to learn about basic usage.
-
-Learn more at our [documentation](https://detectron2.readthedocs.org).
-And see [projects/](projects/) for some projects that are built on top of detectron2.
-
-## Model Zoo and Baselines
-
-We provide a large set of baseline results and trained models available for download in the [Detectron2 Model Zoo](MODEL_ZOO.md).
-
-
-## License
-
-Detectron2 is released under the [Apache 2.0 license](LICENSE).
-
-## Citing Detectron2
-
-If you use Detectron2 in your research or wish to refer to the baseline results published in the [Model Zoo](MODEL_ZOO.md), please use the following BibTeX entry.
-
-```BibTeX
-@misc{wu2019detectron2,
-  author =       {Yuxin Wu and Alexander Kirillov and Francisco Massa and
-                  Wan-Yen Lo and Ross Girshick},
-  title =        {Detectron2},
-  howpublished = {\url{https://github.com/facebookresearch/detectron2}},
-  year =         {2019}
-}
-```

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/projects/CenterNet2/centernet/modeling/backbone/bifpn.py

@@ -1,425 +0,0 @@
-# Modified from https://github.com/rwightman/efficientdet-pytorch/blob/master/effdet/efficientdet.py
-# The original file is under Apache-2.0 License
-import math
-from os.path import join
-import numpy as np
-from collections import OrderedDict
-from typing import List
-
-import torch
-from torch import nn
-import torch.utils.model_zoo as model_zoo
-import torch.nn.functional as F
-import fvcore.nn.weight_init as weight_init
-
-from detectron2.layers import ShapeSpec, Conv2d
-from detectron2.modeling.backbone.resnet import build_resnet_backbone
-from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
-from detectron2.layers.batch_norm import get_norm
-from detectron2.modeling.backbone import Backbone
-from .dlafpn import dla34
-
-def get_fpn_config(base_reduction=8):
-    """BiFPN config with sum."""
-    p = {
-        'nodes': [
-            {'reduction': base_reduction << 3, 'inputs_offsets': [3, 4]},
-            {'reduction': base_reduction << 2, 'inputs_offsets': [2, 5]},
-            {'reduction': base_reduction << 1, 'inputs_offsets': [1, 6]},
-            {'reduction': base_reduction, 'inputs_offsets': [0, 7]},
-            {'reduction': base_reduction << 1, 'inputs_offsets': [1, 7, 8]},
-            {'reduction': base_reduction << 2, 'inputs_offsets': [2, 6, 9]},
-            {'reduction': base_reduction << 3, 'inputs_offsets': [3, 5, 10]},
-            {'reduction': base_reduction << 4, 'inputs_offsets': [4, 11]},
-        ],
-        'weight_method': 'fastattn',
-    }
-    return p
-
-
-def swish(x, inplace: bool = False):
-    """Swish - Described in: https://arxiv.org/abs/1710.05941
-    """
-    return x.mul_(x.sigmoid()) if inplace else x.mul(x.sigmoid())
-
-
-class Swish(nn.Module):
-    def __init__(self, inplace: bool = False):
-        super(Swish, self).__init__()
-        self.inplace = inplace
-
-    def forward(self, x):
-        return swish(x, self.inplace)
-
-
-class SequentialAppend(nn.Sequential):
-    def __init__(self, *args):
-        super(SequentialAppend, self).__init__(*args)
-
-    def forward(self, x):
-        for module in self:
-            x.append(module(x))
-        return x
-
-
-class SequentialAppendLast(nn.Sequential):
-    def __init__(self, *args):
-        super(SequentialAppendLast, self).__init__(*args)
-
-    # def forward(self, x: List[torch.Tensor]):
-    def forward(self, x):
-        for module in self:
-            x.append(module(x[-1]))
-        return x
-
-
-class ConvBnAct2d(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1, padding='', bias=False,
-                 norm='', act_layer=Swish):
-        super(ConvBnAct2d, self).__init__()
-        # self.conv = create_conv2d(
-        #     in_channels, out_channels, kernel_size, stride=stride, dilation=dilation, padding=padding, bias=bias)
-        self.conv = Conv2d(
-            in_channels, out_channels, kernel_size=kernel_size, stride=stride, 
-            padding=kernel_size // 2, bias=(norm == ''))
-        self.bn = get_norm(norm, out_channels)
-        self.act = None if act_layer is None else act_layer(inplace=True)
-
-    def forward(self, x):
-        x = self.conv(x)
-        if self.bn is not None:
-            x = self.bn(x)
-        if self.act is not None:
-            x = self.act(x)
-        return x
-
-
-class SeparableConv2d(nn.Module):
-    """ Separable Conv
-    """
-    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1, padding='', bias=False,
-                 channel_multiplier=1.0, pw_kernel_size=1, act_layer=Swish,
-                 norm=''):
-        super(SeparableConv2d, self).__init__()
-
-        # self.conv_dw = create_conv2d(
-        #     in_channels, int(in_channels * channel_multiplier), kernel_size,
-        #     stride=stride, dilation=dilation, padding=padding, depthwise=True)
-
-        self.conv_dw = Conv2d(
-            in_channels, int(in_channels * channel_multiplier), 
-            kernel_size=kernel_size, stride=stride, padding=kernel_size // 2, bias=bias,
-            groups=out_channels)
-        # print('conv_dw', kernel_size, stride) 
-        # self.conv_pw = create_conv2d(
-        #     int(in_channels * channel_multiplier), out_channels, pw_kernel_size, padding=padding, bias=bias)
-        
-        self.conv_pw = Conv2d(
-            int(in_channels * channel_multiplier), out_channels, 
-            kernel_size=pw_kernel_size, padding=pw_kernel_size // 2, bias=(norm==''))
-        # print('conv_pw', pw_kernel_size) 
-
-        self.bn = get_norm(norm, out_channels)
-        self.act = None if act_layer is None else act_layer(inplace=True)
-
-    def forward(self, x):
-        x = self.conv_dw(x)
-        x = self.conv_pw(x)
-        if self.bn is not None:
-            x = self.bn(x)
-        if self.act is not None:
-            x = self.act(x)
-        return x
-
-
-class ResampleFeatureMap(nn.Sequential):
-    def __init__(self, in_channels, out_channels, reduction_ratio=1., pad_type='', pooling_type='max',
-                 norm='', apply_bn=False, conv_after_downsample=False,
-                 redundant_bias=False):
-        super(ResampleFeatureMap, self).__init__()
-        pooling_type = pooling_type or 'max'
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.reduction_ratio = reduction_ratio
-        self.conv_after_downsample = conv_after_downsample
-
-        conv = None
-        if in_channels != out_channels:
-            conv = ConvBnAct2d(
-                in_channels, out_channels, kernel_size=1, padding=pad_type,
-                norm=norm if apply_bn else '', 
-                bias=not apply_bn or redundant_bias, act_layer=None)
-
-        if reduction_ratio > 1:
-            stride_size = int(reduction_ratio)
-            if conv is not None and not self.conv_after_downsample:
-                self.add_module('conv', conv)
-            self.add_module(
-                'downsample',
-                # create_pool2d(
-                #     pooling_type, kernel_size=stride_size + 1, stride=stride_size, padding=pad_type)
-                # nn.MaxPool2d(kernel_size=stride_size + 1, stride=stride_size, padding=pad_type)
-                nn.MaxPool2d(kernel_size=stride_size, stride=stride_size)
-                )
-            if conv is not None and self.conv_after_downsample:
-                self.add_module('conv', conv)
-        else:
-            if conv is not None:
-                self.add_module('conv', conv)
-            if reduction_ratio < 1:
-                scale = int(1 // reduction_ratio)
-                self.add_module('upsample', nn.UpsamplingNearest2d(scale_factor=scale))
-
-
-class FpnCombine(nn.Module):
-    def __init__(self, feature_info, fpn_config, fpn_channels, inputs_offsets, target_reduction, pad_type='',
-                 pooling_type='max', norm='', apply_bn_for_resampling=False,
-                 conv_after_downsample=False, redundant_bias=False, weight_method='attn'):
-        super(FpnCombine, self).__init__()
-        self.inputs_offsets = inputs_offsets
-        self.weight_method = weight_method
-
-        self.resample = nn.ModuleDict()
-        for idx, offset in enumerate(inputs_offsets):
-            in_channels = fpn_channels
-            if offset < len(feature_info):
-                in_channels = feature_info[offset]['num_chs']
-                input_reduction = feature_info[offset]['reduction']
-            else:
-                node_idx = offset - len(feature_info)
-                # print('node_idx, len', node_idx, len(fpn_config['nodes']))
-                input_reduction = fpn_config['nodes'][node_idx]['reduction']
-            reduction_ratio = target_reduction / input_reduction
-            self.resample[str(offset)] = ResampleFeatureMap(
-                in_channels, fpn_channels, reduction_ratio=reduction_ratio, pad_type=pad_type,
-                pooling_type=pooling_type, norm=norm,
-                apply_bn=apply_bn_for_resampling, conv_after_downsample=conv_after_downsample,
-                redundant_bias=redundant_bias)
-
-        if weight_method == 'attn' or weight_method == 'fastattn':
-            # WSM
-            self.edge_weights = nn.Parameter(torch.ones(len(inputs_offsets)), requires_grad=True)
-        else:
-            self.edge_weights = None
-
-    def forward(self, x):
-        dtype = x[0].dtype
-        nodes = []
-        for offset in self.inputs_offsets:
-            input_node = x[offset]
-            input_node = self.resample[str(offset)](input_node)
-            nodes.append(input_node)
-
-        if self.weight_method == 'attn':
-            normalized_weights = torch.softmax(self.edge_weights.type(dtype), dim=0)
-            x = torch.stack(nodes, dim=-1) * normalized_weights
-        elif self.weight_method == 'fastattn':
-            edge_weights = nn.functional.relu(self.edge_weights.type(dtype))
-            weights_sum = torch.sum(edge_weights)
-            x = torch.stack(
-                [(nodes[i] * edge_weights[i]) / (weights_sum + 0.0001) for i in range(len(nodes))], dim=-1)
-        elif self.weight_method == 'sum':
-            x = torch.stack(nodes, dim=-1)
-        else:
-            raise ValueError('unknown weight_method {}'.format(self.weight_method))
-        x = torch.sum(x, dim=-1)
-        return x
-
-
-class BiFpnLayer(nn.Module):
-    def __init__(self, feature_info, fpn_config, fpn_channels, num_levels=5, pad_type='',
-                 pooling_type='max', norm='', act_layer=Swish,
-                 apply_bn_for_resampling=False, conv_after_downsample=True, conv_bn_relu_pattern=False,
-                 separable_conv=True, redundant_bias=False):
-        super(BiFpnLayer, self).__init__()
-        self.fpn_config = fpn_config
-        self.num_levels = num_levels
-        self.conv_bn_relu_pattern = False
-
-        self.feature_info = []
-        self.fnode = SequentialAppend()
-        for i, fnode_cfg in enumerate(fpn_config['nodes']):
-            # logging.debug('fnode {} : {}'.format(i, fnode_cfg))
-            # print('fnode {} : {}'.format(i, fnode_cfg))
-            fnode_layers = OrderedDict()
-
-            # combine features
-            reduction = fnode_cfg['reduction']
-            fnode_layers['combine'] = FpnCombine(
-                feature_info, fpn_config, fpn_channels, fnode_cfg['inputs_offsets'], target_reduction=reduction,
-                pad_type=pad_type, pooling_type=pooling_type, norm=norm,
-                apply_bn_for_resampling=apply_bn_for_resampling, conv_after_downsample=conv_after_downsample,
-                redundant_bias=redundant_bias, weight_method=fpn_config['weight_method'])
-            self.feature_info.append(dict(num_chs=fpn_channels, reduction=reduction))
-
-            # after combine ops
-            after_combine = OrderedDict()
-            if not conv_bn_relu_pattern:
-                after_combine['act'] = act_layer(inplace=True)
-                conv_bias = redundant_bias
-                conv_act = None
-            else:
-                conv_bias = False
-                conv_act = act_layer
-            conv_kwargs = dict(
-                in_channels=fpn_channels, out_channels=fpn_channels, kernel_size=3, padding=pad_type,
-                bias=conv_bias, norm=norm, act_layer=conv_act)
-            after_combine['conv'] = SeparableConv2d(**conv_kwargs) if separable_conv else ConvBnAct2d(**conv_kwargs)
-            fnode_layers['after_combine'] = nn.Sequential(after_combine)
-
-            self.fnode.add_module(str(i), nn.Sequential(fnode_layers))
-
-        self.feature_info = self.feature_info[-num_levels::]
-
-    def forward(self, x):
-        x = self.fnode(x)
-        return x[-self.num_levels::]
-
-
-class BiFPN(Backbone):
-    def __init__(
-        self, cfg, bottom_up, in_features, out_channels, norm='', 
-        num_levels=5, num_bifpn=4, separable_conv=False,
-    ):
-        super(BiFPN, self).__init__()
-        assert isinstance(bottom_up, Backbone)
-        
-        # Feature map strides and channels from the bottom up network (e.g. ResNet)
-        input_shapes = bottom_up.output_shape()
-        in_strides = [input_shapes[f].stride for f in in_features]
-        in_channels = [input_shapes[f].channels for f in in_features]
-
-        self.num_levels = num_levels
-        self.num_bifpn = num_bifpn
-        self.bottom_up = bottom_up
-        self.in_features = in_features
-        self._size_divisibility = 128
-        levels = [int(math.log2(s)) for s in in_strides]
-        self._out_feature_strides = {
-            "p{}".format(int(math.log2(s))): s for s in in_strides}
-        if len(in_features) < num_levels:
-            for l in range(num_levels - len(in_features)):
-                s = l + levels[-1]
-                self._out_feature_strides["p{}".format(s + 1)] = 2 ** (s + 1)
-        self._out_features = list(sorted(self._out_feature_strides.keys()))
-        self._out_feature_channels = {k: out_channels for k in self._out_features}
-        
-        # print('self._out_feature_strides', self._out_feature_strides)
-        # print('self._out_feature_channels', self._out_feature_channels)
-        
-        feature_info = [
-            {'num_chs': in_channels[level], 'reduction': in_strides[level]} \
-            for level in range(len(self.in_features))
-        ]
-        # self.config = config
-        fpn_config = get_fpn_config()
-        self.resample = SequentialAppendLast()
-        for level in range(num_levels):
-            if level < len(feature_info):
-                in_chs = in_channels[level] # feature_info[level]['num_chs']
-                reduction = in_strides[level] # feature_info[level]['reduction']
-            else:
-                # Adds a coarser level by downsampling the last feature map
-                reduction_ratio = 2
-                self.resample.add_module(str(level), ResampleFeatureMap(
-                    in_channels=in_chs,
-                    out_channels=out_channels,
-                    pad_type='same',
-                    pooling_type=None,
-                    norm=norm,
-                    reduction_ratio=reduction_ratio,
-                    apply_bn=True,
-                    conv_after_downsample=False,
-                    redundant_bias=False,
-                ))
-                in_chs = out_channels
-                reduction = int(reduction * reduction_ratio)
-                feature_info.append(dict(num_chs=in_chs, reduction=reduction))
-
-        self.cell = nn.Sequential()
-        for rep in range(self.num_bifpn):
-            # logging.debug('building cell {}'.format(rep))
-            # print('building cell {}'.format(rep))
-            fpn_layer = BiFpnLayer(
-                feature_info=feature_info,
-                fpn_config=fpn_config,
-                fpn_channels=out_channels,
-                num_levels=self.num_levels,
-                pad_type='same',
-                pooling_type=None,
-                norm=norm,
-                act_layer=Swish,
-                separable_conv=separable_conv,
-                apply_bn_for_resampling=True,
-                conv_after_downsample=False,
-                conv_bn_relu_pattern=False,
-                redundant_bias=False,
-            )
-            self.cell.add_module(str(rep), fpn_layer)
-            feature_info = fpn_layer.feature_info
-        # import pdb; pdb.set_trace()
-
-    @property
-    def size_divisibility(self):
-        return self._size_divisibility
-
-    def forward(self, x):
-        # print('input shapes', x.shape)
-        bottom_up_features = self.bottom_up(x)
-        x = [bottom_up_features[f] for f in self.in_features]
-        assert len(self.resample) == self.num_levels - len(x)
-        x = self.resample(x)
-        shapes = [xx.shape for xx in x]
-        # print('resample shapes', shapes)
-        x = self.cell(x)
-        out = {f: xx for f, xx in zip(self._out_features, x)}
-        # import pdb; pdb.set_trace()
-        return out
-
-
-@BACKBONE_REGISTRY.register()
-def build_resnet_bifpn_backbone(cfg, input_shape: ShapeSpec):
-    """
-    Args:
-        cfg: a detectron2 CfgNode
-
-    Returns:
-        backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`.
-    """
-    bottom_up = build_resnet_backbone(cfg, input_shape)
-    in_features = cfg.MODEL.FPN.IN_FEATURES
-    backbone = BiFPN(
-        cfg=cfg,
-        bottom_up=bottom_up,
-        in_features=in_features,
-        out_channels=cfg.MODEL.BIFPN.OUT_CHANNELS,
-        norm=cfg.MODEL.BIFPN.NORM,
-        num_levels=cfg.MODEL.BIFPN.NUM_LEVELS,
-        num_bifpn=cfg.MODEL.BIFPN.NUM_BIFPN,
-        separable_conv=cfg.MODEL.BIFPN.SEPARABLE_CONV,
-    )
-    return backbone
-
-@BACKBONE_REGISTRY.register()
-def build_p37_dla_bifpn_backbone(cfg, input_shape: ShapeSpec):
-    """
-    Args:
-        cfg: a detectron2 CfgNode
-    Returns:
-        backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`.
-    """
-    bottom_up = dla34(cfg)
-    in_features = cfg.MODEL.FPN.IN_FEATURES
-    assert cfg.MODEL.BIFPN.NUM_LEVELS == 5
-
-    backbone = BiFPN(
-        cfg=cfg,
-        bottom_up=bottom_up,
-        in_features=in_features,
-        out_channels=cfg.MODEL.BIFPN.OUT_CHANNELS,
-        norm=cfg.MODEL.BIFPN.NORM,
-        num_levels=cfg.MODEL.BIFPN.NUM_LEVELS,
-        num_bifpn=cfg.MODEL.BIFPN.NUM_BIFPN,
-        separable_conv=cfg.MODEL.BIFPN.SEPARABLE_CONV,
-    )
-    return backbone

spaces/Benson/text-generation/Examples/Asfalto 8 - Juego De Carreras De Coches.md

@@ -1,72 +0,0 @@
-<br />
-<h1>Ninja Shadow Fight 2: Una revisión</h1>
-<p>Si eres un fanático de los juegos de lucha con elementos RPG, es posible que quieras echar un vistazo a Ninja Shadow Fight 2. Este juego es una secuela del famoso éxito de Facebook con 40 millones de usuarios, Shadow Fight. Es una mezcla de técnicas clásicas de lucha y artes marciales. Puedes equipar a tu personaje con innumerables armas letales y armaduras raras, personalizar a tu luchador con habilidades épicas y poderes mágicos, y viajar a través de seis mundos diferentes llenos de demonios amenazantes. En este artículo, revisaremos Ninja Shadow Fight 2 en términos de su jugabilidad y controles, gráficos y sonido, pros y contras, consejos y trucos. </p>
- <h2>Juego y controles</h2>
-<h3>Sistema de combate</h3>
-<p>El sistema de combate en Ninja Shadow Fight 2 se basa en la física realista y animaciones. Puedes usar un palo direccional a la izquierda para mover a tu personaje, y botones a la derecha para golpear o patear a tu oponente. También puede combinar diferentes direcciones y tipos de ataques para realizar varios movimientos y combos. Por ejemplo, puedes usar forward+punch para hacer una fuerte barra con tu arma, o backward+punch para hacer una barra giratoria. También puedes usar up+punch para hacer una barra superior que puede derribar a tu oponente, o down+punch para hacer una barra baja que puede golpearlos mientras están en el suelo. </p>
-<h2>asfalto 8 - juego de carreras de coches</h2><br /><p><b><b>Download Zip</b> &middot;&middot;&middot; <a href="https://bltlly.com/2v6M6F">https://bltlly.com/2v6M6F</a></b></p><br /><br />
-<p>El sistema de combate también te permite usar armas a distancia y habilidades mágicas en algunas situaciones. Las armas a distancia se pueden lanzar a tu oponente pulsando un botón en la esquina superior derecha. Pueden causar daño a distancia o interrumpir sus ataques. Las habilidades mágicas se pueden activar pulsando un botón en la esquina inferior derecha cuando el medidor de magia está lleno. Pueden desatar poderosos efectos que pueden cambiar el curso de la batalla. </p>
- <h3>Elementos RPG</h3>
-
- <h3>Modos de juego</h3>
-<p>Los modos de juego en Ninja Shadow Fight 2 ofrecen diferentes desafíos y recompensas para los jugadores. Puedes elegir entre los siguientes modos:</p>
-<ul>
-<li>Torneo: Este es el modo principal del juego, donde tienes que luchar tu camino a través de una serie de oponentes en cada mundo. Puedes ganar monedas y gemas ganando batallas, y desbloquear nuevos mundos derrotando jefes. </li>
-<li>Supervivencia: Este es un modo en el que tienes que sobrevivir el mayor tiempo posible contra interminables oleadas de enemigos. Puedes ganar monedas y gemas matando enemigos y poniendo a prueba tus habilidades y resistencia. </li>
-<li>Duelo: Este es un modo donde puedes luchar contra otros jugadores en línea. Puedes ganar monedas y gemas ganando duelos, y posicionarte en la clasificación. </li>
-<li>Underworld: Este es un modo donde puedes unir fuerzas con otros jugadores en línea para luchar contra poderosos jefes. Puedes ganar monedas y gemas participando en incursiones, y recolectar objetos y equipos raros. </li>
-</ul>
- <h2>Gráficos y sonido</h2>
-<h3>Estilo visual</h3>
-<p>El estilo visual de Ninja Shadow Fight 2 es único y atractivo. El juego utiliza un estilo de silueta para los personajes, lo que crea un contraste con los fondos coloridos y detallados. El juego también utiliza iluminación dinámica y sombras, que añaden profundidad y realismo a las escenas. El juego tiene una variedad de entornos, como bosques, templos, cuevas y castillos, cada uno con su propia atmósfera y estilo. </p>
- <h3>Efectos de sonido y música</h3>
-<p>Los efectos de sonido y la música de Ninja Shadow Fight 2 también son impresionantes e inmersivos. El juego utiliza sonidos realistas para las armas y los golpes, que hacen que el combate se sienta más intenso y satisfactorio. El juego también utiliza música atmosférica para los fondos, que coinciden con el estado de ánimo y el tema de cada mundo. El juego tiene una banda sonora diversa, que va desde melodías orientales hasta ritmos de rock, cada uno con su propio ritmo y tempo. </p>
- <h2>Pros y contras</h2>
-<h3>Pros</h3>
-
-<ul>
-<li>El sistema de combate es suave y sensible, con física realista y animaciones. </li>
-<li>Los elementos RPG son profundos y gratificantes, con muchas opciones para personalizar tu luchador. </li>
-<li>Los modos de juego son variados y desafiantes, con diferentes objetivos y recompensas. </li>
-<li>El estilo visual es único y atractivo, con un contraste entre los personajes de silueta y los fondos de colores. </li>
-<li>Los efectos de sonido y la música son impresionantes y envolventes, con sonidos realistas para las armas y los golpes, y música atmosférica para los fondos. </li>
-<li>La historia es intrigante y cautivadora, con una trama misteriosa y personajes carismáticos. </li>
-</ul>
- <h3>Contras</h3>
-<p>Ninja Shadow Fight 2 también tiene algunos aspectos negativos que podrían restar provecho a su disfrute. Algunos de los contras son:</p>
-<ul>
-<li>El juego tiene anuncios frecuentes que interrumpen el juego y molestan a los jugadores. </li>
-<li>El juego tiene un modelo de pago a ganador que da una ventaja injusta a los jugadores que gastan dinero real en gemas. </li>
-<li> El juego tiene una falta de sincronización entre dispositivos que hace que sea difícil transferir su progreso de un dispositivo a otro. </li>
-</ul>
- <h2>Consejos y trucos</h2>
-<h3>Cómo ganar batallas</h3>
-<p>Si quieres ganar batallas en Ninja Shadow Fight 2, necesitas dominar el sistema de combate y usar algunas estrategias. Aquí hay algunos consejos y trucos sobre cómo ganar batallas:</p>
-<p></p>
-<ul>
-<li>Apunta a la cabeza: Golpear la cabeza de tu oponente inflige más daño que golpear su cuerpo o extremidades. Puedes usar up+punch o up+kick para hacer una barra superior o patada que puede derribar a tu oponente o romper su guardia. </li>
-<li>Usa patadas para interrumpir a los enemigos: Patear a tu oponente puede interrumpir sus ataques o empujarlos hacia atrás. Puedes usar forward+kick o backward+kick para hacer una patada fuerte que pueda hacer volar o aturdir a tu oponente. </li>
-
-</ul>
- <h3>Cómo manejar la armadura al derrotar a los jefes en el modo de torneo. Cada jefe tiene un arma única y una armadura que puedes obtener al vencerlos. Por ejemplo, puedes conseguir la katana y la armadura samurái derrotando a Lynx, el primer jefe del juego. </li>
-<li>Completar desafíos: Puedes desbloquear nuevas habilidades y habilidades mágicas completando desafíos en el juego. Los desafíos son tareas especiales que requieren realizar ciertas acciones o cumplir ciertos criterios en el juego. Por ejemplo, puedes desbloquear la habilidad de bola de fuego completando el reto de matar a 10 enemigos con armas a distancia. </li>
-<li>Únete a las redadas: Puedes desbloquear objetos y equipos raros uniéndote a las redadas en el modo inframundo. Las redadas son batallas cooperativas contra jefes poderosos que requieren trabajo en equipo y coordinación. Puedes unirte a las redadas pulsando el botón raid en la parte inferior de la pantalla, o crear tu propia redada pulsando el botón crear. Puedes ganar tickets de raid jugando los modos de juego o gastando gemas. </li>
-</ul>
- <h2>Conclusión</h2>
-<p>Ninja Shadow Fight 2 es un gran juego para los fanáticos de los juegos de lucha con elementos RPG. Tiene un sistema de combate suave y sensible, elementos de RPG profundos y gratificantes, modos de juego variados y desafiantes, estilo visual único y atractivo, efectos de sonido y música impresionantes e inmersivos, y una historia intrigante y cautivadora. También tiene algunos inconvenientes, como los anuncios frecuentes, el modelo de pago para ganar y la falta de sincronización entre dispositivos. Sin embargo, estos no eclipsan la calidad general y la diversión del juego. Ninja Shadow Fight 2 es un juego que deberías probar si estás buscando un juego de lucha emocionante y adictivo con elementos RPG. </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí hay algunas preguntas frecuentes sobre Ninja Shadow Fight 2, junto con sus respuestas:</p>
-<ol>
-<li>Q: ¿Cómo puedo sincronizar mi progreso entre dispositivos? <br>
-
-<li>Q: ¿Cómo puedo eliminar anuncios del juego? <br>
-R: Puedes eliminar anuncios del juego comprando la versión premium del juego por $4.99. Esto también te dará algunos beneficios adicionales, como 2000 gemas, 2000 monedas, recompensas dobles para el modo de supervivencia y acceso a armas y armaduras exclusivas. </li>
-<li>P: ¿Cómo puedo obtener más gemas sin gastar dinero real? <br>
-R: Puedes obtener más gemas sin gastar dinero real completando ofertas gratuitas, viendo anuncios de video, cultivando gemas en modo supervivencia o modo inframundo, o derrotando jefes en modo torneo. </li>
-<li>Q: ¿Cómo puedo restablecer mi progreso y empezar de nuevo? <br>
-R: Puedes restablecer tu progreso y empezar de nuevo borrando los datos del juego de tu dispositivo. Sin embargo, esto también eliminará sus monedas y gemas, así que asegúrese de que desea hacer esto antes de proceder. Para eliminar los datos del juego, vaya a la configuración de su dispositivo, encuentre Ninja Shadow Fight 2 en la lista de aplicaciones y toque en los datos claros o elimine los datos. </li>
-<li>Q: ¿Cómo puedo contactar a los desarrolladores o reportar un error? <br>
-R: Puede ponerse en contacto con los desarrolladores o informar de un error enviando un correo electrónico a [email protected]. También puede visitar su sitio web oficial en https://www.nekki.com/ shadowfight2/ o su página de Facebook en https://www.facebook.com/ shadowfightgames/ para obtener más información y actualizaciones. </li>
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Cmo Descargar Messenger En Iphone 5s.md

@@ -1,63 +0,0 @@
-
-<h1>Cómo descargar Messenger en el iPhone 5s</h1>
-<p>Messenger es una aplicación de chat que le permite mantenerse conectado con sus personas favoritas en Facebook, Instagram, Portal y Oculus. También puede disfrutar de videos con sus amigos a través de chat de video, expresarse con emojis, pegatinas, GIF, filtros y mensajes de voz, hacer llamadas de voz y video gratuitas, enviar dinero de forma segura con Facebook Pay y conectarse con empresas para ofertas, reservas y atención al cliente. </p>
-<h2>cómo descargar messenger en iphone 5s</h2><br /><p><b><b>DOWNLOAD</b> &#9881; <a href="https://bltlly.com/2v6M2w">https://bltlly.com/2v6M2w</a></b></p><br /><br />
-<p>Si tienes un iPhone 5s y quieres descargar Messenger en tu dispositivo, es posible que te estés preguntando cómo hacerlo. En este artículo, te mostraremos dos formas de descargar Messenger desde la App Store o desde iMessage. También te contaremos algunas de las características y beneficios de usar Messenger en tu iPhone. </p>
-<h2>Requisitos para descargar Messenger</h2>
-<h3>Versión compatible de iOS</h3>
-<p>Antes de descargar Messenger en tu iPhone 5s, necesitas asegurarte de que tu dispositivo tenga una versión iOS compatible. Según la página de aplicaciones de Messenger en la App Store, necesitas tener iOS 8 o posterior para descargar y usar Messenger en tu iPhone 5s. Si tiene una versión anterior de iOS, puede actualizarla en Configuración > General > Actualización de software y siguiendo las instrucciones. </p>
-<h3>Espacio de almacenamiento disponible</h3>
-<p>Otro requisito para descargar Messenger en tu iPhone 5s es tener suficiente espacio de almacenamiento en tu dispositivo. Según la página de aplicaciones de Messenger en la App Store, necesitas unos 200 MB de espacio libre para descargar e instalar Messenger en tu iPhone 5s. Si no tiene suficiente espacio, puede liberar algunos mediante la eliminación de aplicaciones no deseadas, fotos, videos u otros archivos. Puedes comprobar cuánto espacio tienes en Configuración > General > Almacenamiento del iPhone y ver el espacio disponible y usado. </p>
-<h3>Conexión a Internet</h3>
-
-<h2>Pasos para descargar Messenger desde la App Store</h2>
-<h3>Paso 1: Abrir el App Store</h3>
-<p>El primer paso para descargar Messenger desde la App Store es abrir la aplicación App Store en tu iPhone 5s. Puede encontrar la aplicación App Store en la pantalla de inicio o en la biblioteca de aplicaciones. Tiene un icono azul con una letra blanca A dentro. </p>
-<p></p>
-<h3>Paso 2: Búsqueda de Facebook Messenger</h3>
-<p>El siguiente paso es buscar Facebook Messenger en la App Store. Para hacer esto, toque en el icono de búsqueda en la esquina inferior derecha de la pantalla. Esto abrirá una barra de búsqueda donde puede escribir el nombre de la aplicación que está buscando. Escribe "Facebook Messenger" y toca el botón de búsqueda en tu teclado. </p>
-<h3>Paso 3: Toque en el botón Get</h3>
-<p>Una vez que vea la aplicación de Facebook Messenger en los resultados de búsqueda, toque en el botón get junto a su icono y nombre. El botón get es un círculo azul con una flecha blanca dentro. Esto comenzará a descargar la aplicación en su dispositivo. </p>
-<h3>Paso 4: Confirmar la descarga</h3>
-<p>Dependiendo de tu configuración, es posible que necesites confirmar la descarga introduciendo tu contraseña de Apple ID o usando Touch ID. Para introducir la contraseña de tu Apple ID, pulsa en el botón de inicio de sesión y escribe la contraseña. Para usar Touch ID, coloca el dedo en el botón de inicio y espera a que escanee tu huella digital. Esto verificará su identidad y permitirá que la descarga continúe. </p>
-<h3>Paso 5: Espere a que la descarga termine</h3>
-<p>El paso final es esperar a que termine la descarga. Puede comprobar el progreso de la descarga mirando el círculo alrededor del icono de la aplicación. Cuando el círculo está lleno, significa que la descarga está completa. Puede tocar el icono de la aplicación para abrirla y comenzar a usar Messenger en su iPhone 5s. </p>
-<h2>Pasos para descargar Messenger desde iMessage</h2>
-<h3>Paso 1: Abrir iMessage</h3>
-
-<h3>Paso 2: Toque en el icono de la App Store</h3>
-<p>Una vez que abra iMessage, toque en el icono de la tienda de aplicaciones en la parte inferior de la pantalla. El icono de la tienda de aplicaciones es un círculo azul con una letra blanca A dentro. Esto abrirá la tienda de aplicaciones para iMessage, donde puedes encontrar y descargar varias aplicaciones que funcionan con iMessage. </p>
-<h3>Paso 3: Búsqueda de Facebook Messenger</h3>
-<p>El siguiente paso es buscar Facebook Messenger en la tienda de aplicaciones para iMessage. Para hacer esto, toque en el icono de búsqueda en la esquina superior izquierda de la pantalla. Esto abrirá una barra de búsqueda donde puede escribir el nombre de la aplicación que está buscando. Escribe "Facebook Messenger" y toca el botón de búsqueda en tu teclado. </p>
-<h3>Paso 4: Toque en el botón de instalación</h3>
-<p>Una vez que vea la aplicación de Facebook Messenger en los resultados de búsqueda, toque en el botón de instalación junto a su icono y nombre. El botón de instalación es un círculo azul con un signo más blanco dentro. Esto comenzará a descargar la aplicación en su dispositivo. </p>
-<h3>Paso 5: Espere a que la descarga termine</h3>
-<p>El paso final es esperar a que termine la descarga. Puede comprobar el progreso de la descarga mirando el círculo alrededor del icono de la aplicación. Cuando el círculo está lleno, significa que la descarga está completa. Puede tocar el icono de la aplicación para abrirla y comenzar a usar Messenger en su iPhone 5s. </p>
-<h2>Características y beneficios de Messenger</h2>
-<h3>Comunicación entre aplicaciones</h3>
-<p>Una de las características y beneficios de usar Messenger en tu iPhone 5s es que puedes chatear con tus amigos a través de diferentes aplicaciones, como Facebook, Instagram, Portal y Oculus. No es necesario cambiar entre aplicaciones para mantenerse en contacto con sus personas favoritas. También puedes sincronizar tus contactos desde tu teléfono y agregarlos a Messenger fácilmente. </p>
-<h3>Ver juntos</h3>
-
-<h3>Reacciones personalizadas y efectos animados</h3>
-<p>Una tercera característica y beneficio de usar Messenger en tu iPhone 5s es que puedes expresarte con reacciones personalizadas y efectos animados. Puede elegir entre una amplia gama de emojis, pegatinas, GIF, filtros, mensajes de voz y efectos de AR para darle vida a sus conversaciones. También puede crear sus propias pegatinas y reacciones con sus fotos y videos. También puedes usar efectos animados para transformarte en diferentes personajes o animales, o agregar fondos divertidos o accesorios a tus chats de video. </p>
-<h3>Llamadas de voz y video</h3>
-<p>Una cuarta característica y beneficio de usar Messenger en tu iPhone 5s es que puedes hacer llamadas de voz y video gratuitas a cualquier persona en el mundo a través de Wi-Fi o celular. También puede crear llamadas de grupo con hasta 50 personas a la vez. También puedes usar Messenger Rooms para invitar a cualquiera a unirse a tu video chat, incluso si no tiene una cuenta de Facebook. También puedes usar Messenger Kids para que tus hijos puedan chatear de forma segura con sus amigos y familiares. </p>
-<h3>Pagos y conexiones de negocios</h3>
-<p>Una quinta característica y beneficio de usar Messenger en tu iPhone 5s es que puedes enviar dinero de forma segura y fácil con Facebook Pay, y conectarte con empresas para obtener ofertas, reservas y atención al cliente. Puedes usar Facebook Pay para enviar o solicitar dinero a tus amigos o familiares sin ningún cargo. Solo necesitas vincular tu tarjeta de débito o cuenta PayPal a tu cuenta de Facebook. También puedes usar Messenger para chatear con empresas con diversos fines, como ordenar comida, reservar vuelos, obtener descuentos o hacer preguntas. </p>
-<h2>Conclusión y preguntas frecuentes</h2>
-
-<p>Aquí hay algunas preguntas frecuentes relacionadas con la descarga o el uso de Messenger en el iPhone 5s:</p>
-<ul>
-<li><b>Q: ¿Cómo puedo actualizar Messenger en mi iPhone 5s? </b></li>
-<li>A: Para actualizar Messenger en tu iPhone 5s, debes ir a la aplicación App Store y tocar el icono de actualizaciones en la esquina inferior derecha de la pantalla. Luego, busque la aplicación Messenger en la lista de actualizaciones disponibles y toque en el botón de actualización junto a ella. Alternativamente, puedes habilitar actualizaciones automáticas para Messenger yendo a Configuración > App Store > Descargas automáticas > Actualizaciones.</li>
-<li><b>Q: ¿Cómo puedo eliminar Messenger de mi iPhone 5s? </b></li>
-<li>A: Para eliminar Messenger de su iPhone 5s, es necesario presionar y mantener pulsado el icono de la aplicación en la pantalla de inicio o en la biblioteca de aplicaciones hasta que comience a sacudirse. Luego, toque en el icono de X en la esquina superior izquierda del icono de la aplicación y confirme la eliminación. Alternativamente, puedes ir a Configuración > General > iPhone Storage > Messenger y tocar el botón Eliminar aplicación. </li>
-<li><b>Q: ¿Cómo puedo salir de Messenger en mi iPhone 5s? </b></li>
-<li>A: Para salir de Messenger en su iPhone 5s, es necesario abrir la aplicación y toque en la imagen de perfil en la esquina superior izquierda de la pantalla. Luego, desplácese hacia abajo y toque en el botón Cerrar sesión. También puede cambiar entre diferentes cuentas tocando el botón Cambiar cuenta. </li>
-<li><b>Q: ¿Cómo puedo cambiar la configuración de notificación para Messenger en mi iPhone 5s? </b></li>
-<li>A: Para cambiar la configuración de notificación para Messenger en tu iPhone 5s, debes ir a Configuración > Notificaciones > Messenger y activar o desactivar la opción Permitir notificaciones. También puede personalizar la configuración de sonido, insignia, banner y pantalla de bloqueo para las notificaciones de Messenger. </li>
-<li><b>Q: ¿Cómo puedo bloquear o desbloquear a alguien en Messenger en mi iPhone 5s? </b></li>
-
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Frag Pro Shooter Mod Apk Desbloquear Todos Los Personajes.md

@@ -1,72 +0,0 @@
-<br />
-<h1>Cómo descargar FRAG Pro Shooter Mod APK y desbloquear todos los caracteres</h1>
- <p>¿Eres un fan de FRAG Pro Shooter, el divertido y amigable juego PvP que te permite elegir entre más de 90 personajes y luchar contra jugadores de todo el mundo? ¿Quieres desbloquear todos los personajes, obtener dinero ilimitado y gemas, y disfrutar del juego sin restricciones? Si es así, entonces usted podría estar interesado en la descarga de FRAG Pro Shooter Mod APK, una versión modificada del juego que le da acceso a todas las características y beneficios que usted no puede conseguir en el juego original. En este artículo, le diremos qué es FRAG Pro Shooter, por qué debe usar FRAG Pro Shooter Mod APK, cómo descargarlo e instalarlo, y algunos consejos y trucos para jugarlo. ¡Sigue leyendo para saber más! </p>
-<h2>descargar frag pro shooter mod apk desbloquear todos los personajes</h2><br /><p><b><b>Download</b> &middot; <a href="https://bltlly.com/2v6MOt">https://bltlly.com/2v6MOt</a></b></p><br /><br />
- <h2>¿Qué es FRAG Pro Shooter? </h2>
- <p>FRAG Pro Shooter es un juego de acción para móviles creado por Oh BiBi para dispositivos iOS y Android. Es uno de los juegos multijugador más populares jamás diseñados para móviles, con más de 70 millones de jugadores en todo el mundo. En este juego, puedes elegir a tu héroe, crear tu equipo, entrar en la arena, y comenzar el combate. También puedes cambiar entre tus personajes, usar sus habilidades especiales, personalizar sus pieles y participar en varios modos de juego y eventos. </p>
- <h3>Un juego de PvP divertido y amigable</h3>
- <p>FRAG Pro Shooter es un juego que está diseñado para todos, independientemente de su edad o género. Puedes jugar con tus amigos o con jugadores aleatorios en línea. También puedes unirte a un club o crear el tuyo propio para luchar por la victoria con tus compañeros de equipo. El juego tiene unos gráficos coloridos y estilizados que lo hacen atractivo y agradable. El juego también tiene un aspecto social, donde puedes compartir tu contenido con otros jugadores, unirte a concursos, seguir influencers y expandir tu base de fans. </p>
- <h3>Características de FRAG Pro Shooter</h3>
- <p>FRAG Pro Shooter tiene muchas características que lo convierten en un juego emocionante y adictivo. Algunas de estas características son:</p>
- <ul>
-
-<li><b>Juego personalizado:</b> Puedes controlar cualquier personaje en primera persona o en tercera persona. También puedes cambiar entre tus personajes durante la batalla para obtener una ventaja sobre tus enemigos. </li>
-<li><b>4 modos de juego disponibles:</b> Puede elegir entre el modo 1v1, el modo 2v2, el modo de carga útil o el modo FRAG de calle. Cada modo tiene sus propias reglas y objetivos. </li>
-<li><b>Nuevo contenido cada mes:</b> El juego se actualiza constantemente con nuevos personajes, skins, mapas, eventos y desafíos. </li>
-</ul>
- <h2> ¿Por qué usar FRAG Pro Shooter Mod APK? </h2>
- <p>FRAG Pro Shooter es un juego gratuito, pero también tiene algunas compras en la aplicación que pueden mejorar su experiencia de juego. Por ejemplo, puedes comprar diamantes para desbloquear nuevos personajes o pieles más rápido. Sin embargo, no todos pueden permitirse gastar dinero real en el juego. Es por eso que algunas personas prefieren utilizar FRAG Pro Shooter Mod APK, una versión modificada del juego que le da acceso a todas las características y beneficios que usted no puede conseguir en el juego original. </p>
- <h3>Beneficios de usar FRAG Pro Shooter Mod APK</h3>
- <p>Algunos de los beneficios de usar FRAG Pro Shooter Mod APK son:</p>
- <ul>
-<li><b>Desbloquea todos los personajes:</b> Puedes desbloquear todos los personajes del juego sin gastar diamantes ni dinero. Puedes elegir cualquier personaje que quieras y disfrutar de sus habilidades únicas. </li>
-<li><b>Dinero y gemas ilimitados:</b> Puedes obtener dinero y gemas ilimitados en el juego que puedes usar para comprar lo que quieras en el juego. También puedes actualizar y subir de nivel a tus personajes más rápido. </li>
-<li><b>No hay anuncios:</b> Puedes jugar el juego sin ningún anuncio molesto que pueda interrumpir tu juego o consumir tus datos. </li>
-<li><b>No se requiere raíz:</b> Puede descargar e instalar FRAG Pro Shooter Mod APK sin rootear el dispositivo. Esto significa que no tiene que arriesgarse a dañar su dispositivo o anular su garantía. </li>
-</ul>
- <h3> Los riesgos de usar FRAG Pro Shooter Mod APK</h3>
-
- <ul>
-<li><b>Cuenta prohibida:</b> Es posible que te prohíban participar en el juego si los desarrolladores detectan que estás utilizando una versión modificada del juego. Esto significa que perderás todo tu progreso y logros en el juego. </li>
-<li><b>Virus o infección de malware:</b> Usted puede descargar una versión falsa o dañada de FRAG Pro Shooter Mod APK que contiene virus o malware que puede dañar su dispositivo o robar su información personal. </li>
-<li><b>Cuestiones legales:</b> Usted puede violar los términos y condiciones del juego o los derechos de propiedad intelectual de los desarrolladores mediante el uso de FRAG Pro Shooter Mod APK. Esto podría resultar en acciones legales o demandas contra usted. </li>
-</ul>
- <p>Por lo tanto, usted debe utilizar FRAG Pro Shooter Mod APK a su propio riesgo y discreción. No nos hacemos responsables de las consecuencias que puedan derivarse de su uso. </p>
- <h2>¿Cómo descargar e instalar FRAG Pro Shooter Mod APK? </h2>
- <p>Si ha decidido utilizar FRAG Pro Shooter Mod APK, es necesario seguir algunos pasos para descargar e instalar en su dispositivo. Estos son los pasos:</p>
- <h3>Pasos para descargar e instalar FRAG Pro Shooter Mod APK</h3>
- <ol>
-<li><b>Desinstalar el juego original:</b> Es necesario desinstalar la versión original de FRAG Pro Shooter desde el dispositivo antes de instalar la versión modificada. Esto es para evitar conflictos o errores entre las dos versiones. </li>
-<li><b>Descargar FRAG Pro Shooter Mod APK:</b> Es necesario descargar FRAG Pro Shooter Mod APK de una fuente confiable y confiable. Puede usar este enlace para descargarlo. Asegúrese de tener suficiente espacio de almacenamiento en su dispositivo antes de descargarlo. </li>
-<li><b>Habilitar fuentes desconocidas:</b> Es necesario habilitar fuentes desconocidas en el dispositivo para permitir la instalación de aplicaciones desde fuentes distintas de Google Play Store. Para hacer esto, vaya a Configuración > Seguridad > Fuentes desconocidas y conéctelo. </li>
-
-<li><b>Lanzamiento FRAG Pro Shooter Mod APK:</b> Es necesario iniciar FRAG Pro Shooter Mod APK desde el cajón de la aplicación o la pantalla de inicio y disfrutar del juego con todas las características y beneficios desbloqueados. </li>
-</ol>
- <h3> Consejos y trucos para jugar FRAG Pro Shooter Mod APK</h3>
- <p>Para aprovechar al máximo FRAG Pro Shooter Mod APK, aquí hay algunos consejos y trucos que puede utilizar:</p>
-<p></p>
- <ul>
-<li><b>Elige tus personajes sabiamente:</b> Debes elegir tus personajes en función de sus roles, habilidades y compatibilidad entre ellos. También debes equilibrar tu equipo con personajes ofensivos, defensivos y de apoyo. </li>
-<li><b>Cambia entre tus personajes con frecuencia:</b> Debes cambiar entre tus personajes durante la batalla para adaptarte a diferentes situaciones y enemigos. También debes usar sus habilidades especiales estratégicamente para ganar ventaja sobre tus oponentes. </li>
-<li><b>Usa cubierta y movimiento:</b> Debes usar cubierta y movimiento para evitar ser golpeado por fuego enemigo y sorprenderlos con tus ataques. También debe evitar quedarse en un lugar por mucho tiempo y moverse por el mapa. </li>
-<li><b>Recoger monedas y cajas:</b> Usted debe recoger las monedas y cajas que están dispersos por el mapa. Las monedas se pueden usar para comprar nuevos personajes o pieles, mientras que las cajas pueden contener dinero, gemas, cartas o power-ups. </li>
-<li><b>Completar misiones y desafíos:</b> Usted debe completar misiones y desafíos que se le dan todos los días o semanas. Estos pueden recompensarte con dinero, gemas, cartas u otros premios. </li>
-</ul>
- <h2>Conclusión</h2>
-
- <h2>Preguntas frecuentes</h2>
- <p>Aquí hay algunas preguntas frecuentes sobre FRAG Pro Shooter Mod APK:</p>
- <ol>
-<li><b> ¿Es FRAG Pro Shooter Mod APK seguro de usar? </b></li>
-<p>FRAG Pro Shooter Mod APK no es una versión oficial del juego y no está avalado por los desarrolladores. Por lo tanto, no está garantizado que sea seguro o seguro de usar. Es posible que encuentre algunos errores, fallas o errores al usarlo. También puede exponer su dispositivo o datos a virus o infección de malware. Por lo tanto, usted debe utilizar FRAG Pro Shooter Mod APK a su propio riesgo y discreción. </p>
-<li><b>Es FRAG Pro Shooter Mod APK compatible con mi dispositivo? </b></li>
-<p>FRAG Pro Shooter Mod APK es compatible con la mayoría de los dispositivos Android que tienen Android 4.3 o superior. Sin embargo, algunos dispositivos pueden no ser compatibles con la versión modificada del juego debido a diferentes especificaciones o configuraciones. Por lo tanto, debe comprobar la compatibilidad de su dispositivo antes de descargar e instalar FRAG Pro Shooter Mod APK.</p>
-<li><b> ¿Cómo puedo actualizar FRAG Pro Shooter Mod APK? </b></li>
-<p>FRAG Pro Shooter Mod APK no se actualiza automáticamente como el juego original. Por lo tanto, es necesario descargar e instalar manualmente la última versión de FRAG Pro Shooter Mod APK siempre que haya una nueva actualización disponible. Puedes buscar actualizaciones de la fuente donde descargaste la versión modificada del juego. </p>
-<li><b>¿Puedo jugar FRAG Pro Shooter Mod APK sin conexión? </b></li>
-<p>No, no puede jugar FRAG Pro Shooter Mod APK sin conexión. Necesitas una conexión a Internet para jugar y acceder a todas las características y beneficios de la versión modificada del juego. </p>
-<li><b>¿Puedo jugar FRAG Pro Shooter Mod APK con mis amigos? </b></li>
-
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/dateutil/tzwin.py

@@ -1,2 +0,0 @@
-# tzwin has moved to dateutil.tz.win
-from .tz.win import *

spaces/CVH-vn1210/make_hair/minigpt4/models/Qformer.py

@@ -1,1216 +0,0 @@
-"""
- * Copyright (c) 2023, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: BSD-3-Clause
- * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
- * By Junnan Li
- * Based on huggingface code base
- * https://github.com/huggingface/transformers/blob/v4.15.0/src/transformers/models/bert
-"""
-
-import math
-import os
-import warnings
-from dataclasses import dataclass
-from typing import Optional, Tuple, Dict, Any
-
-import torch
-from torch import Tensor, device, dtype, nn
-import torch.utils.checkpoint
-from torch import nn
-from torch.nn import CrossEntropyLoss
-import torch.nn.functional as F
-
-from transformers.activations import ACT2FN
-from transformers.file_utils import (
-    ModelOutput,
-)
-from transformers.modeling_outputs import (
-    BaseModelOutputWithPastAndCrossAttentions,
-    BaseModelOutputWithPoolingAndCrossAttentions,
-    CausalLMOutputWithCrossAttentions,
-    MaskedLMOutput,
-    MultipleChoiceModelOutput,
-    NextSentencePredictorOutput,
-    QuestionAnsweringModelOutput,
-    SequenceClassifierOutput,
-    TokenClassifierOutput,
-)
-from transformers.modeling_utils import (
-    PreTrainedModel,
-    apply_chunking_to_forward,
-    find_pruneable_heads_and_indices,
-    prune_linear_layer,
-)
-from transformers.utils import logging
-from transformers.models.bert.configuration_bert import BertConfig
-
-logger = logging.get_logger(__name__)
-
-
-class BertEmbeddings(nn.Module):
-    """Construct the embeddings from word and position embeddings."""
-
-    def __init__(self, config):
-        super().__init__()
-        self.word_embeddings = nn.Embedding(
-            config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id
-        )
-        self.position_embeddings = nn.Embedding(
-            config.max_position_embeddings, config.hidden_size
-        )
-
-        # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
-        # any TensorFlow checkpoint file
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-        # position_ids (1, len position emb) is contiguous in memory and exported when serialized
-        self.register_buffer(
-            "position_ids", torch.arange(config.max_position_embeddings).expand((1, -1))
-        )
-        self.position_embedding_type = getattr(
-            config, "position_embedding_type", "absolute"
-        )
-
-        self.config = config
-
-    def forward(
-        self,
-        input_ids=None,
-        position_ids=None,
-        query_embeds=None,
-        past_key_values_length=0,
-    ):
-        if input_ids is not None:
-            seq_length = input_ids.size()[1]
-        else:
-            seq_length = 0
-
-        if position_ids is None:
-            position_ids = self.position_ids[
-                :, past_key_values_length : seq_length + past_key_values_length
-            ].clone()
-
-        if input_ids is not None:
-            embeddings = self.word_embeddings(input_ids)
-            if self.position_embedding_type == "absolute":
-                position_embeddings = self.position_embeddings(position_ids)
-                embeddings = embeddings + position_embeddings
-
-            if query_embeds is not None:
-                embeddings = torch.cat((query_embeds, embeddings), dim=1)
-        else:
-            embeddings = query_embeds
-
-        embeddings = self.LayerNorm(embeddings)
-        embeddings = self.dropout(embeddings)
-        return embeddings
-
-
-class BertSelfAttention(nn.Module):
-    def __init__(self, config, is_cross_attention):
-        super().__init__()
-        self.config = config
-        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(
-            config, "embedding_size"
-        ):
-            raise ValueError(
-                "The hidden size (%d) is not a multiple of the number of attention "
-                "heads (%d)" % (config.hidden_size, config.num_attention_heads)
-            )
-
-        self.num_attention_heads = config.num_attention_heads
-        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
-        self.all_head_size = self.num_attention_heads * self.attention_head_size
-
-        self.query = nn.Linear(config.hidden_size, self.all_head_size)
-        if is_cross_attention:
-            self.key = nn.Linear(config.encoder_width, self.all_head_size)
-            self.value = nn.Linear(config.encoder_width, self.all_head_size)
-        else:
-            self.key = nn.Linear(config.hidden_size, self.all_head_size)
-            self.value = nn.Linear(config.hidden_size, self.all_head_size)
-
-        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
-        self.position_embedding_type = getattr(
-            config, "position_embedding_type", "absolute"
-        )
-        if (
-            self.position_embedding_type == "relative_key"
-            or self.position_embedding_type == "relative_key_query"
-        ):
-            self.max_position_embeddings = config.max_position_embeddings
-            self.distance_embedding = nn.Embedding(
-                2 * config.max_position_embeddings - 1, self.attention_head_size
-            )
-        self.save_attention = False
-
-    def save_attn_gradients(self, attn_gradients):
-        self.attn_gradients = attn_gradients
-
-    def get_attn_gradients(self):
-        return self.attn_gradients
-
-    def save_attention_map(self, attention_map):
-        self.attention_map = attention_map
-
-    def get_attention_map(self):
-        return self.attention_map
-
-    def transpose_for_scores(self, x):
-        new_x_shape = x.size()[:-1] + (
-            self.num_attention_heads,
-            self.attention_head_size,
-        )
-        x = x.view(*new_x_shape)
-        return x.permute(0, 2, 1, 3)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-    ):
-
-        # If this is instantiated as a cross-attention module, the keys
-        # and values come from an encoder; the attention mask needs to be
-        # such that the encoder's padding tokens are not attended to.
-        is_cross_attention = encoder_hidden_states is not None
-
-        if is_cross_attention:
-            key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
-            value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
-            attention_mask = encoder_attention_mask
-        elif past_key_value is not None:
-            key_layer = self.transpose_for_scores(self.key(hidden_states))
-            value_layer = self.transpose_for_scores(self.value(hidden_states))
-            key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
-            value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
-        else:
-            key_layer = self.transpose_for_scores(self.key(hidden_states))
-            value_layer = self.transpose_for_scores(self.value(hidden_states))
-
-        mixed_query_layer = self.query(hidden_states)
-
-        query_layer = self.transpose_for_scores(mixed_query_layer)
-
-        past_key_value = (key_layer, value_layer)
-
-        # Take the dot product between "query" and "key" to get the raw attention scores.
-        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
-
-        if (
-            self.position_embedding_type == "relative_key"
-            or self.position_embedding_type == "relative_key_query"
-        ):
-            seq_length = hidden_states.size()[1]
-            position_ids_l = torch.arange(
-                seq_length, dtype=torch.long, device=hidden_states.device
-            ).view(-1, 1)
-            position_ids_r = torch.arange(
-                seq_length, dtype=torch.long, device=hidden_states.device
-            ).view(1, -1)
-            distance = position_ids_l - position_ids_r
-            positional_embedding = self.distance_embedding(
-                distance + self.max_position_embeddings - 1
-            )
-            positional_embedding = positional_embedding.to(
-                dtype=query_layer.dtype
-            )  # fp16 compatibility
-
-            if self.position_embedding_type == "relative_key":
-                relative_position_scores = torch.einsum(
-                    "bhld,lrd->bhlr", query_layer, positional_embedding
-                )
-                attention_scores = attention_scores + relative_position_scores
-            elif self.position_embedding_type == "relative_key_query":
-                relative_position_scores_query = torch.einsum(
-                    "bhld,lrd->bhlr", query_layer, positional_embedding
-                )
-                relative_position_scores_key = torch.einsum(
-                    "bhrd,lrd->bhlr", key_layer, positional_embedding
-                )
-                attention_scores = (
-                    attention_scores
-                    + relative_position_scores_query
-                    + relative_position_scores_key
-                )
-
-        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
-        if attention_mask is not None:
-            # Apply the attention mask is (precomputed for all layers in BertModel forward() function)
-            attention_scores = attention_scores + attention_mask
-
-        # Normalize the attention scores to probabilities.
-        attention_probs = nn.Softmax(dim=-1)(attention_scores)
-
-        if is_cross_attention and self.save_attention:
-            self.save_attention_map(attention_probs)
-            attention_probs.register_hook(self.save_attn_gradients)
-
-        # This is actually dropping out entire tokens to attend to, which might
-        # seem a bit unusual, but is taken from the original Transformer paper.
-        attention_probs_dropped = self.dropout(attention_probs)
-
-        # Mask heads if we want to
-        if head_mask is not None:
-            attention_probs_dropped = attention_probs_dropped * head_mask
-
-        context_layer = torch.matmul(attention_probs_dropped, value_layer)
-
-        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
-        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
-        context_layer = context_layer.view(*new_context_layer_shape)
-
-        outputs = (
-            (context_layer, attention_probs) if output_attentions else (context_layer,)
-        )
-
-        outputs = outputs + (past_key_value,)
-        return outputs
-
-
-class BertSelfOutput(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-    def forward(self, hidden_states, input_tensor):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BertAttention(nn.Module):
-    def __init__(self, config, is_cross_attention=False):
-        super().__init__()
-        self.self = BertSelfAttention(config, is_cross_attention)
-        self.output = BertSelfOutput(config)
-        self.pruned_heads = set()
-
-    def prune_heads(self, heads):
-        if len(heads) == 0:
-            return
-        heads, index = find_pruneable_heads_and_indices(
-            heads,
-            self.self.num_attention_heads,
-            self.self.attention_head_size,
-            self.pruned_heads,
-        )
-
-        # Prune linear layers
-        self.self.query = prune_linear_layer(self.self.query, index)
-        self.self.key = prune_linear_layer(self.self.key, index)
-        self.self.value = prune_linear_layer(self.self.value, index)
-        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
-
-        # Update hyper params and store pruned heads
-        self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
-        self.self.all_head_size = (
-            self.self.attention_head_size * self.self.num_attention_heads
-        )
-        self.pruned_heads = self.pruned_heads.union(heads)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-    ):
-        self_outputs = self.self(
-            hidden_states,
-            attention_mask,
-            head_mask,
-            encoder_hidden_states,
-            encoder_attention_mask,
-            past_key_value,
-            output_attentions,
-        )
-        attention_output = self.output(self_outputs[0], hidden_states)
-
-        outputs = (attention_output,) + self_outputs[
-            1:
-        ]  # add attentions if we output them
-        return outputs
-
-
-class BertIntermediate(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
-        if isinstance(config.hidden_act, str):
-            self.intermediate_act_fn = ACT2FN[config.hidden_act]
-        else:
-            self.intermediate_act_fn = config.hidden_act
-
-    def forward(self, hidden_states):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.intermediate_act_fn(hidden_states)
-        return hidden_states
-
-
-class BertOutput(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-        self.dropout = nn.Dropout(config.hidden_dropout_prob)
-
-    def forward(self, hidden_states, input_tensor):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.dropout(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states + input_tensor)
-        return hidden_states
-
-
-class BertLayer(nn.Module):
-    def __init__(self, config, layer_num):
-        super().__init__()
-        self.config = config
-        self.chunk_size_feed_forward = config.chunk_size_feed_forward
-        self.seq_len_dim = 1
-        self.attention = BertAttention(config)
-        self.layer_num = layer_num
-        if (
-            self.config.add_cross_attention
-            and layer_num % self.config.cross_attention_freq == 0
-        ):
-            self.crossattention = BertAttention(
-                config, is_cross_attention=self.config.add_cross_attention
-            )
-            self.has_cross_attention = True
-        else:
-            self.has_cross_attention = False
-        self.intermediate = BertIntermediate(config)
-        self.output = BertOutput(config)
-
-        self.intermediate_query = BertIntermediate(config)
-        self.output_query = BertOutput(config)
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_value=None,
-        output_attentions=False,
-        query_length=0,
-    ):
-        # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
-        self_attn_past_key_value = (
-            past_key_value[:2] if past_key_value is not None else None
-        )
-        self_attention_outputs = self.attention(
-            hidden_states,
-            attention_mask,
-            head_mask,
-            output_attentions=output_attentions,
-            past_key_value=self_attn_past_key_value,
-        )
-        attention_output = self_attention_outputs[0]
-        outputs = self_attention_outputs[1:-1]
-
-        present_key_value = self_attention_outputs[-1]
-
-        if query_length > 0:
-            query_attention_output = attention_output[:, :query_length, :]
-
-            if self.has_cross_attention:
-                assert (
-                    encoder_hidden_states is not None
-                ), "encoder_hidden_states must be given for cross-attention layers"
-                cross_attention_outputs = self.crossattention(
-                    query_attention_output,
-                    attention_mask,
-                    head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    output_attentions=output_attentions,
-                )
-                query_attention_output = cross_attention_outputs[0]
-                outputs = (
-                    outputs + cross_attention_outputs[1:-1]
-                )  # add cross attentions if we output attention weights
-
-            layer_output = apply_chunking_to_forward(
-                self.feed_forward_chunk_query,
-                self.chunk_size_feed_forward,
-                self.seq_len_dim,
-                query_attention_output,
-            )
-            if attention_output.shape[1] > query_length:
-                layer_output_text = apply_chunking_to_forward(
-                    self.feed_forward_chunk,
-                    self.chunk_size_feed_forward,
-                    self.seq_len_dim,
-                    attention_output[:, query_length:, :],
-                )
-                layer_output = torch.cat([layer_output, layer_output_text], dim=1)
-        else:
-            layer_output = apply_chunking_to_forward(
-                self.feed_forward_chunk,
-                self.chunk_size_feed_forward,
-                self.seq_len_dim,
-                attention_output,
-            )
-        outputs = (layer_output,) + outputs
-
-        outputs = outputs + (present_key_value,)
-
-        return outputs
-
-    def feed_forward_chunk(self, attention_output):
-        intermediate_output = self.intermediate(attention_output)
-        layer_output = self.output(intermediate_output, attention_output)
-        return layer_output
-
-    def feed_forward_chunk_query(self, attention_output):
-        intermediate_output = self.intermediate_query(attention_output)
-        layer_output = self.output_query(intermediate_output, attention_output)
-        return layer_output
-
-
-class BertEncoder(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.config = config
-        self.layer = nn.ModuleList(
-            [BertLayer(config, i) for i in range(config.num_hidden_layers)]
-        )
-
-    def forward(
-        self,
-        hidden_states,
-        attention_mask=None,
-        head_mask=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_values=None,
-        use_cache=None,
-        output_attentions=False,
-        output_hidden_states=False,
-        return_dict=True,
-        query_length=0,
-    ):
-        all_hidden_states = () if output_hidden_states else None
-        all_self_attentions = () if output_attentions else None
-        all_cross_attentions = (
-            () if output_attentions and self.config.add_cross_attention else None
-        )
-
-        next_decoder_cache = () if use_cache else None
-
-        for i in range(self.config.num_hidden_layers):
-            layer_module = self.layer[i]
-            if output_hidden_states:
-                all_hidden_states = all_hidden_states + (hidden_states,)
-
-            layer_head_mask = head_mask[i] if head_mask is not None else None
-            past_key_value = past_key_values[i] if past_key_values is not None else None
-
-            if getattr(self.config, "gradient_checkpointing", False) and self.training:
-
-                if use_cache:
-                    logger.warn(
-                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
-                    )
-                    use_cache = False
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        return module(
-                            *inputs, past_key_value, output_attentions, query_length
-                        )
-
-                    return custom_forward
-
-                layer_outputs = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(layer_module),
-                    hidden_states,
-                    attention_mask,
-                    layer_head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                )
-            else:
-                layer_outputs = layer_module(
-                    hidden_states,
-                    attention_mask,
-                    layer_head_mask,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    past_key_value,
-                    output_attentions,
-                    query_length,
-                )
-
-            hidden_states = layer_outputs[0]
-            if use_cache:
-                next_decoder_cache += (layer_outputs[-1],)
-            if output_attentions:
-                all_self_attentions = all_self_attentions + (layer_outputs[1],)
-                all_cross_attentions = all_cross_attentions + (layer_outputs[2],)
-
-        if output_hidden_states:
-            all_hidden_states = all_hidden_states + (hidden_states,)
-
-        if not return_dict:
-            return tuple(
-                v
-                for v in [
-                    hidden_states,
-                    next_decoder_cache,
-                    all_hidden_states,
-                    all_self_attentions,
-                    all_cross_attentions,
-                ]
-                if v is not None
-            )
-        return BaseModelOutputWithPastAndCrossAttentions(
-            last_hidden_state=hidden_states,
-            past_key_values=next_decoder_cache,
-            hidden_states=all_hidden_states,
-            attentions=all_self_attentions,
-            cross_attentions=all_cross_attentions,
-        )
-
-
-class BertPooler(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        self.activation = nn.Tanh()
-
-    def forward(self, hidden_states):
-        # We "pool" the model by simply taking the hidden state corresponding
-        # to the first token.
-        first_token_tensor = hidden_states[:, 0]
-        pooled_output = self.dense(first_token_tensor)
-        pooled_output = self.activation(pooled_output)
-        return pooled_output
-
-
-class BertPredictionHeadTransform(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
-        if isinstance(config.hidden_act, str):
-            self.transform_act_fn = ACT2FN[config.hidden_act]
-        else:
-            self.transform_act_fn = config.hidden_act
-        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
-
-    def forward(self, hidden_states):
-        hidden_states = self.dense(hidden_states)
-        hidden_states = self.transform_act_fn(hidden_states)
-        hidden_states = self.LayerNorm(hidden_states)
-        return hidden_states
-
-
-class BertLMPredictionHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.transform = BertPredictionHeadTransform(config)
-
-        # The output weights are the same as the input embeddings, but there is
-        # an output-only bias for each token.
-        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
-
-        self.bias = nn.Parameter(torch.zeros(config.vocab_size))
-
-        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
-        self.decoder.bias = self.bias
-
-    def forward(self, hidden_states):
-        hidden_states = self.transform(hidden_states)
-        hidden_states = self.decoder(hidden_states)
-        return hidden_states
-
-
-class BertOnlyMLMHead(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.predictions = BertLMPredictionHead(config)
-
-    def forward(self, sequence_output):
-        prediction_scores = self.predictions(sequence_output)
-        return prediction_scores
-
-
-class BertPreTrainedModel(PreTrainedModel):
-    """
-    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
-    models.
-    """
-
-    config_class = BertConfig
-    base_model_prefix = "bert"
-    _keys_to_ignore_on_load_missing = [r"position_ids"]
-
-    def _init_weights(self, module):
-        """Initialize the weights"""
-        if isinstance(module, (nn.Linear, nn.Embedding)):
-            # Slightly different from the TF version which uses truncated_normal for initialization
-            # cf https://github.com/pytorch/pytorch/pull/5617
-            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
-        elif isinstance(module, nn.LayerNorm):
-            module.bias.data.zero_()
-            module.weight.data.fill_(1.0)
-        if isinstance(module, nn.Linear) and module.bias is not None:
-            module.bias.data.zero_()
-
-
-class BertModel(BertPreTrainedModel):
-    """
-    The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
-    cross-attention is added between the self-attention layers, following the architecture described in `Attention is
-    all you need <https://arxiv.org/abs/1706.03762>`__ by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
-    Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
-    argument and :obj:`add_cross_attention` set to :obj:`True`; an :obj:`encoder_hidden_states` is then expected as an
-    input to the forward pass.
-    """
-
-    def __init__(self, config, add_pooling_layer=False):
-        super().__init__(config)
-        self.config = config
-
-        self.embeddings = BertEmbeddings(config)
-
-        self.encoder = BertEncoder(config)
-
-        self.pooler = BertPooler(config) if add_pooling_layer else None
-
-        self.init_weights()
-
-    def get_input_embeddings(self):
-        return self.embeddings.word_embeddings
-
-    def set_input_embeddings(self, value):
-        self.embeddings.word_embeddings = value
-
-    def _prune_heads(self, heads_to_prune):
-        """
-        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
-        class PreTrainedModel
-        """
-        for layer, heads in heads_to_prune.items():
-            self.encoder.layer[layer].attention.prune_heads(heads)
-
-    def get_extended_attention_mask(
-        self,
-        attention_mask: Tensor,
-        input_shape: Tuple[int],
-        device: device,
-        is_decoder: bool,
-        has_query: bool = False,
-    ) -> Tensor:
-        """
-        Makes broadcastable attention and causal masks so that future and masked tokens are ignored.
-
-        Arguments:
-            attention_mask (:obj:`torch.Tensor`):
-                Mask with ones indicating tokens to attend to, zeros for tokens to ignore.
-            input_shape (:obj:`Tuple[int]`):
-                The shape of the input to the model.
-            device: (:obj:`torch.device`):
-                The device of the input to the model.
-
-        Returns:
-            :obj:`torch.Tensor` The extended attention mask, with a the same dtype as :obj:`attention_mask.dtype`.
-        """
-        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
-        # ourselves in which case we just need to make it broadcastable to all heads.
-        if attention_mask.dim() == 3:
-            extended_attention_mask = attention_mask[:, None, :, :]
-        elif attention_mask.dim() == 2:
-            # Provided a padding mask of dimensions [batch_size, seq_length]
-            # - if the model is a decoder, apply a causal mask in addition to the padding mask
-            # - if the model is an encoder, make the mask broadcastable to [batch_size, num_heads, seq_length, seq_length]
-            if is_decoder:
-                batch_size, seq_length = input_shape
-
-                seq_ids = torch.arange(seq_length, device=device)
-                causal_mask = (
-                    seq_ids[None, None, :].repeat(batch_size, seq_length, 1)
-                    <= seq_ids[None, :, None]
-                )
-
-                # add a prefix ones mask to the causal mask
-                # causal and attention masks must have same type with pytorch version < 1.3
-                causal_mask = causal_mask.to(attention_mask.dtype)
-
-                if causal_mask.shape[1] < attention_mask.shape[1]:
-                    prefix_seq_len = attention_mask.shape[1] - causal_mask.shape[1]
-                    if has_query:  # UniLM style attention mask
-                        causal_mask = torch.cat(
-                            [
-                                torch.zeros(
-                                    (batch_size, prefix_seq_len, seq_length),
-                                    device=device,
-                                    dtype=causal_mask.dtype,
-                                ),
-                                causal_mask,
-                            ],
-                            axis=1,
-                        )
-                    causal_mask = torch.cat(
-                        [
-                            torch.ones(
-                                (batch_size, causal_mask.shape[1], prefix_seq_len),
-                                device=device,
-                                dtype=causal_mask.dtype,
-                            ),
-                            causal_mask,
-                        ],
-                        axis=-1,
-                    )
-                extended_attention_mask = (
-                    causal_mask[:, None, :, :] * attention_mask[:, None, None, :]
-                )
-            else:
-                extended_attention_mask = attention_mask[:, None, None, :]
-        else:
-            raise ValueError(
-                "Wrong shape for input_ids (shape {}) or attention_mask (shape {})".format(
-                    input_shape, attention_mask.shape
-                )
-            )
-
-        # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
-        # masked positions, this operation will create a tensor which is 0.0 for
-        # positions we want to attend and -10000.0 for masked positions.
-        # Since we are adding it to the raw scores before the softmax, this is
-        # effectively the same as removing these entirely.
-        extended_attention_mask = extended_attention_mask.to(
-            dtype=self.dtype
-        )  # fp16 compatibility
-        extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
-        return extended_attention_mask
-
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        position_ids=None,
-        head_mask=None,
-        query_embeds=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        past_key_values=None,
-        use_cache=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-        is_decoder=False,
-    ):
-        r"""
-        encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
-            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
-            the model is configured as a decoder.
-        encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
-            the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-        past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
-            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
-            If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
-            (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
-            instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
-        use_cache (:obj:`bool`, `optional`):
-            If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
-            decoding (see :obj:`past_key_values`).
-        """
-        output_attentions = (
-            output_attentions
-            if output_attentions is not None
-            else self.config.output_attentions
-        )
-        output_hidden_states = (
-            output_hidden_states
-            if output_hidden_states is not None
-            else self.config.output_hidden_states
-        )
-        return_dict = (
-            return_dict if return_dict is not None else self.config.use_return_dict
-        )
-
-        # use_cache = use_cache if use_cache is not None else self.config.use_cache
-
-        if input_ids is None:
-            assert (
-                query_embeds is not None
-            ), "You have to specify query_embeds when input_ids is None"
-
-        # past_key_values_length
-        past_key_values_length = (
-            past_key_values[0][0].shape[2] - self.config.query_length
-            if past_key_values is not None
-            else 0
-        )
-
-        query_length = query_embeds.shape[1] if query_embeds is not None else 0
-
-        embedding_output = self.embeddings(
-            input_ids=input_ids,
-            position_ids=position_ids,
-            query_embeds=query_embeds,
-            past_key_values_length=past_key_values_length,
-        )
-
-        input_shape = embedding_output.size()[:-1]
-        batch_size, seq_length = input_shape
-        device = embedding_output.device
-
-        if attention_mask is None:
-            attention_mask = torch.ones(
-                ((batch_size, seq_length + past_key_values_length)), device=device
-            )
-
-        # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
-        # ourselves in which case we just need to make it broadcastable to all heads.
-        if is_decoder:
-            extended_attention_mask = self.get_extended_attention_mask(
-                attention_mask,
-                input_ids.shape,
-                device,
-                is_decoder,
-                has_query=(query_embeds is not None),
-            )
-        else:
-            extended_attention_mask = self.get_extended_attention_mask(
-                attention_mask, input_shape, device, is_decoder
-            )
-
-        # If a 2D or 3D attention mask is provided for the cross-attention
-        # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
-        if encoder_hidden_states is not None:
-            if type(encoder_hidden_states) == list:
-                encoder_batch_size, encoder_sequence_length, _ = encoder_hidden_states[
-                    0
-                ].size()
-            else:
-                (
-                    encoder_batch_size,
-                    encoder_sequence_length,
-                    _,
-                ) = encoder_hidden_states.size()
-            encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
-
-            if type(encoder_attention_mask) == list:
-                encoder_extended_attention_mask = [
-                    self.invert_attention_mask(mask) for mask in encoder_attention_mask
-                ]
-            elif encoder_attention_mask is None:
-                encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
-                encoder_extended_attention_mask = self.invert_attention_mask(
-                    encoder_attention_mask
-                )
-            else:
-                encoder_extended_attention_mask = self.invert_attention_mask(
-                    encoder_attention_mask
-                )
-        else:
-            encoder_extended_attention_mask = None
-
-        # Prepare head mask if needed
-        # 1.0 in head_mask indicate we keep the head
-        # attention_probs has shape bsz x n_heads x N x N
-        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
-        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
-        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
-
-        encoder_outputs = self.encoder(
-            embedding_output,
-            attention_mask=extended_attention_mask,
-            head_mask=head_mask,
-            encoder_hidden_states=encoder_hidden_states,
-            encoder_attention_mask=encoder_extended_attention_mask,
-            past_key_values=past_key_values,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            query_length=query_length,
-        )
-        sequence_output = encoder_outputs[0]
-        pooled_output = (
-            self.pooler(sequence_output) if self.pooler is not None else None
-        )
-
-        if not return_dict:
-            return (sequence_output, pooled_output) + encoder_outputs[1:]
-
-        return BaseModelOutputWithPoolingAndCrossAttentions(
-            last_hidden_state=sequence_output,
-            pooler_output=pooled_output,
-            past_key_values=encoder_outputs.past_key_values,
-            hidden_states=encoder_outputs.hidden_states,
-            attentions=encoder_outputs.attentions,
-            cross_attentions=encoder_outputs.cross_attentions,
-        )
-
-
-class BertLMHeadModel(BertPreTrainedModel):
-
-    _keys_to_ignore_on_load_unexpected = [r"pooler"]
-    _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"]
-
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bert = BertModel(config, add_pooling_layer=False)
-        self.cls = BertOnlyMLMHead(config)
-
-        self.init_weights()
-
-    def get_output_embeddings(self):
-        return self.cls.predictions.decoder
-
-    def set_output_embeddings(self, new_embeddings):
-        self.cls.predictions.decoder = new_embeddings
-
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        position_ids=None,
-        head_mask=None,
-        query_embeds=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        labels=None,
-        past_key_values=None,
-        use_cache=True,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-        return_logits=False,
-        is_decoder=True,
-        reduction="mean",
-    ):
-        r"""
-        encoder_hidden_states  (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`):
-            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
-            the model is configured as a decoder.
-        encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
-            the cross-attention if the model is configured as a decoder. Mask values selected in ``[0, 1]``:
-            - 1 for tokens that are **not masked**,
-            - 0 for tokens that are **masked**.
-        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Labels for computing the left-to-right language modeling loss (next word prediction). Indices should be in
-            ``[-100, 0, ..., config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are
-            ignored (masked), the loss is only computed for the tokens with labels n ``[0, ..., config.vocab_size]``
-        past_key_values (:obj:`tuple(tuple(torch.FloatTensor))` of length :obj:`config.n_layers` with each tuple having 4 tensors of shape :obj:`(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
-            Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
-            If :obj:`past_key_values` are used, the user can optionally input only the last :obj:`decoder_input_ids`
-            (those that don't have their past key value states given to this model) of shape :obj:`(batch_size, 1)`
-            instead of all :obj:`decoder_input_ids` of shape :obj:`(batch_size, sequence_length)`.
-        use_cache (:obj:`bool`, `optional`):
-            If set to :obj:`True`, :obj:`past_key_values` key value states are returned and can be used to speed up
-            decoding (see :obj:`past_key_values`).
-        Returns:
-        Example::
-            >>> from transformers import BertTokenizer, BertLMHeadModel, BertConfig
-            >>> import torch
-            >>> tokenizer = BertTokenizer.from_pretrained('bert-base-cased')
-            >>> config = BertConfig.from_pretrained("bert-base-cased")
-            >>> model = BertLMHeadModel.from_pretrained('bert-base-cased', config=config)
-            >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
-            >>> outputs = model(**inputs)
-            >>> prediction_logits = outputs.logits
-        """
-        return_dict = (
-            return_dict if return_dict is not None else self.config.use_return_dict
-        )
-        if labels is not None:
-            use_cache = False
-        if past_key_values is not None:
-            query_embeds = None
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            query_embeds=query_embeds,
-            encoder_hidden_states=encoder_hidden_states,
-            encoder_attention_mask=encoder_attention_mask,
-            past_key_values=past_key_values,
-            use_cache=use_cache,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            is_decoder=is_decoder,
-        )
-
-        sequence_output = outputs[0]
-        if query_embeds is not None:
-            sequence_output = outputs[0][:, query_embeds.shape[1] :, :]
-
-        prediction_scores = self.cls(sequence_output)
-
-        if return_logits:
-            return prediction_scores[:, :-1, :].contiguous()
-
-        lm_loss = None
-        if labels is not None:
-            # we are doing next-token prediction; shift prediction scores and input ids by one
-            shifted_prediction_scores = prediction_scores[:, :-1, :].contiguous()
-            labels = labels[:, 1:].contiguous()
-            loss_fct = CrossEntropyLoss(reduction=reduction, label_smoothing=0.1)
-            lm_loss = loss_fct(
-                shifted_prediction_scores.view(-1, self.config.vocab_size),
-                labels.view(-1),
-            )
-            if reduction == "none":
-                lm_loss = lm_loss.view(prediction_scores.size(0), -1).sum(1)
-
-        if not return_dict:
-            output = (prediction_scores,) + outputs[2:]
-            return ((lm_loss,) + output) if lm_loss is not None else output
-
-        return CausalLMOutputWithCrossAttentions(
-            loss=lm_loss,
-            logits=prediction_scores,
-            past_key_values=outputs.past_key_values,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-            cross_attentions=outputs.cross_attentions,
-        )
-
-    def prepare_inputs_for_generation(
-        self, input_ids, query_embeds, past=None, attention_mask=None, **model_kwargs
-    ):
-        # if model is used as a decoder in encoder-decoder model, the decoder attention mask is created on the fly
-        if attention_mask is None:
-            attention_mask = input_ids.new_ones(input_ids.shape)
-        query_mask = input_ids.new_ones(query_embeds.shape[:-1])
-        attention_mask = torch.cat([query_mask, attention_mask], dim=-1)
-
-        # cut decoder_input_ids if past is used
-        if past is not None:
-            input_ids = input_ids[:, -1:]
-
-        return {
-            "input_ids": input_ids,
-            "query_embeds": query_embeds,
-            "attention_mask": attention_mask,
-            "past_key_values": past,
-            "encoder_hidden_states": model_kwargs.get("encoder_hidden_states", None),
-            "encoder_attention_mask": model_kwargs.get("encoder_attention_mask", None),
-            "is_decoder": True,
-        }
-
-    def _reorder_cache(self, past, beam_idx):
-        reordered_past = ()
-        for layer_past in past:
-            reordered_past += (
-                tuple(
-                    past_state.index_select(0, beam_idx) for past_state in layer_past
-                ),
-            )
-        return reordered_past
-
-
-class BertForMaskedLM(BertPreTrainedModel):
-
-    _keys_to_ignore_on_load_unexpected = [r"pooler"]
-    _keys_to_ignore_on_load_missing = [r"position_ids", r"predictions.decoder.bias"]
-
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bert = BertModel(config, add_pooling_layer=False)
-        self.cls = BertOnlyMLMHead(config)
-
-        self.init_weights()
-
-    def get_output_embeddings(self):
-        return self.cls.predictions.decoder
-
-    def set_output_embeddings(self, new_embeddings):
-        self.cls.predictions.decoder = new_embeddings
-
-    def forward(
-        self,
-        input_ids=None,
-        attention_mask=None,
-        position_ids=None,
-        head_mask=None,
-        query_embeds=None,
-        encoder_hidden_states=None,
-        encoder_attention_mask=None,
-        labels=None,
-        output_attentions=None,
-        output_hidden_states=None,
-        return_dict=None,
-        return_logits=False,
-        is_decoder=False,
-    ):
-        r"""
-        labels (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):
-            Labels for computing the masked language modeling loss. Indices should be in ``[-100, 0, ...,
-            config.vocab_size]`` (see ``input_ids`` docstring) Tokens with indices set to ``-100`` are ignored
-            (masked), the loss is only computed for the tokens with labels in ``[0, ..., config.vocab_size]``
-        """
-
-        return_dict = (
-            return_dict if return_dict is not None else self.config.use_return_dict
-        )
-
-        outputs = self.bert(
-            input_ids,
-            attention_mask=attention_mask,
-            position_ids=position_ids,
-            head_mask=head_mask,
-            query_embeds=query_embeds,
-            encoder_hidden_states=encoder_hidden_states,
-            encoder_attention_mask=encoder_attention_mask,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-            is_decoder=is_decoder,
-        )
-
-        if query_embeds is not None:
-            sequence_output = outputs[0][:, query_embeds.shape[1] :, :]
-        prediction_scores = self.cls(sequence_output)
-
-        if return_logits:
-            return prediction_scores
-
-        masked_lm_loss = None
-        if labels is not None:
-            loss_fct = CrossEntropyLoss()  # -100 index = padding token
-            masked_lm_loss = loss_fct(
-                prediction_scores.view(-1, self.config.vocab_size), labels.view(-1)
-            )
-
-        if not return_dict:
-            output = (prediction_scores,) + outputs[2:]
-            return (
-                ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
-            )
-
-        return MaskedLMOutput(
-            loss=masked_lm_loss,
-            logits=prediction_scores,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/modeling/matcher.py

@@ -1,135 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-from typing import List
-import torch
-
-
-class Matcher(object):
-    """
-    This class assigns to each predicted "element" (e.g., a box) a ground-truth
-    element. Each predicted element will have exactly zero or one matches; each
-    ground-truth element may be matched to zero or more predicted elements.
-
-    The matching is determined by the MxN match_quality_matrix, that characterizes
-    how well each (ground-truth, prediction)-pair match each other. For example,
-    if the elements are boxes, this matrix may contain box intersection-over-union
-    overlap values.
-
-    The matcher returns (a) a vector of length N containing the index of the
-    ground-truth element m in [0, M) that matches to prediction n in [0, N).
-    (b) a vector of length N containing the labels for each prediction.
-    """
-
-    def __init__(
-        self, thresholds: List[float], labels: List[int], allow_low_quality_matches: bool = False
-    ):
-        """
-        Args:
-            thresholds (list): a list of thresholds used to stratify predictions
-                into levels.
-            labels (list): a list of values to label predictions belonging at
-                each level. A label can be one of {-1, 0, 1} signifying
-                {ignore, negative class, positive class}, respectively.
-            allow_low_quality_matches (bool): if True, produce additional matches
-                for predictions with maximum match quality lower than high_threshold.
-                See set_low_quality_matches_ for more details.
-
-            For example,
-                thresholds = [0.3, 0.5]
-                labels = [0, -1, 1]
-                All predictions with iou < 0.3 will be marked with 0 and
-                thus will be considered as false positives while training.
-                All predictions with 0.3 <= iou < 0.5 will be marked with -1 and
-                thus will be ignored.
-                All predictions with 0.5 <= iou will be marked with 1 and
-                thus will be considered as true positives.
-        """
-        # Add -inf and +inf to first and last position in thresholds
-        thresholds = thresholds[:]
-        assert thresholds[0] > 0
-        thresholds.insert(0, -float("inf"))
-        thresholds.append(float("inf"))
-        assert all(low <= high for (low, high) in zip(thresholds[:-1], thresholds[1:]))
-        assert all(l in [-1, 0, 1] for l in labels)
-        assert len(labels) == len(thresholds) - 1
-        self.thresholds = thresholds
-        self.labels = labels
-        self.allow_low_quality_matches = allow_low_quality_matches
-
-    def __call__(self, match_quality_matrix):
-        """
-        Args:
-            match_quality_matrix (Tensor[float]): an MxN tensor, containing the
-                pairwise quality between M ground-truth elements and N predicted
-                elements. All elements must be >= 0 (due to the us of `torch.nonzero`
-                for selecting indices in :meth:`set_low_quality_matches_`).
-
-        Returns:
-            matches (Tensor[int64]): a vector of length N, where matches[i] is a matched
-                ground-truth index in [0, M)
-            match_labels (Tensor[int8]): a vector of length N, where pred_labels[i] indicates
-                whether a prediction is a true or false positive or ignored
-        """
-        assert match_quality_matrix.dim() == 2
-        if match_quality_matrix.numel() == 0:
-            default_matches = match_quality_matrix.new_full(
-                (match_quality_matrix.size(1),), 0, dtype=torch.int64
-            )
-            # When no gt boxes exist, we define IOU = 0 and therefore set labels
-            # to `self.labels[0]`, which usually defaults to background class 0
-            # To choose to ignore instead, can make labels=[-1,0,-1,1] + set appropriate thresholds
-            default_match_labels = match_quality_matrix.new_full(
-                (match_quality_matrix.size(1),), self.labels[0], dtype=torch.int8
-            )
-            return default_matches, default_match_labels
-
-        assert torch.all(match_quality_matrix >= 0)
-
-        # match_quality_matrix is M (gt) x N (predicted)
-        # Max over gt elements (dim 0) to find best gt candidate for each prediction
-        matched_vals, matches = match_quality_matrix.max(dim=0)
-
-        match_labels = matches.new_full(matches.size(), 1, dtype=torch.int8)
-
-        for (l, low, high) in zip(self.labels, self.thresholds[:-1], self.thresholds[1:]):
-            low_high = (matched_vals >= low) & (matched_vals < high)
-            match_labels[low_high] = l
-
-        if self.allow_low_quality_matches:
-            self.set_low_quality_matches_(match_labels, match_quality_matrix)
-
-        return matches, match_labels
-
-    def set_low_quality_matches_(self, match_labels, match_quality_matrix):
-        """
-        Produce additional matches for predictions that have only low-quality matches.
-        Specifically, for each ground-truth G find the set of predictions that have
-        maximum overlap with it (including ties); for each prediction in that set, if
-        it is unmatched, then match it to the ground-truth G.
-
-        This function implements the RPN assignment case (i) in Sec. 3.1.2 of the
-        Faster R-CNN paper: https://arxiv.org/pdf/1506.01497v3.pdf.
-        """
-        # For each gt, find the prediction with which it has highest quality
-        highest_quality_foreach_gt, _ = match_quality_matrix.max(dim=1)
-        # Find the highest quality match available, even if it is low, including ties.
-        # Note that the matches qualities must be positive due to the use of
-        # `torch.nonzero`.
-        gt_pred_pairs_of_highest_quality = torch.nonzero(
-            match_quality_matrix == highest_quality_foreach_gt[:, None]
-        )
-        # Example gt_pred_pairs_of_highest_quality:
-        #   tensor([[    0, 39796],
-        #           [    1, 32055],
-        #           [    1, 32070],
-        #           [    2, 39190],
-        #           [    2, 40255],
-        #           [    3, 40390],
-        #           [    3, 41455],
-        #           [    4, 45470],
-        #           [    5, 45325],
-        #           [    5, 46390]])
-        # Each row is a (gt index, prediction index)
-        # Note how gt items 1, 2, 3, and 5 each have two ties
-
-        pred_inds_to_update = gt_pred_pairs_of_highest_quality[:, 1]
-        match_labels[pred_inds_to_update] = 1

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

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

spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/scan.h

@@ -1,928 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
-#pragma once
-
-
-#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
-#include <thrust/system/cuda/config.h>
-#include <thrust/detail/type_traits.h>
-#include <thrust/functional.h>
-#include <thrust/detail/type_traits/iterator/is_output_iterator.h>
-
-#include <thrust/system/cuda/detail/execution_policy.h>
-#include <thrust/detail/cstdint.h>
-#include <thrust/detail/temporary_array.h>
-#include <thrust/system/cuda/detail/util.h>
-#include <cub/device/device_scan.cuh>
-#include <thrust/system/cuda/detail/core/agent_launcher.h>
-#include <thrust/system/cuda/detail/par_to_seq.h>
-#include <thrust/system/cuda/detail/dispatch.h>
-#include <thrust/detail/mpl/math.h>
-#include <thrust/detail/minmax.h>
-#include <thrust/distance.h>
-#include <thrust/iterator/iterator_traits.h>
-
-namespace thrust
-{
-template <typename DerivedPolicy,
-          typename InputIterator,
-          typename OutputIterator,
-          typename AssociativeOperator>
-__host__ __device__ OutputIterator
-inclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
-               InputIterator                                               first,
-               InputIterator                                               last,
-               OutputIterator                                              result,
-               AssociativeOperator                                         binary_op);
-
-template <typename DerivedPolicy,
-          typename InputIterator,
-          typename OutputIterator,
-          typename T,
-          typename AssociativeOperator>
-__host__ __device__ OutputIterator
-exclusive_scan(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
-               InputIterator                                               first,
-               InputIterator                                               last,
-               OutputIterator                                              result,
-               T                                                           init,
-               AssociativeOperator                                         binary_op);
-} // end namespace thrust
-
-namespace thrust
-{
-namespace cuda_cub {
-
-namespace __scan {
-
-  namespace mpl = thrust::detail::mpl::math;
-
-  template<class>
-  struct WarpSize { enum { value = 32 }; };
-
-  template <int                      _BLOCK_THREADS,
-            int                      _ITEMS_PER_THREAD = 1,
-            cub::BlockLoadAlgorithm  _LOAD_ALGORITHM   = cub::BLOCK_LOAD_DIRECT,
-            cub::CacheLoadModifier   _LOAD_MODIFIER    = cub::LOAD_DEFAULT,
-            cub::BlockStoreAlgorithm _STORE_ALGORITHM  = cub::BLOCK_STORE_DIRECT,
-            cub::BlockScanAlgorithm  _SCAN_ALGORITHM   = cub::BLOCK_SCAN_WARP_SCANS>
-  struct PtxPolicy
-  {
-    enum
-    {
-      BLOCK_THREADS    = _BLOCK_THREADS,
-      ITEMS_PER_THREAD = _ITEMS_PER_THREAD,
-      ITEMS_PER_TILE   = BLOCK_THREADS * ITEMS_PER_THREAD,
-    };
-
-    static const cub::BlockLoadAlgorithm  LOAD_ALGORITHM  = _LOAD_ALGORITHM;
-    static const cub::CacheLoadModifier   LOAD_MODIFIER   = _LOAD_MODIFIER;
-    static const cub::BlockStoreAlgorithm STORE_ALGORITHM = _STORE_ALGORITHM;
-    static const cub::BlockScanAlgorithm  SCAN_ALGORITHM  = _SCAN_ALGORITHM;
-  };    // struct PtxPolicy
-
-
-  // Scale the number of warps to keep same amount of "tile" storage
-  // as the nominal configuration for 4B data.  Minimum of two warps.
-  //
-  template<class Arch, int NOMINAL_4B_BLOCK_THREADS, class T>
-  struct THRUST_BLOCK_THREADS
-  {
-    enum
-    {
-      value = mpl::min<int,
-                       NOMINAL_4B_BLOCK_THREADS,
-                       mpl::max<int,
-                                3,
-                                ((NOMINAL_4B_BLOCK_THREADS /
-                                  WarpSize<Arch>::value) *
-                                 4) /
-                                    sizeof(T)>::value *
-                           WarpSize<Arch>::value>::value
-    };
-  }; // struct THRUST_BLOCK_THREADS
-
-  // If necessary, scale down number of items per thread to keep
-  // the same amount of "tile" storage as the nominal configuration for 4B data.
-  // Minimum 1 item per thread
-  //
-  template <class Arch,
-            int NOMINAL_4B_ITEMS_PER_THREAD,
-            int NOMINAL_4B_BLOCK_THREADS,
-            class T>
-  struct THRUST_ITEMS_PER_THREAD
-  {
-    enum
-    {
-      value = mpl::min<
-          int,
-          NOMINAL_4B_ITEMS_PER_THREAD,
-          mpl::max<
-              int,
-              1,
-              (NOMINAL_4B_ITEMS_PER_THREAD *
-               NOMINAL_4B_BLOCK_THREADS * 4 / sizeof(T)) /
-                  THRUST_BLOCK_THREADS<Arch,
-                                       NOMINAL_4B_BLOCK_THREADS,
-                                       T>::value>::value>::value
-    };
-  };
-
-
-  template <class Arch, class T, class U>
-  struct Tuning;
-
-  template<class T, class U>
-  struct Tuning<sm30,T,U>
-  {
-    typedef sm30 Arch;
-    enum
-    {
-      NOMINAL_4B_BLOCK_THREADS    = 256,
-      NOMINAL_4B_ITEMS_PER_THREAD = 9,
-    };
-
-    typedef PtxPolicy<THRUST_BLOCK_THREADS<Arch,
-                                           NOMINAL_4B_BLOCK_THREADS,
-                                           T>::value,
-                      THRUST_ITEMS_PER_THREAD<Arch,
-                                              NOMINAL_4B_ITEMS_PER_THREAD,
-                                              NOMINAL_4B_BLOCK_THREADS,
-                                              T>::value,
-                      cub::BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED,
-                      cub::LOAD_DEFAULT,
-                      cub::BLOCK_STORE_WARP_TRANSPOSE_TIMESLICED,
-                      cub::BLOCK_SCAN_RAKING_MEMOIZE>
-        type;
-  };    // struct Tuning for sm30
-
-  template<class T, class U>
-  struct Tuning<sm35,T,U>
-  {
-    typedef sm35 Arch;
-    enum
-    {
-      NOMINAL_4B_BLOCK_THREADS    = 128,
-      NOMINAL_4B_ITEMS_PER_THREAD = 12,
-    };
-
-    typedef PtxPolicy<THRUST_BLOCK_THREADS<Arch,
-                                           NOMINAL_4B_BLOCK_THREADS,
-                                           T>::value,
-                      THRUST_ITEMS_PER_THREAD<Arch,
-                                              NOMINAL_4B_ITEMS_PER_THREAD,
-                                              NOMINAL_4B_BLOCK_THREADS,
-                                              T>::value,
-                      cub::BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED,
-                      cub::LOAD_LDG,
-                      cub::BLOCK_STORE_WARP_TRANSPOSE_TIMESLICED,
-                      cub::BLOCK_SCAN_RAKING>
-        type;
-  };    // struct Tuning for sm35
-
-  template<class T, class U>
-  struct Tuning<sm52,T,U>
-  {
-    typedef sm52 Arch;
-    enum
-    {
-      NOMINAL_4B_BLOCK_THREADS    = 128,
-      NOMINAL_4B_ITEMS_PER_THREAD = 12,
-    };
-
-    typedef PtxPolicy<THRUST_BLOCK_THREADS<Arch,
-                                           NOMINAL_4B_BLOCK_THREADS,
-                                           T>::value,
-                      THRUST_ITEMS_PER_THREAD<Arch,
-                                              NOMINAL_4B_ITEMS_PER_THREAD,
-                                              NOMINAL_4B_BLOCK_THREADS,
-                                              T>::value,
-                      cub::BLOCK_LOAD_WARP_TRANSPOSE_TIMESLICED,
-                      cub::LOAD_LDG,
-                      cub::BLOCK_STORE_WARP_TRANSPOSE_TIMESLICED,
-                      cub::BLOCK_SCAN_RAKING>
-        type;
-  };    // struct Tuning for sm52
-
-  template <class InputIt,
-            class OutputIt,
-            class ScanOp,
-            class Size,
-            class T,
-            class Inclusive>
-  struct ScanAgent
-  {
-    typedef cub::ScanTileState<T> ScanTileState;
-    typedef cub::BlockScanRunningPrefixOp<T, ScanOp> RunningPrefixCallback;
-
-    template<class Arch>
-    struct PtxPlan : Tuning<Arch,T,T>::type
-    {
-      typedef Tuning<Arch, T, T> tuning;
-
-
-      typedef typename core::LoadIterator<PtxPlan, InputIt>::type LoadIt;
-      typedef typename core::BlockLoad<PtxPlan, LoadIt, T>::type    BlockLoad;
-      typedef typename core::BlockStore<PtxPlan, OutputIt, T>::type BlockStore;
-
-      typedef cub::TilePrefixCallbackOp<T, ScanOp, ScanTileState, Arch::ver>
-          TilePrefixCallback;
-      typedef cub::BlockScan<T,
-                             PtxPlan::BLOCK_THREADS,
-                             PtxPlan::SCAN_ALGORITHM,
-                             1,
-                             1,
-                             Arch::ver>
-          BlockScan;
-
-      union TempStorage
-      {
-        typename BlockLoad::TempStorage  load;
-        typename BlockStore::TempStorage store;
-
-        struct
-        {
-          typename TilePrefixCallback::TempStorage prefix;
-          typename BlockScan::TempStorage          scan;
-        };
-      };    // struct TempStorage
-    };    // struct PtxPlan
-    typedef typename core::specialize_plan_msvc10_war<PtxPlan>::type::type ptx_plan;
-
-    typedef typename ptx_plan::LoadIt             LoadIt;
-    typedef typename ptx_plan::BlockLoad          BlockLoad;
-    typedef typename ptx_plan::BlockStore         BlockStore;
-    typedef typename ptx_plan::TilePrefixCallback TilePrefixCallback;
-    typedef typename ptx_plan::BlockScan          BlockScan;
-    typedef typename ptx_plan::TempStorage        TempStorage;
-
-    enum
-    {
-      INCLUSIVE        = Inclusive::value,
-      BLOCK_THREADS    = ptx_plan::BLOCK_THREADS,
-      ITEMS_PER_THREAD = ptx_plan::ITEMS_PER_THREAD,
-      ITEMS_PER_TILE   = ptx_plan::ITEMS_PER_TILE,
-
-      SYNC_AFTER_LOAD = (ptx_plan::LOAD_ALGORITHM != cub::BLOCK_LOAD_DIRECT),
-    };
-
-    struct impl
-    {
-      //---------------------------------------------------------------------
-      // Per thread data
-      //---------------------------------------------------------------------
-
-      TempStorage &storage;
-      ScanTileState &tile_state;
-      LoadIt load_it;
-      OutputIt output_it;
-      ScanOp scan_op;
-
-      //---------------------------------------------------------------------
-      // Block scan utility methods (first tile)
-      //---------------------------------------------------------------------
-
-      // Exclusive scan specialization
-      //
-      template <class _ScanOp>
-      void THRUST_DEVICE_FUNCTION scan_tile(T (&items)[ITEMS_PER_THREAD],
-                                            _ScanOp scan_op,
-                                            T &     block_aggregate,
-                                            thrust::detail::false_type /* is_inclusive */)
-      {
-        BlockScan(storage.scan).ExclusiveScan(items, items, scan_op, block_aggregate);
-      }
-
-      // Exclusive sum specialization
-      //
-      void THRUST_DEVICE_FUNCTION scan_tile(T (&items)[ITEMS_PER_THREAD],
-                                            plus<T> /*scan_op*/,
-                                            T &     block_aggregate,
-                                            thrust::detail::false_type /* is_inclusive */)
-      {
-        BlockScan(storage.scan).ExclusiveSum(items, items, block_aggregate);
-      }
-
-      // Inclusive scan specialization
-      //
-      template <typename _ScanOp>
-      void THRUST_DEVICE_FUNCTION scan_tile(T (&items)[ITEMS_PER_THREAD],
-                                            _ScanOp scan_op,
-                                            T &     block_aggregate,
-                                            thrust::detail::true_type /* is_inclusive */)
-      {
-        BlockScan(storage.scan).InclusiveScan(items, items, scan_op, block_aggregate);
-      }
-
-
-      // Inclusive sum specialization
-      //
-      void THRUST_DEVICE_FUNCTION scan_tile(T (&items)[ITEMS_PER_THREAD],
-                                            plus<T> /*scan_op*/,
-                                            T &     block_aggregate,
-                                            thrust::detail::true_type /* is_inclusive */)
-      {
-        BlockScan(storage.scan).InclusiveSum(items, items, block_aggregate);
-      }
-
-      //---------------------------------------------------------------------
-      // Block scan utility methods (subsequent tiles)
-      //---------------------------------------------------------------------
-
-      // Exclusive scan specialization (with prefix from predecessors)
-      //
-      template <class _ScanOp, class PrefixCallback>
-      void THRUST_DEVICE_FUNCTION scan_tile(T (&items)[ITEMS_PER_THREAD],
-                                            _ScanOp         scan_op,
-                                            T &             block_aggregate,
-                                            PrefixCallback &prefix_op,
-                                            thrust::detail::false_type /* is_inclusive */)
-      {
-        BlockScan(storage.scan).ExclusiveScan(items, items, scan_op, prefix_op);
-        block_aggregate = prefix_op.GetBlockAggregate();
-      }
-
-      // Exclusive sum specialization (with prefix from predecessors)
-      //
-      template <class PrefixCallback>
-      THRUST_DEVICE_FUNCTION void scan_tile(T (&items)[ITEMS_PER_THREAD],
-                                            plus<T>         /*scan_op*/,
-                                            T &             block_aggregate,
-                                            PrefixCallback &prefix_op,
-                                            thrust::detail::false_type /* is_inclusive */)
-      {
-        BlockScan(storage.scan).ExclusiveSum(items, items, prefix_op);
-        block_aggregate = prefix_op.GetBlockAggregate();
-      }
-
-      // Inclusive scan specialization (with prefix from predecessors)
-      //
-      template <class _ScanOp, class PrefixCallback>
-      THRUST_DEVICE_FUNCTION void scan_tile(T (&items)[ITEMS_PER_THREAD],
-                                            _ScanOp         scan_op,
-                                            T &             block_aggregate,
-                                            PrefixCallback &prefix_op,
-                                            thrust::detail::true_type /* is_inclusive */)
-      {
-        BlockScan(storage.scan).InclusiveScan(items, items, scan_op, prefix_op);
-        block_aggregate = prefix_op.GetBlockAggregate();
-      }
-
-      // Inclusive sum specialization (with prefix from predecessors)
-      //
-      template <class U, class PrefixCallback>
-      THRUST_DEVICE_FUNCTION void scan_tile(T (&items)[ITEMS_PER_THREAD],
-                                            plus<T>         /*scan_op*/,
-                                            T &             block_aggregate,
-                                            PrefixCallback &prefix_op,
-                                            thrust::detail::true_type /* is_inclusive */)
-      {
-        BlockScan(storage.scan).InclusiveSum(items, items, prefix_op);
-        block_aggregate = prefix_op.GetBlockAggregate();
-      }
-
-      //---------------------------------------------------------------------
-      // Cooperatively scan a device-wide sequence of tiles with other CTAs
-      //---------------------------------------------------------------------
-
-      // Process a tile of input (dynamic chained scan)
-      //
-      template <bool IS_FULL_TILE, class AddInitToExclusive>
-      THRUST_DEVICE_FUNCTION void
-      consume_tile(Size               /*num_items*/,
-                   Size               num_remaining,
-                   int                tile_idx,
-                   Size               tile_base,
-                   AddInitToExclusive add_init_to_exclusive_scan)
-      {
-        using core::sync_threadblock;
-
-        // Load items
-        T items[ITEMS_PER_THREAD];
-
-        if (IS_FULL_TILE)
-        {
-          BlockLoad(storage.load).Load(load_it + tile_base, items);
-        }
-        else
-        {
-          // Fill last element with the first element
-          // because collectives are not suffix guarded
-          BlockLoad(storage.load)
-              .Load(load_it + tile_base,
-                    items,
-                    num_remaining,
-                    *(load_it + tile_base));
-        }
-
-        if (SYNC_AFTER_LOAD)
-          sync_threadblock();
-
-        // Perform tile scan
-        if (tile_idx == 0)
-        {
-          // Scan first tile
-          T block_aggregate;
-          scan_tile(items, scan_op, block_aggregate, Inclusive());
-
-          // Update tile status if there may be successor tiles (i.e., this tile is full)
-          if (IS_FULL_TILE && (threadIdx.x == 0))
-            tile_state.SetInclusive(0, block_aggregate);
-        }
-        else
-        {
-          // Scan non-first tile
-          T                  block_aggregate;
-          TilePrefixCallback prefix_op(tile_state, storage.prefix, scan_op, tile_idx);
-          scan_tile(items, scan_op, block_aggregate, prefix_op, Inclusive());
-        }
-
-        sync_threadblock();
-
-        add_init_to_exclusive_scan(items, tile_idx);
-
-        // Store items
-        if (IS_FULL_TILE)
-        {
-          BlockStore(storage.store).Store(output_it + tile_base, items);
-        }
-        else
-        {
-          BlockStore(storage.store).Store(output_it + tile_base, items, num_remaining);
-        }
-      }
-
-
-      //---------------------------------------------------------------------
-      // Constructor
-      //---------------------------------------------------------------------
-
-      // Dequeue and scan tiles of items as part of a dynamic chained scan
-      // with Init
-      template <class AddInitToExclusiveScan>
-      THRUST_DEVICE_FUNCTION
-      impl(TempStorage &          storage_,
-           ScanTileState &        tile_state_,
-           InputIt                input_it,
-           OutputIt               output_it_,
-           ScanOp                 scan_op_,
-           Size                   num_items,
-           AddInitToExclusiveScan add_init_to_exclusive_scan)
-          : storage(storage_),
-            tile_state(tile_state_),
-            load_it(core::make_load_iterator(ptx_plan(), input_it)),
-            output_it(output_it_),
-            scan_op(scan_op_)
-      {
-        int  tile_idx      = blockIdx.x;
-        Size tile_base     = ITEMS_PER_TILE * tile_idx;
-        Size num_remaining = num_items - tile_base;
-
-        if (num_remaining > ITEMS_PER_TILE)
-        {
-          // Full tile
-          consume_tile<true>(num_items,
-                             num_remaining,
-                             tile_idx,
-                             tile_base,
-                             add_init_to_exclusive_scan);
-        }
-        else if (num_remaining > 0)
-        {
-          // Partially-full tile
-          consume_tile<false>(num_items,
-                              num_remaining,
-                              tile_idx,
-                              tile_base,
-                              add_init_to_exclusive_scan);
-        }
-      }
-    };    // struct impl
-
-    //---------------------------------------------------------------------
-    // Agent entry point
-    //---------------------------------------------------------------------
-
-    template <class AddInitToExclusiveScan>
-    THRUST_AGENT_ENTRY(InputIt                input_it,
-                       OutputIt               output_it,
-                       ScanOp                 scan_op,
-                       Size                   num_items,
-                       ScanTileState          tile_state,
-                       AddInitToExclusiveScan add_init_to_exclusive_scan,
-                       char *                 shmem)
-    {
-      TempStorage &storage = *reinterpret_cast<TempStorage *>(shmem);
-      impl(storage,
-           tile_state,
-           input_it,
-           output_it,
-           scan_op,
-           num_items,
-           add_init_to_exclusive_scan);
-    }
-  };    // struct ScanAgent
-
-  template <class ScanTileState,
-            class Size>
-  struct InitAgent
-  {
-    template <class Arch>
-    struct PtxPlan : PtxPolicy<128> {};
-
-    typedef core::specialize_plan<PtxPlan> ptx_plan;
-
-    //---------------------------------------------------------------------
-    // Agent entry point
-    //---------------------------------------------------------------------
-
-    THRUST_AGENT_ENTRY(ScanTileState tile_state,
-                       Size          num_tiles,
-                       char *        /*shmem*/)
-    {
-      tile_state.InitializeStatus(num_tiles);
-    }
-
-  }; // struct InitAgent
-
-  template<class T>
-  struct DoNothing
-  {
-    typedef T     type;
-    template <int ITEMS_PER_THREAD>
-    THRUST_DEVICE_FUNCTION void
-    operator()(T (&items)[ITEMS_PER_THREAD], int /*tile_idx*/)
-    {
-      THRUST_UNUSED_VAR(items);
-    }
-  };    // struct DoNothing
-
-  template<class T, class ScanOp>
-  struct AddInitToExclusiveScan
-  {
-    typedef T type;
-    T         init;
-    ScanOp    scan_op;
-
-    THRUST_RUNTIME_FUNCTION
-    AddInitToExclusiveScan(T init_, ScanOp scan_op_)
-        : init(init_), scan_op(scan_op_) {}
-
-    template <int ITEMS_PER_THREAD>
-    THRUST_DEVICE_FUNCTION void
-    operator()(T (&items)[ITEMS_PER_THREAD], int tile_idx)
-    {
-      if (tile_idx == 0 && threadIdx.x == 0)
-      {
-        items[0] = init;
-        for (int i = 1; i < ITEMS_PER_THREAD; ++i)
-          items[i] = scan_op(init, items[i]);
-      }
-      else
-      {
-        for (int i = 0; i < ITEMS_PER_THREAD; ++i)
-          items[i] = scan_op(init, items[i]);
-      }
-    }
-  };    // struct AddInitToExclusiveScan
-
-  template <class Inclusive,
-            class InputIt,
-            class OutputIt,
-            class ScanOp,
-            class Size,
-            class AddInitToExclusiveScan>
-  static cudaError_t THRUST_RUNTIME_FUNCTION
-  doit_step(void *                 d_temp_storage,
-            size_t &               temp_storage_bytes,
-            InputIt                input_it,
-            Size                   num_items,
-            AddInitToExclusiveScan add_init_to_exclusive_scan,
-            OutputIt               output_it,
-            ScanOp                 scan_op,
-            cudaStream_t           stream,
-            bool                   debug_sync)
-  {
-    using core::AgentPlan;
-    using core::AgentLauncher;
-
-    cudaError_t status = cudaSuccess;
-    if (num_items == 0)
-      return cudaErrorNotSupported;
-
-    typedef typename AddInitToExclusiveScan::type T;
-
-    typedef AgentLauncher<
-        ScanAgent<InputIt, OutputIt, ScanOp, Size, T, Inclusive> >
-        scan_agent;
-
-    typedef typename scan_agent::ScanTileState ScanTileState;
-
-    typedef AgentLauncher<InitAgent<ScanTileState, Size> > init_agent;
-
-    AgentPlan scan_plan = scan_agent::get_plan(stream);
-    AgentPlan init_plan = init_agent::get_plan();
-
-    int tile_size = scan_plan.items_per_tile;
-    Size num_tiles = static_cast<Size>((num_items + tile_size - 1) / tile_size);
-
-    size_t vshmem_size = core::vshmem_size(scan_plan.shared_memory_size,
-                                           num_tiles);
-
-    size_t allocation_sizes[2] = {0, vshmem_size};
-    status = ScanTileState::AllocationSize(static_cast<int>(num_tiles), allocation_sizes[0]);
-    CUDA_CUB_RET_IF_FAIL(status);
-
-    void* allocations[2] = {NULL, NULL};
-
-    status = core::alias_storage(d_temp_storage,
-                                 temp_storage_bytes,
-                                 allocations,
-                                 allocation_sizes);
-    CUDA_CUB_RET_IF_FAIL(status);
-
-    if (d_temp_storage == NULL)
-    {
-      return status;
-    }
-
-    ScanTileState tile_state;
-    status = tile_state.Init(static_cast<int>(num_tiles), allocations[0], allocation_sizes[0]);
-    CUDA_CUB_RET_IF_FAIL(status);
-
-    char *vshmem_ptr = vshmem_size > 0 ? (char*)allocations[1] : NULL;
-
-    init_agent ia(init_plan, num_tiles, stream, "scan::init_agent", debug_sync);
-    ia.launch(tile_state, num_tiles);
-    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
-
-    scan_agent sa(scan_plan, num_items, stream, vshmem_ptr, "scan::scan_agent", debug_sync);
-    sa.launch(input_it,
-              output_it,
-              scan_op,
-              num_items,
-              tile_state,
-              add_init_to_exclusive_scan);
-    CUDA_CUB_RET_IF_FAIL(cudaPeekAtLastError());
-    return status;
-  }    // func doit_step
-
-  template <typename Inclusive,
-            typename Derived,
-            typename InputIt,
-            typename OutputIt,
-            typename Size,
-            typename ScanOp,
-            typename AddInitToExclusiveScan>
-  THRUST_RUNTIME_FUNCTION
-  OutputIt scan(execution_policy<Derived>& policy,
-                InputIt                    input_it,
-                OutputIt                   output_it,
-                Size                       num_items,
-                ScanOp                     scan_op,
-                AddInitToExclusiveScan     add_init_to_exclusive_scan)
-  {
-    if (num_items == 0)
-      return output_it;
-
-    size_t       storage_size = 0;
-    cudaStream_t stream       = cuda_cub::stream(policy);
-    bool         debug_sync   = THRUST_DEBUG_SYNC_FLAG;
-
-    cudaError_t status;
-    THRUST_INDEX_TYPE_DISPATCH(status,
-                                doit_step<Inclusive>,
-                                num_items,
-                                (NULL,
-                                storage_size,
-                                input_it,
-                                num_items_fixed,
-                                add_init_to_exclusive_scan,
-                                output_it,
-                                scan_op,
-                                stream,
-                                debug_sync));
-    cuda_cub::throw_on_error(status, "scan failed on 1st step");
-
-    // Allocate temporary storage.
-    thrust::detail::temporary_array<thrust::detail::uint8_t, Derived>
-      tmp(policy, storage_size);
-    void *ptr = static_cast<void*>(tmp.data().get());
-
-    THRUST_INDEX_TYPE_DISPATCH(status,
-                                doit_step<Inclusive>,
-                                num_items,
-                                (ptr,
-                                storage_size,
-                                input_it,
-                                num_items_fixed,
-                                add_init_to_exclusive_scan,
-                                output_it,
-                                scan_op,
-                                stream,
-                                debug_sync));
-    cuda_cub::throw_on_error(status, "scan failed on 2nd step");
-
-    status = cuda_cub::synchronize(policy);
-    cuda_cub::throw_on_error(status, "scan failed to synchronize");
-
-    return output_it + num_items;
-  }    // func scan
-
-}    // namespace __scan
-
-//-------------------------
-// Thrust API entry points
-//-------------------------
-
-__thrust_exec_check_disable__
-template <class Derived,
-          class InputIt,
-          class Size,
-          class OutputIt,
-          class ScanOp>
-OutputIt __host__ __device__
-inclusive_scan_n(execution_policy<Derived> &policy,
-                 InputIt                    first,
-                 Size                       num_items,
-                 OutputIt                   result,
-                 ScanOp                     scan_op)
-{
-  OutputIt ret = result;
-  if (__THRUST_HAS_CUDART__)
-  {
-    typedef typename iterator_traits<InputIt>::value_type T;
-    ret = __scan::scan<thrust::detail::true_type>(policy,
-                                                  first,
-                                                  result,
-                                                  num_items,
-                                                  scan_op,
-                                                  __scan::DoNothing<T>());
-  }
-  else
-  {
-#if !__THRUST_HAS_CUDART__
-    ret = thrust::inclusive_scan(cvt_to_seq(derived_cast(policy)),
-                                 first,
-                                 first + num_items,
-                                 result,
-                                 scan_op);
-#endif
-  }
-  return ret;
-}
-
-
-template <class Derived,
-          class InputIt,
-          class OutputIt,
-          class ScanOp>
-OutputIt __host__ __device__
-inclusive_scan(execution_policy<Derived> &policy,
-               InputIt                    first,
-               InputIt                    last,
-               OutputIt                   result,
-               ScanOp                     scan_op)
-{
-  typedef typename thrust::iterator_traits<InputIt>::difference_type diff_t;
-  diff_t num_items = thrust::distance(first, last);
-  return cuda_cub::inclusive_scan_n(policy, first, num_items, result, scan_op);
-}
-
-
-template <class Derived,
-          class InputIt,
-          class OutputIt>
-OutputIt __host__ __device__
-inclusive_scan(execution_policy<Derived> &policy,
-               InputIt                    first,
-               OutputIt                   last,
-               OutputIt                   result)
-{
-
-  typedef typename thrust::detail::eval_if<
-      thrust::detail::is_output_iterator<OutputIt>::value,
-      thrust::iterator_value<InputIt>,
-      thrust::iterator_value<OutputIt> >::type result_type;
-  return cuda_cub::inclusive_scan(policy, first, last, result, plus<result_type>());
-};
-
-__thrust_exec_check_disable__
-template <class Derived,
-          class InputIt,
-          class Size,
-          class OutputIt,
-          class T,
-          class ScanOp>
-OutputIt __host__ __device__
-exclusive_scan_n(execution_policy<Derived> &policy,
-                 InputIt                    first,
-                 Size                       num_items,
-                 OutputIt                   result,
-                 T                          init,
-                 ScanOp                     scan_op)
-{
-  OutputIt ret = result;
-  if (__THRUST_HAS_CUDART__)
-  {
-    ret = __scan::scan<thrust::detail::false_type>(
-        policy,
-        first,
-        result,
-        num_items,
-        scan_op,
-        __scan::AddInitToExclusiveScan<T, ScanOp>(init, scan_op));
-  }
-  else
-  {
-#if !__THRUST_HAS_CUDART__
-    ret = thrust::exclusive_scan(cvt_to_seq(derived_cast(policy)),
-                                 first,
-                                 first + num_items,
-                                 result,
-                                 init,
-                                 scan_op);
-#endif
-  }
-  return ret;
-}
-
-template <class Derived,
-          class InputIt,
-          class OutputIt,
-          class T,
-          class ScanOp>
-OutputIt __host__ __device__
-exclusive_scan(execution_policy<Derived> &policy,
-               InputIt                    first,
-               InputIt                    last,
-               OutputIt                   result,
-               T                          init,
-               ScanOp                   scan_op)
-{
-  typedef typename thrust::iterator_traits<InputIt>::difference_type diff_t;
-  diff_t num_items = thrust::distance(first, last);
-  return cuda_cub::exclusive_scan_n(policy, first, num_items, result, init, scan_op);
-}
-
-template <class Derived,
-          class InputIt,
-          class OutputIt,
-          class T>
-OutputIt __host__ __device__
-exclusive_scan(execution_policy<Derived> &policy,
-               InputIt                    first,
-               OutputIt                   last,
-               OutputIt                   result,
-               T                          init)
-{
-  return cuda_cub::exclusive_scan(policy, first, last, result, init, plus<T>());
-}
-
-template <class Derived,
-          class InputIt,
-          class OutputIt>
-OutputIt __host__ __device__
-exclusive_scan(execution_policy<Derived> &policy,
-               InputIt                    first,
-               OutputIt                   last,
-               OutputIt                   result)
-{
-  typedef typename thrust::detail::eval_if<
-      thrust::detail::is_output_iterator<OutputIt>::value,
-      thrust::iterator_value<InputIt>,
-      thrust::iterator_value<OutputIt>
-  >::type result_type;
-  return cuda_cub::exclusive_scan(policy, first, last, result, result_type(0));
-};
-
-} // namespace cuda_cub
-} // end namespace thrust
-
-#include <thrust/scan.h>
-
-#endif

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

@@ -1,95 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-
-/*! \file for_each.h
- *  \brief Sequential implementations of for_each functions.
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/detail/function.h>
-#include <thrust/system/detail/sequential/execution_policy.h>
-
-namespace thrust
-{
-namespace system
-{
-namespace detail
-{
-namespace sequential
-{
-
-
-__thrust_exec_check_disable__
-template<typename DerivedPolicy,
-         typename InputIterator,
-         typename UnaryFunction>
-__host__ __device__
-InputIterator for_each(sequential::execution_policy<DerivedPolicy> &,
-                       InputIterator first,
-                       InputIterator last,
-                       UnaryFunction f)
-{
-  // wrap f
-  thrust::detail::wrapped_function<
-    UnaryFunction,
-    void
-  > wrapped_f(f);
-
-  for(; first != last; ++first)
-  {
-    wrapped_f(*first);
-  }
-
-  return first;
-} // end for_each()
-
-
-template<typename DerivedPolicy,
-         typename InputIterator,
-         typename Size,
-         typename UnaryFunction>
-__host__ __device__
-InputIterator for_each_n(sequential::execution_policy<DerivedPolicy> &,
-                         InputIterator first,
-                         Size n,
-                         UnaryFunction f)
-{
-  // wrap f
-  thrust::detail::wrapped_function<
-    UnaryFunction,
-    void
-  > wrapped_f(f);
-
-  for(Size i = 0; i != n; i++)
-  {
-    // we can dereference an OutputIterator if f does not
-    // try to use the reference for anything besides assignment
-    wrapped_f(*first);
-    ++first;
-  }
-
-  return first;
-} // end for_each_n()
-
-
-} // end namespace sequential
-} // end namespace detail
-} // end namespace system
-} // end namespace thrust
-

spaces/CVPR/MonoScene/monoscene/monoscene.py

@@ -1,125 +0,0 @@
-import pytorch_lightning as pl
-import torch
-import torch.nn as nn
-from monoscene.unet3d_nyu import UNet3D as UNet3DNYU
-from monoscene.unet3d_kitti import UNet3D as UNet3DKitti
-from monoscene.flosp import FLoSP
-import numpy as np
-import torch.nn.functional as F
-from monoscene.unet2d import UNet2D
-
-
-class MonoScene(pl.LightningModule):
-    def __init__(
-        self,
-        n_classes,
-        feature,
-        project_scale,
-        full_scene_size,
-        dataset,
-        project_res=["1", "2", "4", "8"],
-        n_relations=4,
-        context_prior=True,
-        fp_loss=True,
-        frustum_size=4,
-        relation_loss=False,
-        CE_ssc_loss=True,
-        geo_scal_loss=True,
-        sem_scal_loss=True,
-        lr=1e-4,
-        weight_decay=1e-4,
-    ):
-        super().__init__()
-
-        self.project_res = project_res
-        self.fp_loss = fp_loss
-        self.dataset = dataset
-        self.context_prior = context_prior
-        self.frustum_size = frustum_size
-        self.relation_loss = relation_loss
-        self.CE_ssc_loss = CE_ssc_loss
-        self.sem_scal_loss = sem_scal_loss
-        self.geo_scal_loss = geo_scal_loss
-        self.project_scale = project_scale
-        self.lr = lr
-        self.weight_decay = weight_decay
-
-        self.projects = {}
-        self.scale_2ds = [1, 2, 4, 8]  # 2D scales
-        for scale_2d in self.scale_2ds:
-            self.projects[str(scale_2d)] = FLoSP(
-                full_scene_size, project_scale=self.project_scale, dataset=self.dataset
-            )
-        self.projects = nn.ModuleDict(self.projects)
-
-        self.n_classes = n_classes
-        if self.dataset == "NYU":
-            self.net_3d_decoder = UNet3DNYU(
-                self.n_classes,
-                nn.BatchNorm3d,
-                n_relations=n_relations,
-                feature=feature,
-                full_scene_size=full_scene_size,
-                context_prior=context_prior,
-            )
-        elif self.dataset == "kitti":
-            self.net_3d_decoder = UNet3DKitti(
-                self.n_classes,
-                nn.BatchNorm3d,
-                project_scale=project_scale,
-                feature=feature,
-                full_scene_size=full_scene_size,
-                context_prior=context_prior,
-            )
-        self.net_rgb = UNet2D.build(out_feature=feature, use_decoder=True)
-
-    def forward(self, batch):
-
-        img = batch["img"]
-        bs = len(img)
-
-        out = {}
-
-        x_rgb = self.net_rgb(img)
-
-        x3ds = []
-        for i in range(bs):
-            x3d = None
-            for scale_2d in self.project_res:
-
-                # project features at each 2D scale to target 3D scale
-                scale_2d = int(scale_2d)
-                projected_pix = batch["projected_pix_{}".format(self.project_scale)][i]#.cuda()
-                fov_mask = batch["fov_mask_{}".format(self.project_scale)][i]#.cuda()
-
-                # Sum all the 3D features
-                if x3d is None:
-                    x3d = self.projects[str(scale_2d)](
-                        x_rgb["1_" + str(scale_2d)][i],
-                        # torch.div(projected_pix, scale_2d, rounding_mode='floor'),
-                        projected_pix // scale_2d,
-                        fov_mask,
-                    )
-                else:
-                    x3d += self.projects[str(scale_2d)](
-                        x_rgb["1_" + str(scale_2d)][i],
-                        # torch.div(projected_pix, scale_2d, rounding_mode='floor'),
-                        projected_pix // scale_2d,
-                        fov_mask,
-                    )
-            x3ds.append(x3d)
-
-        input_dict = {
-            "x3d": torch.stack(x3ds),
-        }
-
-        out_dict = self.net_3d_decoder(input_dict)
-
-        ssc_pred = out_dict["ssc_logit"]
-    
-        y_pred = ssc_pred.detach().cpu().numpy()
-        y_pred = np.argmax(y_pred, axis=1)
-
-        return y_pred
-
-

spaces/CVPR/WALT/mmdet/models/losses/varifocal_loss.py

@@ -1,133 +0,0 @@
-import mmcv
-import torch.nn as nn
-import torch.nn.functional as F
-
-from ..builder import LOSSES
-from .utils import weight_reduce_loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-def varifocal_loss(pred,
-                   target,
-                   weight=None,
-                   alpha=0.75,
-                   gamma=2.0,
-                   iou_weighted=True,
-                   reduction='mean',
-                   avg_factor=None):
-    """`Varifocal Loss <https://arxiv.org/abs/2008.13367>`_
-
-    Args:
-        pred (torch.Tensor): The prediction with shape (N, C), C is the
-            number of classes
-        target (torch.Tensor): The learning target of the iou-aware
-            classification score with shape (N, C), C is the number of classes.
-        weight (torch.Tensor, optional): The weight of loss for each
-            prediction. Defaults to None.
-        alpha (float, optional): A balance factor for the negative part of
-            Varifocal Loss, which is different from the alpha of Focal Loss.
-            Defaults to 0.75.
-        gamma (float, optional): The gamma for calculating the modulating
-            factor. Defaults to 2.0.
-        iou_weighted (bool, optional): Whether to weight the loss of the
-            positive example with the iou target. Defaults to True.
-        reduction (str, optional): The method used to reduce the loss into
-            a scalar. Defaults to 'mean'. Options are "none", "mean" and
-            "sum".
-        avg_factor (int, optional): Average factor that is used to average
-            the loss. Defaults to None.
-    """
-    # pred and target should be of the same size
-    assert pred.size() == target.size()
-    pred_sigmoid = pred.sigmoid()
-    target = target.type_as(pred)
-    if iou_weighted:
-        focal_weight = target * (target > 0.0).float() + \
-            alpha * (pred_sigmoid - target).abs().pow(gamma) * \
-            (target <= 0.0).float()
-    else:
-        focal_weight = (target > 0.0).float() + \
-            alpha * (pred_sigmoid - target).abs().pow(gamma) * \
-            (target <= 0.0).float()
-    loss = F.binary_cross_entropy_with_logits(
-        pred, target, reduction='none') * focal_weight
-    loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
-    return loss
-
-
-@LOSSES.register_module()
-class VarifocalLoss(nn.Module):
-
-    def __init__(self,
-                 use_sigmoid=True,
-                 alpha=0.75,
-                 gamma=2.0,
-                 iou_weighted=True,
-                 reduction='mean',
-                 loss_weight=1.0):
-        """`Varifocal Loss <https://arxiv.org/abs/2008.13367>`_
-
-        Args:
-            use_sigmoid (bool, optional): Whether the prediction is
-                used for sigmoid or softmax. Defaults to True.
-            alpha (float, optional): A balance factor for the negative part of
-                Varifocal Loss, which is different from the alpha of Focal
-                Loss. Defaults to 0.75.
-            gamma (float, optional): The gamma for calculating the modulating
-                factor. Defaults to 2.0.
-            iou_weighted (bool, optional): Whether to weight the loss of the
-                positive examples with the iou target. Defaults to True.
-            reduction (str, optional): The method used to reduce the loss into
-                a scalar. Defaults to 'mean'. Options are "none", "mean" and
-                "sum".
-            loss_weight (float, optional): Weight of loss. Defaults to 1.0.
-        """
-        super(VarifocalLoss, self).__init__()
-        assert use_sigmoid is True, \
-            'Only sigmoid varifocal loss supported now.'
-        assert alpha >= 0.0
-        self.use_sigmoid = use_sigmoid
-        self.alpha = alpha
-        self.gamma = gamma
-        self.iou_weighted = iou_weighted
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None):
-        """Forward function.
-
-        Args:
-            pred (torch.Tensor): The prediction.
-            target (torch.Tensor): The learning target of the prediction.
-            weight (torch.Tensor, optional): The weight of loss for each
-                prediction. Defaults to None.
-            avg_factor (int, optional): Average factor that is used to average
-                the loss. Defaults to None.
-            reduction_override (str, optional): The reduction method used to
-                override the original reduction method of the loss.
-                Options are "none", "mean" and "sum".
-
-        Returns:
-            torch.Tensor: The calculated loss
-        """
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        if self.use_sigmoid:
-            loss_cls = self.loss_weight * varifocal_loss(
-                pred,
-                target,
-                weight,
-                alpha=self.alpha,
-                gamma=self.gamma,
-                iou_weighted=self.iou_weighted,
-                reduction=reduction,
-                avg_factor=avg_factor)
-        else:
-            raise NotImplementedError
-        return loss_cls

spaces/CVPR/regionclip-demo/detectron2/modeling/proposal_generator/rpn.py

@@ -1,533 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from typing import Dict, List, Optional, Tuple, Union
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from detectron2.config import configurable
-from detectron2.layers import Conv2d, ShapeSpec, cat
-from detectron2.structures import Boxes, ImageList, Instances, pairwise_iou
-from detectron2.utils.events import get_event_storage
-from detectron2.utils.memory import retry_if_cuda_oom
-from detectron2.utils.registry import Registry
-
-from ..anchor_generator import build_anchor_generator
-from ..box_regression import Box2BoxTransform, _dense_box_regression_loss
-from ..matcher import Matcher
-from ..sampling import subsample_labels
-from .build import PROPOSAL_GENERATOR_REGISTRY
-from .proposal_utils import find_top_rpn_proposals
-
-RPN_HEAD_REGISTRY = Registry("RPN_HEAD")
-RPN_HEAD_REGISTRY.__doc__ = """
-Registry for RPN heads, which take feature maps and perform
-objectness classification and bounding box regression for anchors.
-
-The registered object will be called with `obj(cfg, input_shape)`.
-The call should return a `nn.Module` object.
-"""
-
-
-"""
-Shape shorthand in this module:
-
-    N: number of images in the minibatch
-    L: number of feature maps per image on which RPN is run
-    A: number of cell anchors (must be the same for all feature maps)
-    Hi, Wi: height and width of the i-th feature map
-    B: size of the box parameterization
-
-Naming convention:
-
-    objectness: refers to the binary classification of an anchor as object vs. not object.
-
-    deltas: refers to the 4-d (dx, dy, dw, dh) deltas that parameterize the box2box
-    transform (see :class:`box_regression.Box2BoxTransform`), or 5d for rotated boxes.
-
-    pred_objectness_logits: predicted objectness scores in [-inf, +inf]; use
-        sigmoid(pred_objectness_logits) to estimate P(object).
-
-    gt_labels: ground-truth binary classification labels for objectness
-
-    pred_anchor_deltas: predicted box2box transform deltas
-
-    gt_anchor_deltas: ground-truth box2box transform deltas
-"""
-
-
-def build_rpn_head(cfg, input_shape):
-    """
-    Build an RPN head defined by `cfg.MODEL.RPN.HEAD_NAME`.
-    """
-    name = cfg.MODEL.RPN.HEAD_NAME
-    return RPN_HEAD_REGISTRY.get(name)(cfg, input_shape)
-
-
-@RPN_HEAD_REGISTRY.register()
-class StandardRPNHead(nn.Module):
-    """
-    Standard RPN classification and regression heads described in :paper:`Faster R-CNN`.
-    Uses a 3x3 conv to produce a shared hidden state from which one 1x1 conv predicts
-    objectness logits for each anchor and a second 1x1 conv predicts bounding-box deltas
-    specifying how to deform each anchor into an object proposal.
-    """
-
-    @configurable
-    def __init__(
-        self, *, in_channels: int, num_anchors: int, box_dim: int = 4, conv_dims: List[int] = (-1,)
-    ):
-        """
-        NOTE: this interface is experimental.
-
-        Args:
-            in_channels (int): number of input feature channels. When using multiple
-                input features, they must have the same number of channels.
-            num_anchors (int): number of anchors to predict for *each spatial position*
-                on the feature map. The total number of anchors for each
-                feature map will be `num_anchors * H * W`.
-            box_dim (int): dimension of a box, which is also the number of box regression
-                predictions to make for each anchor. An axis aligned box has
-                box_dim=4, while a rotated box has box_dim=5.
-            conv_dims (list[int]): a list of integers representing the output channels
-                of N conv layers. Set it to -1 to use the same number of output channels
-                as input channels.
-        """
-        super().__init__()
-        cur_channels = in_channels
-        # Keeping the old variable names and structure for backwards compatiblity.
-        # Otherwise the old checkpoints will fail to load.
-        if len(conv_dims) == 1:
-            out_channels = cur_channels if conv_dims[0] == -1 else conv_dims[0]
-            # 3x3 conv for the hidden representation
-            self.conv = self._get_rpn_conv(cur_channels, out_channels)
-            cur_channels = out_channels
-        else:
-            self.conv = nn.Sequential()
-            for k, conv_dim in enumerate(conv_dims):
-                out_channels = cur_channels if conv_dim == -1 else conv_dim
-                if out_channels <= 0:
-                    raise ValueError(
-                        f"Conv output channels should be greater than 0. Got {out_channels}"
-                    )
-                conv = self._get_rpn_conv(cur_channels, out_channels)
-                self.conv.add_module(f"conv{k}", conv)
-                cur_channels = out_channels
-        # 1x1 conv for predicting objectness logits
-        self.objectness_logits = nn.Conv2d(cur_channels, num_anchors, kernel_size=1, stride=1)
-        # 1x1 conv for predicting box2box transform deltas
-        self.anchor_deltas = nn.Conv2d(cur_channels, num_anchors * box_dim, kernel_size=1, stride=1)
-
-        # Keeping the order of weights initialization same for backwards compatiblility.
-        for layer in self.modules():
-            if isinstance(layer, nn.Conv2d):
-                nn.init.normal_(layer.weight, std=0.01)
-                nn.init.constant_(layer.bias, 0)
-
-    def _get_rpn_conv(self, in_channels, out_channels):
-        return Conv2d(
-            in_channels,
-            out_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            activation=nn.ReLU(),
-        )
-
-    @classmethod
-    def from_config(cls, cfg, input_shape):
-        # Standard RPN is shared across levels:
-        in_channels = [s.channels for s in input_shape]
-        assert len(set(in_channels)) == 1, "Each level must have the same channel!"
-        in_channels = in_channels[0]
-
-        # RPNHead should take the same input as anchor generator
-        # NOTE: it assumes that creating an anchor generator does not have unwanted side effect.
-        anchor_generator = build_anchor_generator(cfg, input_shape)
-        num_anchors = anchor_generator.num_anchors
-        box_dim = anchor_generator.box_dim
-        assert (
-            len(set(num_anchors)) == 1
-        ), "Each level must have the same number of anchors per spatial position"
-        return {
-            "in_channels": in_channels,
-            "num_anchors": num_anchors[0],
-            "box_dim": box_dim,
-            "conv_dims": cfg.MODEL.RPN.CONV_DIMS,
-        }
-
-    def forward(self, features: List[torch.Tensor]):
-        """
-        Args:
-            features (list[Tensor]): list of feature maps
-
-        Returns:
-            list[Tensor]: A list of L elements.
-                Element i is a tensor of shape (N, A, Hi, Wi) representing
-                the predicted objectness logits for all anchors. A is the number of cell anchors.
-            list[Tensor]: A list of L elements. Element i is a tensor of shape
-                (N, A*box_dim, Hi, Wi) representing the predicted "deltas" used to transform anchors
-                to proposals.
-        """
-        pred_objectness_logits = []
-        pred_anchor_deltas = []
-        for x in features:
-            t = self.conv(x)
-            pred_objectness_logits.append(self.objectness_logits(t))
-            pred_anchor_deltas.append(self.anchor_deltas(t))
-        return pred_objectness_logits, pred_anchor_deltas
-
-
-@PROPOSAL_GENERATOR_REGISTRY.register()
-class RPN(nn.Module):
-    """
-    Region Proposal Network, introduced by :paper:`Faster R-CNN`.
-    """
-
-    @configurable
-    def __init__(
-        self,
-        *,
-        in_features: List[str],
-        head: nn.Module,
-        anchor_generator: nn.Module,
-        anchor_matcher: Matcher,
-        box2box_transform: Box2BoxTransform,
-        batch_size_per_image: int,
-        positive_fraction: float,
-        pre_nms_topk: Tuple[float, float],
-        post_nms_topk: Tuple[float, float],
-        nms_thresh: float = 0.7,
-        min_box_size: float = 0.0,
-        anchor_boundary_thresh: float = -1.0,
-        loss_weight: Union[float, Dict[str, float]] = 1.0,
-        box_reg_loss_type: str = "smooth_l1",
-        smooth_l1_beta: float = 0.0,
-    ):
-        """
-        NOTE: this interface is experimental.
-
-        Args:
-            in_features (list[str]): list of names of input features to use
-            head (nn.Module): a module that predicts logits and regression deltas
-                for each level from a list of per-level features
-            anchor_generator (nn.Module): a module that creates anchors from a
-                list of features. Usually an instance of :class:`AnchorGenerator`
-            anchor_matcher (Matcher): label the anchors by matching them with ground truth.
-            box2box_transform (Box2BoxTransform): defines the transform from anchors boxes to
-                instance boxes
-            batch_size_per_image (int): number of anchors per image to sample for training
-            positive_fraction (float): fraction of foreground anchors to sample for training
-            pre_nms_topk (tuple[float]): (train, test) that represents the
-                number of top k proposals to select before NMS, in
-                training and testing.
-            post_nms_topk (tuple[float]): (train, test) that represents the
-                number of top k proposals to select after NMS, in
-                training and testing.
-            nms_thresh (float): NMS threshold used to de-duplicate the predicted proposals
-            min_box_size (float): remove proposal boxes with any side smaller than this threshold,
-                in the unit of input image pixels
-            anchor_boundary_thresh (float): legacy option
-            loss_weight (float|dict): weights to use for losses. Can be single float for weighting
-                all rpn losses together, or a dict of individual weightings. Valid dict keys are:
-                    "loss_rpn_cls" - applied to classification loss
-                    "loss_rpn_loc" - applied to box regression loss
-            box_reg_loss_type (str): Loss type to use. Supported losses: "smooth_l1", "giou".
-            smooth_l1_beta (float): beta parameter for the smooth L1 regression loss. Default to
-                use L1 loss. Only used when `box_reg_loss_type` is "smooth_l1"
-        """
-        super().__init__()
-        self.in_features = in_features
-        self.rpn_head = head
-        self.anchor_generator = anchor_generator
-        self.anchor_matcher = anchor_matcher
-        self.box2box_transform = box2box_transform
-        self.batch_size_per_image = batch_size_per_image
-        self.positive_fraction = positive_fraction
-        # Map from self.training state to train/test settings
-        self.pre_nms_topk = {True: pre_nms_topk[0], False: pre_nms_topk[1]}
-        self.post_nms_topk = {True: post_nms_topk[0], False: post_nms_topk[1]}
-        self.nms_thresh = nms_thresh
-        self.min_box_size = float(min_box_size)
-        self.anchor_boundary_thresh = anchor_boundary_thresh
-        if isinstance(loss_weight, float):
-            loss_weight = {"loss_rpn_cls": loss_weight, "loss_rpn_loc": loss_weight}
-        self.loss_weight = loss_weight
-        self.box_reg_loss_type = box_reg_loss_type
-        self.smooth_l1_beta = smooth_l1_beta
-
-    @classmethod
-    def from_config(cls, cfg, input_shape: Dict[str, ShapeSpec]):
-        in_features = cfg.MODEL.RPN.IN_FEATURES
-        ret = {
-            "in_features": in_features,
-            "min_box_size": cfg.MODEL.PROPOSAL_GENERATOR.MIN_SIZE,
-            "nms_thresh": cfg.MODEL.RPN.NMS_THRESH,
-            "batch_size_per_image": cfg.MODEL.RPN.BATCH_SIZE_PER_IMAGE,
-            "positive_fraction": cfg.MODEL.RPN.POSITIVE_FRACTION,
-            "loss_weight": {
-                "loss_rpn_cls": cfg.MODEL.RPN.LOSS_WEIGHT,
-                "loss_rpn_loc": cfg.MODEL.RPN.BBOX_REG_LOSS_WEIGHT * cfg.MODEL.RPN.LOSS_WEIGHT,
-            },
-            "anchor_boundary_thresh": cfg.MODEL.RPN.BOUNDARY_THRESH,
-            "box2box_transform": Box2BoxTransform(weights=cfg.MODEL.RPN.BBOX_REG_WEIGHTS),
-            "box_reg_loss_type": cfg.MODEL.RPN.BBOX_REG_LOSS_TYPE,
-            "smooth_l1_beta": cfg.MODEL.RPN.SMOOTH_L1_BETA,
-        }
-
-        ret["pre_nms_topk"] = (cfg.MODEL.RPN.PRE_NMS_TOPK_TRAIN, cfg.MODEL.RPN.PRE_NMS_TOPK_TEST)
-        ret["post_nms_topk"] = (cfg.MODEL.RPN.POST_NMS_TOPK_TRAIN, cfg.MODEL.RPN.POST_NMS_TOPK_TEST)
-
-        ret["anchor_generator"] = build_anchor_generator(cfg, [input_shape[f] for f in in_features])
-        ret["anchor_matcher"] = Matcher(
-            cfg.MODEL.RPN.IOU_THRESHOLDS, cfg.MODEL.RPN.IOU_LABELS, allow_low_quality_matches=True
-        )
-        ret["head"] = build_rpn_head(cfg, [input_shape[f] for f in in_features])
-        return ret
-
-    def _subsample_labels(self, label):
-        """
-        Randomly sample a subset of positive and negative examples, and overwrite
-        the label vector to the ignore value (-1) for all elements that are not
-        included in the sample.
-
-        Args:
-            labels (Tensor): a vector of -1, 0, 1. Will be modified in-place and returned.
-        """
-        pos_idx, neg_idx = subsample_labels(
-            label, self.batch_size_per_image, self.positive_fraction, 0
-        )
-        # Fill with the ignore label (-1), then set positive and negative labels
-        label.fill_(-1)
-        label.scatter_(0, pos_idx, 1)
-        label.scatter_(0, neg_idx, 0)
-        return label
-
-    @torch.jit.unused
-    @torch.no_grad()
-    def label_and_sample_anchors(
-        self, anchors: List[Boxes], gt_instances: List[Instances]
-    ) -> Tuple[List[torch.Tensor], List[torch.Tensor]]:
-        """
-        Args:
-            anchors (list[Boxes]): anchors for each feature map.
-            gt_instances: the ground-truth instances for each image.
-
-        Returns:
-            list[Tensor]:
-                List of #img tensors. i-th element is a vector of labels whose length is
-                the total number of anchors across all feature maps R = sum(Hi * Wi * A).
-                Label values are in {-1, 0, 1}, with meanings: -1 = ignore; 0 = negative
-                class; 1 = positive class.
-            list[Tensor]:
-                i-th element is a Rx4 tensor. The values are the matched gt boxes for each
-                anchor. Values are undefined for those anchors not labeled as 1.
-        """
-        anchors = Boxes.cat(anchors)
-
-        gt_boxes = [x.gt_boxes for x in gt_instances]
-        image_sizes = [x.image_size for x in gt_instances]
-        del gt_instances
-
-        gt_labels = []
-        matched_gt_boxes = []
-        for image_size_i, gt_boxes_i in zip(image_sizes, gt_boxes):
-            """
-            image_size_i: (h, w) for the i-th image
-            gt_boxes_i: ground-truth boxes for i-th image
-            """
-
-            match_quality_matrix = retry_if_cuda_oom(pairwise_iou)(gt_boxes_i, anchors)
-            matched_idxs, gt_labels_i = retry_if_cuda_oom(self.anchor_matcher)(match_quality_matrix)
-            # Matching is memory-expensive and may result in CPU tensors. But the result is small
-            gt_labels_i = gt_labels_i.to(device=gt_boxes_i.device)
-            del match_quality_matrix
-
-            if self.anchor_boundary_thresh >= 0:
-                # Discard anchors that go out of the boundaries of the image
-                # NOTE: This is legacy functionality that is turned off by default in Detectron2
-                anchors_inside_image = anchors.inside_box(image_size_i, self.anchor_boundary_thresh)
-                gt_labels_i[~anchors_inside_image] = -1
-
-            # A vector of labels (-1, 0, 1) for each anchor
-            gt_labels_i = self._subsample_labels(gt_labels_i)
-
-            if len(gt_boxes_i) == 0:
-                # These values won't be used anyway since the anchor is labeled as background
-                matched_gt_boxes_i = torch.zeros_like(anchors.tensor)
-            else:
-                # TODO wasted indexing computation for ignored boxes
-                matched_gt_boxes_i = gt_boxes_i[matched_idxs].tensor
-
-            gt_labels.append(gt_labels_i)  # N,AHW
-            matched_gt_boxes.append(matched_gt_boxes_i)
-        return gt_labels, matched_gt_boxes
-
-    @torch.jit.unused
-    def losses(
-        self,
-        anchors: List[Boxes],
-        pred_objectness_logits: List[torch.Tensor],
-        gt_labels: List[torch.Tensor],
-        pred_anchor_deltas: List[torch.Tensor],
-        gt_boxes: List[torch.Tensor],
-    ) -> Dict[str, torch.Tensor]:
-        """
-        Return the losses from a set of RPN predictions and their associated ground-truth.
-
-        Args:
-            anchors (list[Boxes or RotatedBoxes]): anchors for each feature map, each
-                has shape (Hi*Wi*A, B), where B is box dimension (4 or 5).
-            pred_objectness_logits (list[Tensor]): A list of L elements.
-                Element i is a tensor of shape (N, Hi*Wi*A) representing
-                the predicted objectness logits for all anchors.
-            gt_labels (list[Tensor]): Output of :meth:`label_and_sample_anchors`.
-            pred_anchor_deltas (list[Tensor]): A list of L elements. Element i is a tensor of shape
-                (N, Hi*Wi*A, 4 or 5) representing the predicted "deltas" used to transform anchors
-                to proposals.
-            gt_boxes (list[Tensor]): Output of :meth:`label_and_sample_anchors`.
-
-        Returns:
-            dict[loss name -> loss value]: A dict mapping from loss name to loss value.
-                Loss names are: `loss_rpn_cls` for objectness classification and
-                `loss_rpn_loc` for proposal localization.
-        """
-        num_images = len(gt_labels)
-        gt_labels = torch.stack(gt_labels)  # (N, sum(Hi*Wi*Ai))
-
-        # Log the number of positive/negative anchors per-image that's used in training
-        pos_mask = gt_labels == 1
-        num_pos_anchors = pos_mask.sum().item()
-        num_neg_anchors = (gt_labels == 0).sum().item()
-        storage = get_event_storage()
-        storage.put_scalar("rpn/num_pos_anchors", num_pos_anchors / num_images)
-        storage.put_scalar("rpn/num_neg_anchors", num_neg_anchors / num_images)
-
-        localization_loss = _dense_box_regression_loss(
-            anchors,
-            self.box2box_transform,
-            pred_anchor_deltas,
-            gt_boxes,
-            pos_mask,
-            box_reg_loss_type=self.box_reg_loss_type,
-            smooth_l1_beta=self.smooth_l1_beta,
-        )
-
-        valid_mask = gt_labels >= 0
-        objectness_loss = F.binary_cross_entropy_with_logits(
-            cat(pred_objectness_logits, dim=1)[valid_mask],
-            gt_labels[valid_mask].to(torch.float32),
-            reduction="sum",
-        )
-        normalizer = self.batch_size_per_image * num_images
-        losses = {
-            "loss_rpn_cls": objectness_loss / normalizer,
-            # The original Faster R-CNN paper uses a slightly different normalizer
-            # for loc loss. But it doesn't matter in practice
-            "loss_rpn_loc": localization_loss / normalizer,
-        }
-        losses = {k: v * self.loss_weight.get(k, 1.0) for k, v in losses.items()}
-        return losses
-
-    def forward(
-        self,
-        images: ImageList,
-        features: Dict[str, torch.Tensor],
-        gt_instances: Optional[List[Instances]] = None,
-    ):
-        """
-        Args:
-            images (ImageList): input images of length `N`
-            features (dict[str, Tensor]): input data as a mapping from feature
-                map name to tensor. Axis 0 represents the number of images `N` in
-                the input data; axes 1-3 are channels, height, and width, which may
-                vary between feature maps (e.g., if a feature pyramid is used).
-            gt_instances (list[Instances], optional): a length `N` list of `Instances`s.
-                Each `Instances` stores ground-truth instances for the corresponding image.
-
-        Returns:
-            proposals: list[Instances]: contains fields "proposal_boxes", "objectness_logits"
-            loss: dict[Tensor] or None
-        """
-        features = [features[f] for f in self.in_features]
-        anchors = self.anchor_generator(features)
-
-        pred_objectness_logits, pred_anchor_deltas = self.rpn_head(features)
-        # Transpose the Hi*Wi*A dimension to the middle:
-        pred_objectness_logits = [
-            # (N, A, Hi, Wi) -> (N, Hi, Wi, A) -> (N, Hi*Wi*A)
-            score.permute(0, 2, 3, 1).flatten(1)
-            for score in pred_objectness_logits
-        ]
-        pred_anchor_deltas = [
-            # (N, A*B, Hi, Wi) -> (N, A, B, Hi, Wi) -> (N, Hi, Wi, A, B) -> (N, Hi*Wi*A, B)
-            x.view(x.shape[0], -1, self.anchor_generator.box_dim, x.shape[-2], x.shape[-1])
-            .permute(0, 3, 4, 1, 2)
-            .flatten(1, -2)
-            for x in pred_anchor_deltas
-        ]
-
-        if self.training:
-            assert gt_instances is not None, "RPN requires gt_instances in training!"
-            gt_labels, gt_boxes = self.label_and_sample_anchors(anchors, gt_instances)
-            losses = self.losses(
-                anchors, pred_objectness_logits, gt_labels, pred_anchor_deltas, gt_boxes
-            )
-        else:
-            losses = {}
-        proposals = self.predict_proposals(
-            anchors, pred_objectness_logits, pred_anchor_deltas, images.image_sizes
-        )
-        return proposals, losses
-
-    def predict_proposals(
-        self,
-        anchors: List[Boxes],
-        pred_objectness_logits: List[torch.Tensor],
-        pred_anchor_deltas: List[torch.Tensor],
-        image_sizes: List[Tuple[int, int]],
-    ):
-        """
-        Decode all the predicted box regression deltas to proposals. Find the top proposals
-        by applying NMS and removing boxes that are too small.
-
-        Returns:
-            proposals (list[Instances]): list of N Instances. The i-th Instances
-                stores post_nms_topk object proposals for image i, sorted by their
-                objectness score in descending order.
-        """
-        # The proposals are treated as fixed for joint training with roi heads.
-        # This approach ignores the derivative w.r.t. the proposal boxes’ coordinates that
-        # are also network responses.
-        with torch.no_grad():
-            pred_proposals = self._decode_proposals(anchors, pred_anchor_deltas)
-            return find_top_rpn_proposals(
-                pred_proposals,
-                pred_objectness_logits,
-                image_sizes,
-                self.nms_thresh,
-                self.pre_nms_topk[self.training],
-                self.post_nms_topk[self.training],
-                self.min_box_size,
-                self.training,
-            )
-
-    def _decode_proposals(self, anchors: List[Boxes], pred_anchor_deltas: List[torch.Tensor]):
-        """
-        Transform anchors into proposals by applying the predicted anchor deltas.
-
-        Returns:
-            proposals (list[Tensor]): A list of L tensors. Tensor i has shape
-                (N, Hi*Wi*A, B)
-        """
-        N = pred_anchor_deltas[0].shape[0]
-        proposals = []
-        # For each feature map
-        for anchors_i, pred_anchor_deltas_i in zip(anchors, pred_anchor_deltas):
-            B = anchors_i.tensor.size(1)
-            pred_anchor_deltas_i = pred_anchor_deltas_i.reshape(-1, B)
-            # Expand anchors to shape (N*Hi*Wi*A, B)
-            anchors_i = anchors_i.tensor.unsqueeze(0).expand(N, -1, -1).reshape(-1, B)
-            proposals_i = self.box2box_transform.apply_deltas(pred_anchor_deltas_i, anchors_i)
-            # Append feature map proposals with shape (N, Hi*Wi*A, B)
-            proposals.append(proposals_i.view(N, -1, B))
-        return proposals

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

@@ -1,39 +0,0 @@
-from bs4 import BeautifulSoup
-import requests
-
-
-def model_url_list():
-    url_list = []
-    for i in range(0, 5):
-        url_list.append(
-            f"https://huggingface.co/models?p={i}&sort=downloads&search=dreambooth")
-    return url_list
-
-
-def data_scraping(url_list):
-    model_list = []
-    for url in url_list:
-        response = requests.get(url)
-        soup = BeautifulSoup(response.text, "html.parser")
-        div_class = 'grid grid-cols-1 gap-5 2xl:grid-cols-2'
-        div = soup.find('div', {'class': div_class})
-        for a in div.find_all('a', href=True):
-            model_list.append(a['href'])
-    return model_list
-
-
-def get_model_list():
-    model_list = data_scraping(model_url_list())
-    for i in range(len(model_list)):
-        model_list[i] = model_list[i][1:]
-
-    best_model_list = [
-        "dreamlike-art/dreamlike-photoreal-2.0",
-        "dreamlike-art/dreamlike-diffusion-1.0",
-        "runwayml/stable-diffusion-v1-5",
-        "CompVis/stable-diffusion-v1-4",
-        "prompthero/openjourney",
-    ]
-
-    model_list = best_model_list + model_list
-    return model_list

spaces/CloseEric/CloseEric/Dockerfile

@@ -1,11 +0,0 @@
-FROM node:18-bullseye-slim
-RUN apt-get update && \
-    apt-get install -y git
-RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app
-WORKDIR /app
-RUN npm install
-COPY Dockerfile greeting.md* .env* ./
-RUN npm run build
-EXPOSE 7860
-ENV NODE_ENV=production
-CMD [ "npm", "start" ]

spaces/DAMO-NLP-SG/Video-LLaMA/video_llama/processors/transforms_video.py

@@ -1,179 +0,0 @@
-#!/usr/bin/env python3
-"""
- Copyright (c) 2022, salesforce.com, inc.
- All rights reserved.
- SPDX-License-Identifier: BSD-3-Clause
- For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
-"""
-
-
-import numbers
-import random
-
-from torchvision.transforms import (
-    RandomCrop,
-    RandomResizedCrop,
-)
-
-import video_llama.processors.functional_video as F
-
-
-__all__ = [
-    "RandomCropVideo",
-    "RandomResizedCropVideo",
-    "CenterCropVideo",
-    "NormalizeVideo",
-    "ToTensorVideo",
-    "RandomHorizontalFlipVideo",
-]
-
-
-class RandomCropVideo(RandomCrop):
-    def __init__(self, size):
-        if isinstance(size, numbers.Number):
-            self.size = (int(size), int(size))
-        else:
-            self.size = size
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (C, T, H, W)
-        Returns:
-            torch.tensor: randomly cropped/resized video clip.
-                size is (C, T, OH, OW)
-        """
-        i, j, h, w = self.get_params(clip, self.size)
-        return F.crop(clip, i, j, h, w)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(size={self.size})"
-
-
-class RandomResizedCropVideo(RandomResizedCrop):
-    def __init__(
-        self,
-        size,
-        scale=(0.08, 1.0),
-        ratio=(3.0 / 4.0, 4.0 / 3.0),
-        interpolation_mode="bilinear",
-    ):
-        if isinstance(size, tuple):
-            if len(size) != 2:
-                raise ValueError(
-                    f"size should be tuple (height, width), instead got {size}"
-                )
-            self.size = size
-        else:
-            self.size = (size, size)
-
-        self.interpolation_mode = interpolation_mode
-        self.scale = scale
-        self.ratio = ratio
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (C, T, H, W)
-        Returns:
-            torch.tensor: randomly cropped/resized video clip.
-                size is (C, T, H, W)
-        """
-        i, j, h, w = self.get_params(clip, self.scale, self.ratio)
-        return F.resized_crop(clip, i, j, h, w, self.size, self.interpolation_mode)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(size={self.size}, interpolation_mode={self.interpolation_mode}, scale={self.scale}, ratio={self.ratio})"
-
-
-class CenterCropVideo:
-    def __init__(self, crop_size):
-        if isinstance(crop_size, numbers.Number):
-            self.crop_size = (int(crop_size), int(crop_size))
-        else:
-            self.crop_size = crop_size
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (C, T, H, W)
-        Returns:
-            torch.tensor: central cropping of video clip. Size is
-            (C, T, crop_size, crop_size)
-        """
-        return F.center_crop(clip, self.crop_size)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(crop_size={self.crop_size})"
-
-
-class NormalizeVideo:
-    """
-    Normalize the video clip by mean subtraction and division by standard deviation
-    Args:
-        mean (3-tuple): pixel RGB mean
-        std (3-tuple): pixel RGB standard deviation
-        inplace (boolean): whether do in-place normalization
-    """
-
-    def __init__(self, mean, std, inplace=False):
-        self.mean = mean
-        self.std = std
-        self.inplace = inplace
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): video clip to be normalized. Size is (C, T, H, W)
-        """
-        return F.normalize(clip, self.mean, self.std, self.inplace)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(mean={self.mean}, std={self.std}, inplace={self.inplace})"
-
-
-class ToTensorVideo:
-    """
-    Convert tensor data type from uint8 to float, divide value by 255.0 and
-    permute the dimensions of clip tensor
-    """
-
-    def __init__(self):
-        pass
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor, dtype=torch.uint8): Size is (T, H, W, C)
-        Return:
-            clip (torch.tensor, dtype=torch.float): Size is (C, T, H, W)
-        """
-        return F.to_tensor(clip)
-
-    def __repr__(self) -> str:
-        return self.__class__.__name__
-
-
-class RandomHorizontalFlipVideo:
-    """
-    Flip the video clip along the horizonal direction with a given probability
-    Args:
-        p (float): probability of the clip being flipped. Default value is 0.5
-    """
-
-    def __init__(self, p=0.5):
-        self.p = p
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Size is (C, T, H, W)
-        Return:
-            clip (torch.tensor): Size is (C, T, H, W)
-        """
-        if random.random() < self.p:
-            clip = F.hflip(clip)
-        return clip
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(p={self.p})"

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ufoLib/validators.py

@@ -1,1186 +0,0 @@
-"""Various low level data validators."""
-
-import calendar
-from io import open
-import fs.base
-import fs.osfs
-
-from collections.abc import Mapping
-from fontTools.ufoLib.utils import numberTypes
-
-
-# -------
-# Generic
-# -------
-
-
-def isDictEnough(value):
-    """
-    Some objects will likely come in that aren't
-    dicts but are dict-ish enough.
-    """
-    if isinstance(value, Mapping):
-        return True
-    for attr in ("keys", "values", "items"):
-        if not hasattr(value, attr):
-            return False
-    return True
-
-
-def genericTypeValidator(value, typ):
-    """
-    Generic. (Added at version 2.)
-    """
-    return isinstance(value, typ)
-
-
-def genericIntListValidator(values, validValues):
-    """
-    Generic. (Added at version 2.)
-    """
-    if not isinstance(values, (list, tuple)):
-        return False
-    valuesSet = set(values)
-    validValuesSet = set(validValues)
-    if valuesSet - validValuesSet:
-        return False
-    for value in values:
-        if not isinstance(value, int):
-            return False
-    return True
-
-
-def genericNonNegativeIntValidator(value):
-    """
-    Generic. (Added at version 3.)
-    """
-    if not isinstance(value, int):
-        return False
-    if value < 0:
-        return False
-    return True
-
-
-def genericNonNegativeNumberValidator(value):
-    """
-    Generic. (Added at version 3.)
-    """
-    if not isinstance(value, numberTypes):
-        return False
-    if value < 0:
-        return False
-    return True
-
-
-def genericDictValidator(value, prototype):
-    """
-    Generic. (Added at version 3.)
-    """
-    # not a dict
-    if not isinstance(value, Mapping):
-        return False
-    # missing required keys
-    for key, (typ, required) in prototype.items():
-        if not required:
-            continue
-        if key not in value:
-            return False
-    # unknown keys
-    for key in value.keys():
-        if key not in prototype:
-            return False
-    # incorrect types
-    for key, v in value.items():
-        prototypeType, required = prototype[key]
-        if v is None and not required:
-            continue
-        if not isinstance(v, prototypeType):
-            return False
-    return True
-
-
-# --------------
-# fontinfo.plist
-# --------------
-
-# Data Validators
-
-
-def fontInfoStyleMapStyleNameValidator(value):
-    """
-    Version 2+.
-    """
-    options = ["regular", "italic", "bold", "bold italic"]
-    return value in options
-
-
-def fontInfoOpenTypeGaspRangeRecordsValidator(value):
-    """
-    Version 3+.
-    """
-    if not isinstance(value, list):
-        return False
-    if len(value) == 0:
-        return True
-    validBehaviors = [0, 1, 2, 3]
-    dictPrototype = dict(rangeMaxPPEM=(int, True), rangeGaspBehavior=(list, True))
-    ppemOrder = []
-    for rangeRecord in value:
-        if not genericDictValidator(rangeRecord, dictPrototype):
-            return False
-        ppem = rangeRecord["rangeMaxPPEM"]
-        behavior = rangeRecord["rangeGaspBehavior"]
-        ppemValidity = genericNonNegativeIntValidator(ppem)
-        if not ppemValidity:
-            return False
-        behaviorValidity = genericIntListValidator(behavior, validBehaviors)
-        if not behaviorValidity:
-            return False
-        ppemOrder.append(ppem)
-    if ppemOrder != sorted(ppemOrder):
-        return False
-    return True
-
-
-def fontInfoOpenTypeHeadCreatedValidator(value):
-    """
-    Version 2+.
-    """
-    # format: 0000/00/00 00:00:00
-    if not isinstance(value, str):
-        return False
-    # basic formatting
-    if not len(value) == 19:
-        return False
-    if value.count(" ") != 1:
-        return False
-    date, time = value.split(" ")
-    if date.count("/") != 2:
-        return False
-    if time.count(":") != 2:
-        return False
-    # date
-    year, month, day = date.split("/")
-    if len(year) != 4:
-        return False
-    if len(month) != 2:
-        return False
-    if len(day) != 2:
-        return False
-    try:
-        year = int(year)
-        month = int(month)
-        day = int(day)
-    except ValueError:
-        return False
-    if month < 1 or month > 12:
-        return False
-    monthMaxDay = calendar.monthrange(year, month)[1]
-    if day < 1 or day > monthMaxDay:
-        return False
-    # time
-    hour, minute, second = time.split(":")
-    if len(hour) != 2:
-        return False
-    if len(minute) != 2:
-        return False
-    if len(second) != 2:
-        return False
-    try:
-        hour = int(hour)
-        minute = int(minute)
-        second = int(second)
-    except ValueError:
-        return False
-    if hour < 0 or hour > 23:
-        return False
-    if minute < 0 or minute > 59:
-        return False
-    if second < 0 or second > 59:
-        return False
-    # fallback
-    return True
-
-
-def fontInfoOpenTypeNameRecordsValidator(value):
-    """
-    Version 3+.
-    """
-    if not isinstance(value, list):
-        return False
-    dictPrototype = dict(
-        nameID=(int, True),
-        platformID=(int, True),
-        encodingID=(int, True),
-        languageID=(int, True),
-        string=(str, True),
-    )
-    for nameRecord in value:
-        if not genericDictValidator(nameRecord, dictPrototype):
-            return False
-    return True
-
-
-def fontInfoOpenTypeOS2WeightClassValidator(value):
-    """
-    Version 2+.
-    """
-    if not isinstance(value, int):
-        return False
-    if value < 0:
-        return False
-    return True
-
-
-def fontInfoOpenTypeOS2WidthClassValidator(value):
-    """
-    Version 2+.
-    """
-    if not isinstance(value, int):
-        return False
-    if value < 1:
-        return False
-    if value > 9:
-        return False
-    return True
-
-
-def fontInfoVersion2OpenTypeOS2PanoseValidator(values):
-    """
-    Version 2.
-    """
-    if not isinstance(values, (list, tuple)):
-        return False
-    if len(values) != 10:
-        return False
-    for value in values:
-        if not isinstance(value, int):
-            return False
-    # XXX further validation?
-    return True
-
-
-def fontInfoVersion3OpenTypeOS2PanoseValidator(values):
-    """
-    Version 3+.
-    """
-    if not isinstance(values, (list, tuple)):
-        return False
-    if len(values) != 10:
-        return False
-    for value in values:
-        if not isinstance(value, int):
-            return False
-        if value < 0:
-            return False
-    # XXX further validation?
-    return True
-
-
-def fontInfoOpenTypeOS2FamilyClassValidator(values):
-    """
-    Version 2+.
-    """
-    if not isinstance(values, (list, tuple)):
-        return False
-    if len(values) != 2:
-        return False
-    for value in values:
-        if not isinstance(value, int):
-            return False
-    classID, subclassID = values
-    if classID < 0 or classID > 14:
-        return False
-    if subclassID < 0 or subclassID > 15:
-        return False
-    return True
-
-
-def fontInfoPostscriptBluesValidator(values):
-    """
-    Version 2+.
-    """
-    if not isinstance(values, (list, tuple)):
-        return False
-    if len(values) > 14:
-        return False
-    if len(values) % 2:
-        return False
-    for value in values:
-        if not isinstance(value, numberTypes):
-            return False
-    return True
-
-
-def fontInfoPostscriptOtherBluesValidator(values):
-    """
-    Version 2+.
-    """
-    if not isinstance(values, (list, tuple)):
-        return False
-    if len(values) > 10:
-        return False
-    if len(values) % 2:
-        return False
-    for value in values:
-        if not isinstance(value, numberTypes):
-            return False
-    return True
-
-
-def fontInfoPostscriptStemsValidator(values):
-    """
-    Version 2+.
-    """
-    if not isinstance(values, (list, tuple)):
-        return False
-    if len(values) > 12:
-        return False
-    for value in values:
-        if not isinstance(value, numberTypes):
-            return False
-    return True
-
-
-def fontInfoPostscriptWindowsCharacterSetValidator(value):
-    """
-    Version 2+.
-    """
-    validValues = list(range(1, 21))
-    if value not in validValues:
-        return False
-    return True
-
-
-def fontInfoWOFFMetadataUniqueIDValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = dict(id=(str, True))
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    return True
-
-
-def fontInfoWOFFMetadataVendorValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = {
-        "name": (str, True),
-        "url": (str, False),
-        "dir": (str, False),
-        "class": (str, False),
-    }
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    if "dir" in value and value.get("dir") not in ("ltr", "rtl"):
-        return False
-    return True
-
-
-def fontInfoWOFFMetadataCreditsValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = dict(credits=(list, True))
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    if not len(value["credits"]):
-        return False
-    dictPrototype = {
-        "name": (str, True),
-        "url": (str, False),
-        "role": (str, False),
-        "dir": (str, False),
-        "class": (str, False),
-    }
-    for credit in value["credits"]:
-        if not genericDictValidator(credit, dictPrototype):
-            return False
-        if "dir" in credit and credit.get("dir") not in ("ltr", "rtl"):
-            return False
-    return True
-
-
-def fontInfoWOFFMetadataDescriptionValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = dict(url=(str, False), text=(list, True))
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    for text in value["text"]:
-        if not fontInfoWOFFMetadataTextValue(text):
-            return False
-    return True
-
-
-def fontInfoWOFFMetadataLicenseValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = dict(url=(str, False), text=(list, False), id=(str, False))
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    if "text" in value:
-        for text in value["text"]:
-            if not fontInfoWOFFMetadataTextValue(text):
-                return False
-    return True
-
-
-def fontInfoWOFFMetadataTrademarkValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = dict(text=(list, True))
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    for text in value["text"]:
-        if not fontInfoWOFFMetadataTextValue(text):
-            return False
-    return True
-
-
-def fontInfoWOFFMetadataCopyrightValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = dict(text=(list, True))
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    for text in value["text"]:
-        if not fontInfoWOFFMetadataTextValue(text):
-            return False
-    return True
-
-
-def fontInfoWOFFMetadataLicenseeValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = {"name": (str, True), "dir": (str, False), "class": (str, False)}
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    if "dir" in value and value.get("dir") not in ("ltr", "rtl"):
-        return False
-    return True
-
-
-def fontInfoWOFFMetadataTextValue(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = {
-        "text": (str, True),
-        "language": (str, False),
-        "dir": (str, False),
-        "class": (str, False),
-    }
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    if "dir" in value and value.get("dir") not in ("ltr", "rtl"):
-        return False
-    return True
-
-
-def fontInfoWOFFMetadataExtensionsValidator(value):
-    """
-    Version 3+.
-    """
-    if not isinstance(value, list):
-        return False
-    if not value:
-        return False
-    for extension in value:
-        if not fontInfoWOFFMetadataExtensionValidator(extension):
-            return False
-    return True
-
-
-def fontInfoWOFFMetadataExtensionValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = dict(names=(list, False), items=(list, True), id=(str, False))
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    if "names" in value:
-        for name in value["names"]:
-            if not fontInfoWOFFMetadataExtensionNameValidator(name):
-                return False
-    for item in value["items"]:
-        if not fontInfoWOFFMetadataExtensionItemValidator(item):
-            return False
-    return True
-
-
-def fontInfoWOFFMetadataExtensionItemValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = dict(id=(str, False), names=(list, True), values=(list, True))
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    for name in value["names"]:
-        if not fontInfoWOFFMetadataExtensionNameValidator(name):
-            return False
-    for val in value["values"]:
-        if not fontInfoWOFFMetadataExtensionValueValidator(val):
-            return False
-    return True
-
-
-def fontInfoWOFFMetadataExtensionNameValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = {
-        "text": (str, True),
-        "language": (str, False),
-        "dir": (str, False),
-        "class": (str, False),
-    }
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    if "dir" in value and value.get("dir") not in ("ltr", "rtl"):
-        return False
-    return True
-
-
-def fontInfoWOFFMetadataExtensionValueValidator(value):
-    """
-    Version 3+.
-    """
-    dictPrototype = {
-        "text": (str, True),
-        "language": (str, False),
-        "dir": (str, False),
-        "class": (str, False),
-    }
-    if not genericDictValidator(value, dictPrototype):
-        return False
-    if "dir" in value and value.get("dir") not in ("ltr", "rtl"):
-        return False
-    return True
-
-
-# ----------
-# Guidelines
-# ----------
-
-
-def guidelinesValidator(value, identifiers=None):
-    """
-    Version 3+.
-    """
-    if not isinstance(value, list):
-        return False
-    if identifiers is None:
-        identifiers = set()
-    for guide in value:
-        if not guidelineValidator(guide):
-            return False
-        identifier = guide.get("identifier")
-        if identifier is not None:
-            if identifier in identifiers:
-                return False
-            identifiers.add(identifier)
-    return True
-
-
-_guidelineDictPrototype = dict(
-    x=((int, float), False),
-    y=((int, float), False),
-    angle=((int, float), False),
-    name=(str, False),
-    color=(str, False),
-    identifier=(str, False),
-)
-
-
-def guidelineValidator(value):
-    """
-    Version 3+.
-    """
-    if not genericDictValidator(value, _guidelineDictPrototype):
-        return False
-    x = value.get("x")
-    y = value.get("y")
-    angle = value.get("angle")
-    # x or y must be present
-    if x is None and y is None:
-        return False
-    # if x or y are None, angle must not be present
-    if x is None or y is None:
-        if angle is not None:
-            return False
-    # if x and y are defined, angle must be defined
-    if x is not None and y is not None and angle is None:
-        return False
-    # angle must be between 0 and 360
-    if angle is not None:
-        if angle < 0:
-            return False
-        if angle > 360:
-            return False
-    # identifier must be 1 or more characters
-    identifier = value.get("identifier")
-    if identifier is not None and not identifierValidator(identifier):
-        return False
-    # color must follow the proper format
-    color = value.get("color")
-    if color is not None and not colorValidator(color):
-        return False
-    return True
-
-
-# -------
-# Anchors
-# -------
-
-
-def anchorsValidator(value, identifiers=None):
-    """
-    Version 3+.
-    """
-    if not isinstance(value, list):
-        return False
-    if identifiers is None:
-        identifiers = set()
-    for anchor in value:
-        if not anchorValidator(anchor):
-            return False
-        identifier = anchor.get("identifier")
-        if identifier is not None:
-            if identifier in identifiers:
-                return False
-            identifiers.add(identifier)
-    return True
-
-
-_anchorDictPrototype = dict(
-    x=((int, float), False),
-    y=((int, float), False),
-    name=(str, False),
-    color=(str, False),
-    identifier=(str, False),
-)
-
-
-def anchorValidator(value):
-    """
-    Version 3+.
-    """
-    if not genericDictValidator(value, _anchorDictPrototype):
-        return False
-    x = value.get("x")
-    y = value.get("y")
-    # x and y must be present
-    if x is None or y is None:
-        return False
-    # identifier must be 1 or more characters
-    identifier = value.get("identifier")
-    if identifier is not None and not identifierValidator(identifier):
-        return False
-    # color must follow the proper format
-    color = value.get("color")
-    if color is not None and not colorValidator(color):
-        return False
-    return True
-
-
-# ----------
-# Identifier
-# ----------
-
-
-def identifierValidator(value):
-    """
-    Version 3+.
-
-    >>> identifierValidator("a")
-    True
-    >>> identifierValidator("")
-    False
-    >>> identifierValidator("a" * 101)
-    False
-    """
-    validCharactersMin = 0x20
-    validCharactersMax = 0x7E
-    if not isinstance(value, str):
-        return False
-    if not value:
-        return False
-    if len(value) > 100:
-        return False
-    for c in value:
-        c = ord(c)
-        if c < validCharactersMin or c > validCharactersMax:
-            return False
-    return True
-
-
-# -----
-# Color
-# -----
-
-
-def colorValidator(value):
-    """
-    Version 3+.
-
-    >>> colorValidator("0,0,0,0")
-    True
-    >>> colorValidator(".5,.5,.5,.5")
-    True
-    >>> colorValidator("0.5,0.5,0.5,0.5")
-    True
-    >>> colorValidator("1,1,1,1")
-    True
-
-    >>> colorValidator("2,0,0,0")
-    False
-    >>> colorValidator("0,2,0,0")
-    False
-    >>> colorValidator("0,0,2,0")
-    False
-    >>> colorValidator("0,0,0,2")
-    False
-
-    >>> colorValidator("1r,1,1,1")
-    False
-    >>> colorValidator("1,1g,1,1")
-    False
-    >>> colorValidator("1,1,1b,1")
-    False
-    >>> colorValidator("1,1,1,1a")
-    False
-
-    >>> colorValidator("1 1 1 1")
-    False
-    >>> colorValidator("1 1,1,1")
-    False
-    >>> colorValidator("1,1 1,1")
-    False
-    >>> colorValidator("1,1,1 1")
-    False
-
-    >>> colorValidator("1, 1, 1, 1")
-    True
-    """
-    if not isinstance(value, str):
-        return False
-    parts = value.split(",")
-    if len(parts) != 4:
-        return False
-    for part in parts:
-        part = part.strip()
-        converted = False
-        try:
-            part = int(part)
-            converted = True
-        except ValueError:
-            pass
-        if not converted:
-            try:
-                part = float(part)
-                converted = True
-            except ValueError:
-                pass
-        if not converted:
-            return False
-        if part < 0:
-            return False
-        if part > 1:
-            return False
-    return True
-
-
-# -----
-# image
-# -----
-
-pngSignature = b"\x89PNG\r\n\x1a\n"
-
-_imageDictPrototype = dict(
-    fileName=(str, True),
-    xScale=((int, float), False),
-    xyScale=((int, float), False),
-    yxScale=((int, float), False),
-    yScale=((int, float), False),
-    xOffset=((int, float), False),
-    yOffset=((int, float), False),
-    color=(str, False),
-)
-
-
-def imageValidator(value):
-    """
-    Version 3+.
-    """
-    if not genericDictValidator(value, _imageDictPrototype):
-        return False
-    # fileName must be one or more characters
-    if not value["fileName"]:
-        return False
-    # color must follow the proper format
-    color = value.get("color")
-    if color is not None and not colorValidator(color):
-        return False
-    return True
-
-
-def pngValidator(path=None, data=None, fileObj=None):
-    """
-    Version 3+.
-
-    This checks the signature of the image data.
-    """
-    assert path is not None or data is not None or fileObj is not None
-    if path is not None:
-        with open(path, "rb") as f:
-            signature = f.read(8)
-    elif data is not None:
-        signature = data[:8]
-    elif fileObj is not None:
-        pos = fileObj.tell()
-        signature = fileObj.read(8)
-        fileObj.seek(pos)
-    if signature != pngSignature:
-        return False, "Image does not begin with the PNG signature."
-    return True, None
-
-
-# -------------------
-# layercontents.plist
-# -------------------
-
-
-def layerContentsValidator(value, ufoPathOrFileSystem):
-    """
-    Check the validity of layercontents.plist.
-    Version 3+.
-    """
-    if isinstance(ufoPathOrFileSystem, fs.base.FS):
-        fileSystem = ufoPathOrFileSystem
-    else:
-        fileSystem = fs.osfs.OSFS(ufoPathOrFileSystem)
-
-    bogusFileMessage = "layercontents.plist in not in the correct format."
-    # file isn't in the right format
-    if not isinstance(value, list):
-        return False, bogusFileMessage
-    # work through each entry
-    usedLayerNames = set()
-    usedDirectories = set()
-    contents = {}
-    for entry in value:
-        # layer entry in the incorrect format
-        if not isinstance(entry, list):
-            return False, bogusFileMessage
-        if not len(entry) == 2:
-            return False, bogusFileMessage
-        for i in entry:
-            if not isinstance(i, str):
-                return False, bogusFileMessage
-        layerName, directoryName = entry
-        # check directory naming
-        if directoryName != "glyphs":
-            if not directoryName.startswith("glyphs."):
-                return (
-                    False,
-                    "Invalid directory name (%s) in layercontents.plist."
-                    % directoryName,
-                )
-        if len(layerName) == 0:
-            return False, "Empty layer name in layercontents.plist."
-        # directory doesn't exist
-        if not fileSystem.exists(directoryName):
-            return False, "A glyphset does not exist at %s." % directoryName
-        # default layer name
-        if layerName == "public.default" and directoryName != "glyphs":
-            return (
-                False,
-                "The name public.default is being used by a layer that is not the default.",
-            )
-        # check usage
-        if layerName in usedLayerNames:
-            return (
-                False,
-                "The layer name %s is used by more than one layer." % layerName,
-            )
-        usedLayerNames.add(layerName)
-        if directoryName in usedDirectories:
-            return (
-                False,
-                "The directory %s is used by more than one layer." % directoryName,
-            )
-        usedDirectories.add(directoryName)
-        # store
-        contents[layerName] = directoryName
-    # missing default layer
-    foundDefault = "glyphs" in contents.values()
-    if not foundDefault:
-        return False, "The required default glyph set is not in the UFO."
-    return True, None
-
-
-# ------------
-# groups.plist
-# ------------
-
-
-def groupsValidator(value):
-    """
-    Check the validity of the groups.
-    Version 3+ (though it's backwards compatible with UFO 1 and UFO 2).
-
-    >>> groups = {"A" : ["A", "A"], "A2" : ["A"]}
-    >>> groupsValidator(groups)
-    (True, None)
-
-    >>> groups = {"" : ["A"]}
-    >>> valid, msg = groupsValidator(groups)
-    >>> valid
-    False
-    >>> print(msg)
-    A group has an empty name.
-
-    >>> groups = {"public.awesome" : ["A"]}
-    >>> groupsValidator(groups)
-    (True, None)
-
-    >>> groups = {"public.kern1." : ["A"]}
-    >>> valid, msg = groupsValidator(groups)
-    >>> valid
-    False
-    >>> print(msg)
-    The group data contains a kerning group with an incomplete name.
-    >>> groups = {"public.kern2." : ["A"]}
-    >>> valid, msg = groupsValidator(groups)
-    >>> valid
-    False
-    >>> print(msg)
-    The group data contains a kerning group with an incomplete name.
-
-    >>> groups = {"public.kern1.A" : ["A"], "public.kern2.A" : ["A"]}
-    >>> groupsValidator(groups)
-    (True, None)
-
-    >>> groups = {"public.kern1.A1" : ["A"], "public.kern1.A2" : ["A"]}
-    >>> valid, msg = groupsValidator(groups)
-    >>> valid
-    False
-    >>> print(msg)
-    The glyph "A" occurs in too many kerning groups.
-    """
-    bogusFormatMessage = "The group data is not in the correct format."
-    if not isDictEnough(value):
-        return False, bogusFormatMessage
-    firstSideMapping = {}
-    secondSideMapping = {}
-    for groupName, glyphList in value.items():
-        if not isinstance(groupName, (str)):
-            return False, bogusFormatMessage
-        if not isinstance(glyphList, (list, tuple)):
-            return False, bogusFormatMessage
-        if not groupName:
-            return False, "A group has an empty name."
-        if groupName.startswith("public."):
-            if not groupName.startswith("public.kern1.") and not groupName.startswith(
-                "public.kern2."
-            ):
-                # unknown public.* name. silently skip.
-                continue
-            else:
-                if len("public.kernN.") == len(groupName):
-                    return (
-                        False,
-                        "The group data contains a kerning group with an incomplete name.",
-                    )
-            if groupName.startswith("public.kern1."):
-                d = firstSideMapping
-            else:
-                d = secondSideMapping
-            for glyphName in glyphList:
-                if not isinstance(glyphName, str):
-                    return (
-                        False,
-                        "The group data %s contains an invalid member." % groupName,
-                    )
-                if glyphName in d:
-                    return (
-                        False,
-                        'The glyph "%s" occurs in too many kerning groups.' % glyphName,
-                    )
-                d[glyphName] = groupName
-    return True, None
-
-
-# -------------
-# kerning.plist
-# -------------
-
-
-def kerningValidator(data):
-    """
-    Check the validity of the kerning data structure.
-    Version 3+ (though it's backwards compatible with UFO 1 and UFO 2).
-
-    >>> kerning = {"A" : {"B" : 100}}
-    >>> kerningValidator(kerning)
-    (True, None)
-
-    >>> kerning = {"A" : ["B"]}
-    >>> valid, msg = kerningValidator(kerning)
-    >>> valid
-    False
-    >>> print(msg)
-    The kerning data is not in the correct format.
-
-    >>> kerning = {"A" : {"B" : "100"}}
-    >>> valid, msg = kerningValidator(kerning)
-    >>> valid
-    False
-    >>> print(msg)
-    The kerning data is not in the correct format.
-    """
-    bogusFormatMessage = "The kerning data is not in the correct format."
-    if not isinstance(data, Mapping):
-        return False, bogusFormatMessage
-    for first, secondDict in data.items():
-        if not isinstance(first, str):
-            return False, bogusFormatMessage
-        elif not isinstance(secondDict, Mapping):
-            return False, bogusFormatMessage
-        for second, value in secondDict.items():
-            if not isinstance(second, str):
-                return False, bogusFormatMessage
-            elif not isinstance(value, numberTypes):
-                return False, bogusFormatMessage
-    return True, None
-
-
-# -------------
-# lib.plist/lib
-# -------------
-
-_bogusLibFormatMessage = "The lib data is not in the correct format: %s"
-
-
-def fontLibValidator(value):
-    """
-    Check the validity of the lib.
-    Version 3+ (though it's backwards compatible with UFO 1 and UFO 2).
-
-    >>> lib = {"foo" : "bar"}
-    >>> fontLibValidator(lib)
-    (True, None)
-
-    >>> lib = {"public.awesome" : "hello"}
-    >>> fontLibValidator(lib)
-    (True, None)
-
-    >>> lib = {"public.glyphOrder" : ["A", "C", "B"]}
-    >>> fontLibValidator(lib)
-    (True, None)
-
-    >>> lib = "hello"
-    >>> valid, msg = fontLibValidator(lib)
-    >>> valid
-    False
-    >>> print(msg)  # doctest: +ELLIPSIS
-    The lib data is not in the correct format: expected a dictionary, ...
-
-    >>> lib = {1: "hello"}
-    >>> valid, msg = fontLibValidator(lib)
-    >>> valid
-    False
-    >>> print(msg)
-    The lib key is not properly formatted: expected str, found int: 1
-
-    >>> lib = {"public.glyphOrder" : "hello"}
-    >>> valid, msg = fontLibValidator(lib)
-    >>> valid
-    False
-    >>> print(msg)  # doctest: +ELLIPSIS
-    public.glyphOrder is not properly formatted: expected list or tuple,...
-
-    >>> lib = {"public.glyphOrder" : ["A", 1, "B"]}
-    >>> valid, msg = fontLibValidator(lib)
-    >>> valid
-    False
-    >>> print(msg)  # doctest: +ELLIPSIS
-    public.glyphOrder is not properly formatted: expected str,...
-    """
-    if not isDictEnough(value):
-        reason = "expected a dictionary, found %s" % type(value).__name__
-        return False, _bogusLibFormatMessage % reason
-    for key, value in value.items():
-        if not isinstance(key, str):
-            return False, (
-                "The lib key is not properly formatted: expected str, found %s: %r"
-                % (type(key).__name__, key)
-            )
-        # public.glyphOrder
-        if key == "public.glyphOrder":
-            bogusGlyphOrderMessage = "public.glyphOrder is not properly formatted: %s"
-            if not isinstance(value, (list, tuple)):
-                reason = "expected list or tuple, found %s" % type(value).__name__
-                return False, bogusGlyphOrderMessage % reason
-            for glyphName in value:
-                if not isinstance(glyphName, str):
-                    reason = "expected str, found %s" % type(glyphName).__name__
-                    return False, bogusGlyphOrderMessage % reason
-    return True, None
-
-
-# --------
-# GLIF lib
-# --------
-
-
-def glyphLibValidator(value):
-    """
-    Check the validity of the lib.
-    Version 3+ (though it's backwards compatible with UFO 1 and UFO 2).
-
-    >>> lib = {"foo" : "bar"}
-    >>> glyphLibValidator(lib)
-    (True, None)
-
-    >>> lib = {"public.awesome" : "hello"}
-    >>> glyphLibValidator(lib)
-    (True, None)
-
-    >>> lib = {"public.markColor" : "1,0,0,0.5"}
-    >>> glyphLibValidator(lib)
-    (True, None)
-
-    >>> lib = {"public.markColor" : 1}
-    >>> valid, msg = glyphLibValidator(lib)
-    >>> valid
-    False
-    >>> print(msg)
-    public.markColor is not properly formatted.
-    """
-    if not isDictEnough(value):
-        reason = "expected a dictionary, found %s" % type(value).__name__
-        return False, _bogusLibFormatMessage % reason
-    for key, value in value.items():
-        if not isinstance(key, str):
-            reason = "key (%s) should be a string" % key
-            return False, _bogusLibFormatMessage % reason
-        # public.markColor
-        if key == "public.markColor":
-            if not colorValidator(value):
-                return False, "public.markColor is not properly formatted."
-    return True, None
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()

spaces/Deep1994/t5-paraphrase/README.md

@@ -1,12 +0,0 @@
----
-title: T5 Paraphrase
-emoji: 👁
-colorFrom: red
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.2.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

spaces/Dinoking/Guccio-AI-Designer/netdissect/nethook.py

@@ -1,266 +0,0 @@
-'''
-Utilities for instrumenting a torch model.
-
-InstrumentedModel will wrap a pytorch model and allow hooking
-arbitrary layers to monitor or modify their output directly.
-
-Modified by Erik Härkönen:
-- 29.11.2019: Unhooking bugfix
-- 25.01.2020: Offset edits, removed old API
-'''
-
-import torch, numpy, types
-from collections import OrderedDict
-
-class InstrumentedModel(torch.nn.Module):
-    '''
-    A wrapper for hooking, probing and intervening in pytorch Modules.
-    Example usage:
-
-    ```
-    model = load_my_model()
-    with inst as InstrumentedModel(model):
-        inst.retain_layer(layername)
-        inst.edit_layer(layername, 0.5, target_features)
-        inst.edit_layer(layername, offset=offset_tensor)
-        inst(inputs)
-        original_features = inst.retained_layer(layername)
-    ```
-    '''
-
-    def __init__(self, model):
-        super(InstrumentedModel, self).__init__()
-        self.model = model
-        self._retained = OrderedDict()
-        self._ablation = {}
-        self._replacement = {}
-        self._offset = {}
-        self._hooked_layer = {}
-        self._old_forward = {}
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, type, value, traceback):
-        self.close()
-
-    def forward(self, *inputs, **kwargs):
-        return self.model(*inputs, **kwargs)
-
-    def retain_layer(self, layername):
-        '''
-        Pass a fully-qualified layer name (E.g., module.submodule.conv3)
-        to hook that layer and retain its output each time the model is run.
-        A pair (layername, aka) can be provided, and the aka will be used
-        as the key for the retained value instead of the layername.
-        '''
-        self.retain_layers([layername])
-
-    def retain_layers(self, layernames):
-        '''
-        Retains a list of a layers at once.
-        '''
-        self.add_hooks(layernames)
-        for layername in layernames:
-            aka = layername
-            if not isinstance(aka, str):
-                layername, aka = layername
-            if aka not in self._retained:
-                self._retained[aka] = None
-
-    def retained_features(self):
-        '''
-        Returns a dict of all currently retained features.
-        '''
-        return OrderedDict(self._retained)
-
-    def retained_layer(self, aka=None, clear=False):
-        '''
-        Retrieve retained data that was previously hooked by retain_layer.
-        Call this after the model is run.  If clear is set, then the
-        retained value will return and also cleared.
-        '''
-        if aka is None:
-            # Default to the first retained layer.
-            aka = next(self._retained.keys().__iter__())
-        result = self._retained[aka]
-        if clear:
-            self._retained[aka] = None
-        return result
-
-    def edit_layer(self, layername, ablation=None, replacement=None, offset=None):
-        '''
-        Pass a fully-qualified layer name (E.g., module.submodule.conv3)
-        to hook that layer and modify its output each time the model is run.
-        The output of the layer will be modified to be a convex combination
-        of the replacement and x interpolated according to the ablation, i.e.:
-        `output = x * (1 - a) + (r * a)`.
-        Additionally or independently, an offset can be added to the output.
-        '''
-        if not isinstance(layername, str):
-            layername, aka = layername
-        else:
-            aka = layername
-
-        # The default ablation if a replacement is specified is 1.0.
-        if ablation is None and replacement is not None:
-            ablation = 1.0
-        self.add_hooks([(layername, aka)])
-        if ablation is not None:
-            self._ablation[aka] = ablation
-        if replacement is not None:
-            self._replacement[aka] = replacement
-        if offset is not None:
-            self._offset[aka] = offset
-        # If needed, could add an arbitrary postprocessing lambda here.
-
-    def remove_edits(self, layername=None, remove_offset=True, remove_replacement=True):
-        '''
-        Removes edits at the specified layer, or removes edits at all layers
-        if no layer name is specified.
-        '''
-        if layername is None:
-            if remove_replacement:
-                self._ablation.clear()
-                self._replacement.clear()
-            if remove_offset:
-                self._offset.clear()
-            return
-
-        if not isinstance(layername, str):
-            layername, aka = layername
-        else:
-            aka = layername
-        if remove_replacement and aka in self._ablation:
-            del self._ablation[aka]
-        if remove_replacement and aka in self._replacement:
-            del self._replacement[aka]
-        if remove_offset and aka in self._offset:
-            del self._offset[aka]
-
-    def add_hooks(self, layernames):
-        '''
-        Sets up a set of layers to be hooked.
-
-        Usually not called directly: use edit_layer or retain_layer instead.
-        '''
-        needed = set()
-        aka_map = {}
-        for name in layernames:
-            aka = name
-            if not isinstance(aka, str):
-                name, aka = name
-            if self._hooked_layer.get(aka, None) != name:
-                aka_map[name] = aka
-                needed.add(name)
-        if not needed:
-            return
-        for name, layer in self.model.named_modules():
-            if name in aka_map:
-                needed.remove(name)
-                aka = aka_map[name]
-                self._hook_layer(layer, name, aka)
-        for name in needed:
-            raise ValueError('Layer %s not found in model' % name)
-
-    def _hook_layer(self, layer, layername, aka):
-        '''
-        Internal method to replace a forward method with a closure that
-        intercepts the call, and tracks the hook so that it can be reverted.
-        '''
-        if aka in self._hooked_layer:
-            raise ValueError('Layer %s already hooked' % aka)
-        if layername in self._old_forward:
-            raise ValueError('Layer %s already hooked' % layername)
-        self._hooked_layer[aka] = layername
-        self._old_forward[layername] = (layer, aka,
-                layer.__dict__.get('forward', None))
-        editor = self
-        original_forward = layer.forward
-        def new_forward(self, *inputs, **kwargs):
-            original_x = original_forward(*inputs, **kwargs)
-            x = editor._postprocess_forward(original_x, aka)
-            return x
-        layer.forward = types.MethodType(new_forward, layer)
-
-    def _unhook_layer(self, aka):
-        '''
-        Internal method to remove a hook, restoring the original forward method.
-        '''
-        if aka not in self._hooked_layer:
-            return
-        layername = self._hooked_layer[aka]
-        layer, check, old_forward = self._old_forward[layername]
-        assert check == aka
-        if old_forward is None:
-            if 'forward' in layer.__dict__:
-                del layer.__dict__['forward']
-        else:
-            layer.forward = old_forward
-        del self._old_forward[layername]
-        del self._hooked_layer[aka]
-        if aka in self._ablation:
-            del self._ablation[aka]
-        if aka in self._replacement:
-            del self._replacement[aka]
-        if aka in self._offset:
-            del self._offset[aka]
-        if aka in self._retained:
-            del self._retained[aka]
-
-    def _postprocess_forward(self, x, aka):
-        '''
-        The internal method called by the hooked layers after they are run.
-        '''
-        # Retain output before edits, if desired.
-        if aka in self._retained:
-            self._retained[aka] = x.detach()
-        
-        # Apply replacement edit
-        a = make_matching_tensor(self._ablation, aka, x)
-        if a is not None:
-            x = x * (1 - a)
-            v = make_matching_tensor(self._replacement, aka, x)
-            if v is not None:
-                x += (v * a)
-        
-        # Apply offset edit
-        b = make_matching_tensor(self._offset, aka, x)
-        if b is not None:
-            x = x + b
-        
-        return x
-
-    def close(self):
-        '''
-        Unhooks all hooked layers in the model.
-        '''
-        for aka in list(self._old_forward.keys()):
-            self._unhook_layer(aka)
-        assert len(self._old_forward) == 0
-
-
-def make_matching_tensor(valuedict, name, data):
-    '''
-    Converts `valuedict[name]` to be a tensor with the same dtype, device,
-    and dimension count as `data`, and caches the converted tensor.
-    '''
-    v = valuedict.get(name, None)
-    if v is None:
-        return None
-    if not isinstance(v, torch.Tensor):
-        # Accept non-torch data.
-        v = torch.from_numpy(numpy.array(v))
-        valuedict[name] = v
-    if not v.device == data.device or not v.dtype == data.dtype:
-        # Ensure device and type matches.
-        assert not v.requires_grad, '%s wrong device or type' % (name)
-        v = v.to(device=data.device, dtype=data.dtype)
-        valuedict[name] = v
-    if len(v.shape) < len(data.shape):
-        # Ensure dimensions are unsqueezed as needed.
-        assert not v.requires_grad, '%s wrong dimensions' % (name)
-        v = v.view((1,) + tuple(v.shape) +
-                (1,) * (len(data.shape) - len(v.shape) - 1))
-        valuedict[name] = v
-    return v

spaces/DragGan/DragGan-Inversion/training/augment.py

@@ -1,562 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Augmentation pipeline from the paper
-"Training Generative Adversarial Networks with Limited Data".
-Matches the original implementation by Karras et al. at
-https://github.com/NVlabs/stylegan2-ada/blob/main/training/augment.py"""
-
-import numpy as np
-import scipy.signal
-import torch
-from torch_utils import persistence
-from torch_utils import misc
-from torch_utils.ops import upfirdn2d
-from torch_utils.ops import grid_sample_gradfix
-from torch_utils.ops import conv2d_gradfix
-
-# ----------------------------------------------------------------------------
-# Coefficients of various wavelet decomposition low-pass filters.
-
-wavelets = {
-    'haar': [0.7071067811865476, 0.7071067811865476],
-    'db1':  [0.7071067811865476, 0.7071067811865476],
-    'db2':  [-0.12940952255092145, 0.22414386804185735, 0.836516303737469, 0.48296291314469025],
-    'db3':  [0.035226291882100656, -0.08544127388224149, -0.13501102001039084, 0.4598775021193313, 0.8068915093133388, 0.3326705529509569],
-    'db4':  [-0.010597401784997278, 0.032883011666982945, 0.030841381835986965, -0.18703481171888114, -0.02798376941698385, 0.6308807679295904, 0.7148465705525415, 0.23037781330885523],
-    'db5':  [0.003335725285001549, -0.012580751999015526, -0.006241490213011705, 0.07757149384006515, -0.03224486958502952, -0.24229488706619015, 0.13842814590110342, 0.7243085284385744, 0.6038292697974729, 0.160102397974125],
-    'db6':  [-0.00107730108499558, 0.004777257511010651, 0.0005538422009938016, -0.031582039318031156, 0.02752286553001629, 0.09750160558707936, -0.12976686756709563, -0.22626469396516913, 0.3152503517092432, 0.7511339080215775, 0.4946238903983854, 0.11154074335008017],
-    'db7':  [0.0003537138000010399, -0.0018016407039998328, 0.00042957797300470274, 0.012550998556013784, -0.01657454163101562, -0.03802993693503463, 0.0806126091510659, 0.07130921926705004, -0.22403618499416572, -0.14390600392910627, 0.4697822874053586, 0.7291320908465551, 0.39653931948230575, 0.07785205408506236],
-    'db8':  [-0.00011747678400228192, 0.0006754494059985568, -0.0003917403729959771, -0.00487035299301066, 0.008746094047015655, 0.013981027917015516, -0.04408825393106472, -0.01736930100202211, 0.128747426620186, 0.00047248457399797254, -0.2840155429624281, -0.015829105256023893, 0.5853546836548691, 0.6756307362980128, 0.3128715909144659, 0.05441584224308161],
-    'sym2': [-0.12940952255092145, 0.22414386804185735, 0.836516303737469, 0.48296291314469025],
-    'sym3': [0.035226291882100656, -0.08544127388224149, -0.13501102001039084, 0.4598775021193313, 0.8068915093133388, 0.3326705529509569],
-    'sym4': [-0.07576571478927333, -0.02963552764599851, 0.49761866763201545, 0.8037387518059161, 0.29785779560527736, -0.09921954357684722, -0.012603967262037833, 0.0322231006040427],
-    'sym5': [0.027333068345077982, 0.029519490925774643, -0.039134249302383094, 0.1993975339773936, 0.7234076904024206, 0.6339789634582119, 0.01660210576452232, -0.17532808990845047, -0.021101834024758855, 0.019538882735286728],
-    'sym6': [0.015404109327027373, 0.0034907120842174702, -0.11799011114819057, -0.048311742585633, 0.4910559419267466, 0.787641141030194, 0.3379294217276218, -0.07263752278646252, -0.021060292512300564, 0.04472490177066578, 0.0017677118642428036, -0.007800708325034148],
-    'sym7': [0.002681814568257878, -0.0010473848886829163, -0.01263630340325193, 0.03051551316596357, 0.0678926935013727, -0.049552834937127255, 0.017441255086855827, 0.5361019170917628, 0.767764317003164, 0.2886296317515146, -0.14004724044296152, -0.10780823770381774, 0.004010244871533663, 0.010268176708511255],
-    'sym8': [-0.0033824159510061256, -0.0005421323317911481, 0.03169508781149298, 0.007607487324917605, -0.1432942383508097, -0.061273359067658524, 0.4813596512583722, 0.7771857517005235, 0.3644418948353314, -0.05194583810770904, -0.027219029917056003, 0.049137179673607506, 0.003808752013890615, -0.01495225833704823, -0.0003029205147213668, 0.0018899503327594609],
-}
-
-# ----------------------------------------------------------------------------
-# Helpers for constructing transformation matrices.
-
-
-def matrix(*rows, device=None):
-    assert all(len(row) == len(rows[0]) for row in rows)
-    elems = [x for row in rows for x in row]
-    ref = [x for x in elems if isinstance(x, torch.Tensor)]
-    if len(ref) == 0:
-        return misc.constant(np.asarray(rows), device=device)
-    assert device is None or device == ref[0].device
-    elems = [x if isinstance(x, torch.Tensor) else misc.constant(
-        x, shape=ref[0].shape, device=ref[0].device) for x in elems]
-    return torch.stack(elems, dim=-1).reshape(ref[0].shape + (len(rows), -1))
-
-
-def translate2d(tx, ty, **kwargs):
-    return matrix(
-        [1, 0, tx],
-        [0, 1, ty],
-        [0, 0, 1],
-        **kwargs)
-
-
-def translate3d(tx, ty, tz, **kwargs):
-    return matrix(
-        [1, 0, 0, tx],
-        [0, 1, 0, ty],
-        [0, 0, 1, tz],
-        [0, 0, 0, 1],
-        **kwargs)
-
-
-def scale2d(sx, sy, **kwargs):
-    return matrix(
-        [sx, 0,  0],
-        [0,  sy, 0],
-        [0,  0,  1],
-        **kwargs)
-
-
-def scale3d(sx, sy, sz, **kwargs):
-    return matrix(
-        [sx, 0,  0,  0],
-        [0,  sy, 0,  0],
-        [0,  0,  sz, 0],
-        [0,  0,  0,  1],
-        **kwargs)
-
-
-def rotate2d(theta, **kwargs):
-    return matrix(
-        [torch.cos(theta), torch.sin(-theta), 0],
-        [torch.sin(theta), torch.cos(theta),  0],
-        [0,                0,                 1],
-        **kwargs)
-
-
-def rotate3d(v, theta, **kwargs):
-    vx = v[..., 0]
-    vy = v[..., 1]
-    vz = v[..., 2]
-    s = torch.sin(theta)
-    c = torch.cos(theta)
-    cc = 1 - c
-    return matrix(
-        [vx*vx*cc+c,    vx*vy*cc-vz*s, vx*vz*cc+vy*s, 0],
-        [vy*vx*cc+vz*s, vy*vy*cc+c,    vy*vz*cc-vx*s, 0],
-        [vz*vx*cc-vy*s, vz*vy*cc+vx*s, vz*vz*cc+c,    0],
-        [0,             0,             0,             1],
-        **kwargs)
-
-
-def translate2d_inv(tx, ty, **kwargs):
-    return translate2d(-tx, -ty, **kwargs)
-
-
-def scale2d_inv(sx, sy, **kwargs):
-    return scale2d(1 / sx, 1 / sy, **kwargs)
-
-
-def rotate2d_inv(theta, **kwargs):
-    return rotate2d(-theta, **kwargs)
-
-# ----------------------------------------------------------------------------
-# Versatile image augmentation pipeline from the paper
-# "Training Generative Adversarial Networks with Limited Data".
-#
-# All augmentations are disabled by default; individual augmentations can
-# be enabled by setting their probability multipliers to 1.
-
-
-@persistence.persistent_class
-class AugmentPipe(torch.nn.Module):
-    def __init__(self,
-                 xflip=0, rotate90=0, xint=0, xint_max=0.125,
-                 scale=0, rotate=0, aniso=0, xfrac=0, scale_std=0.2, rotate_max=1, aniso_std=0.2, xfrac_std=0.125,
-                 brightness=0, contrast=0, lumaflip=0, hue=0, saturation=0, brightness_std=0.2, contrast_std=0.5, hue_max=1, saturation_std=1,
-                 imgfilter=0, imgfilter_bands=[1, 1, 1, 1], imgfilter_std=1,
-                 noise=0, cutout=0, noise_std=0.1, cutout_size=0.5,
-                 ):
-        super().__init__()
-        # Overall multiplier for augmentation probability.
-        self.register_buffer('p', torch.ones([]))
-
-        # Pixel blitting.
-        # Probability multiplier for x-flip.
-        self.xflip = float(xflip)
-        # Probability multiplier for 90 degree rotations.
-        self.rotate90 = float(rotate90)
-        # Probability multiplier for integer translation.
-        self.xint = float(xint)
-        # Range of integer translation, relative to image dimensions.
-        self.xint_max = float(xint_max)
-
-        # General geometric transformations.
-        # Probability multiplier for isotropic scaling.
-        self.scale = float(scale)
-        # Probability multiplier for arbitrary rotation.
-        self.rotate = float(rotate)
-        # Probability multiplier for anisotropic scaling.
-        self.aniso = float(aniso)
-        # Probability multiplier for fractional translation.
-        self.xfrac = float(xfrac)
-        # Log2 standard deviation of isotropic scaling.
-        self.scale_std = float(scale_std)
-        # Range of arbitrary rotation, 1 = full circle.
-        self.rotate_max = float(rotate_max)
-        # Log2 standard deviation of anisotropic scaling.
-        self.aniso_std = float(aniso_std)
-        # Standard deviation of frational translation, relative to image dimensions.
-        self.xfrac_std = float(xfrac_std)
-
-        # Color transformations.
-        # Probability multiplier for brightness.
-        self.brightness = float(brightness)
-        # Probability multiplier for contrast.
-        self.contrast = float(contrast)
-        # Probability multiplier for luma flip.
-        self.lumaflip = float(lumaflip)
-        # Probability multiplier for hue rotation.
-        self.hue = float(hue)
-        # Probability multiplier for saturation.
-        self.saturation = float(saturation)
-        # Standard deviation of brightness.
-        self.brightness_std = float(brightness_std)
-        # Log2 standard deviation of contrast.
-        self.contrast_std = float(contrast_std)
-        # Range of hue rotation, 1 = full circle.
-        self.hue_max = float(hue_max)
-        # Log2 standard deviation of saturation.
-        self.saturation_std = float(saturation_std)
-
-        # Image-space filtering.
-        # Probability multiplier for image-space filtering.
-        self.imgfilter = float(imgfilter)
-        # Probability multipliers for individual frequency bands.
-        self.imgfilter_bands = list(imgfilter_bands)
-        # Log2 standard deviation of image-space filter amplification.
-        self.imgfilter_std = float(imgfilter_std)
-
-        # Image-space corruptions.
-        # Probability multiplier for additive RGB noise.
-        self.noise = float(noise)
-        # Probability multiplier for cutout.
-        self.cutout = float(cutout)
-        # Standard deviation of additive RGB noise.
-        self.noise_std = float(noise_std)
-        # Size of the cutout rectangle, relative to image dimensions.
-        self.cutout_size = float(cutout_size)
-
-        # Setup orthogonal lowpass filter for geometric augmentations.
-        self.register_buffer(
-            'Hz_geom', upfirdn2d.setup_filter(wavelets['sym6']))
-
-        # Construct filter bank for image-space filtering.
-        Hz_lo = np.asarray(wavelets['sym2'])            # H(z)
-        Hz_hi = Hz_lo * ((-1) ** np.arange(Hz_lo.size))  # H(-z)
-        Hz_lo2 = np.convolve(Hz_lo, Hz_lo[::-1]) / 2    # H(z) * H(z^-1) / 2
-        Hz_hi2 = np.convolve(Hz_hi, Hz_hi[::-1]) / 2    # H(-z) * H(-z^-1) / 2
-        Hz_fbank = np.eye(4, 1)                         # Bandpass(H(z), b_i)
-        for i in range(1, Hz_fbank.shape[0]):
-            Hz_fbank = np.dstack([Hz_fbank, np.zeros_like(Hz_fbank)]).reshape(
-                Hz_fbank.shape[0], -1)[:, :-1]
-            Hz_fbank = scipy.signal.convolve(Hz_fbank, [Hz_lo2])
-            Hz_fbank[i, (Hz_fbank.shape[1] - Hz_hi2.size) //
-                     2: (Hz_fbank.shape[1] + Hz_hi2.size) // 2] += Hz_hi2
-        self.register_buffer('Hz_fbank', torch.as_tensor(
-            Hz_fbank, dtype=torch.float32))
-
-    def forward(self, images, debug_percentile=None):
-        assert isinstance(images, torch.Tensor) and images.ndim == 4
-        batch_size, num_channels, height, width = images.shape
-        device = images.device
-        if debug_percentile is not None:
-            debug_percentile = torch.as_tensor(
-                debug_percentile, dtype=torch.float32, device=device)
-
-        # -------------------------------------
-        # Select parameters for pixel blitting.
-        # -------------------------------------
-
-        # Initialize inverse homogeneous 2D transform: G_inv @ pixel_out ==> pixel_in
-        I_3 = torch.eye(3, device=device)
-        G_inv = I_3
-
-        # Apply x-flip with probability (xflip * strength).
-        if self.xflip > 0:
-            i = torch.floor(torch.rand([batch_size], device=device) * 2)
-            i = torch.where(torch.rand(
-                [batch_size], device=device) < self.xflip * self.p, i, torch.zeros_like(i))
-            if debug_percentile is not None:
-                i = torch.full_like(i, torch.floor(debug_percentile * 2))
-            G_inv = G_inv @ scale2d_inv(1 - 2 * i, 1)
-
-        # Apply 90 degree rotations with probability (rotate90 * strength).
-        if self.rotate90 > 0:
-            i = torch.floor(torch.rand([batch_size], device=device) * 4)
-            i = torch.where(torch.rand(
-                [batch_size], device=device) < self.rotate90 * self.p, i, torch.zeros_like(i))
-            if debug_percentile is not None:
-                i = torch.full_like(i, torch.floor(debug_percentile * 4))
-            G_inv = G_inv @ rotate2d_inv(-np.pi / 2 * i)
-
-        # Apply integer translation with probability (xint * strength).
-        if self.xint > 0:
-            t = (torch.rand([batch_size, 2], device=device)
-                 * 2 - 1) * self.xint_max
-            t = torch.where(torch.rand(
-                [batch_size, 1], device=device) < self.xint * self.p, t, torch.zeros_like(t))
-            if debug_percentile is not None:
-                t = torch.full_like(
-                    t, (debug_percentile * 2 - 1) * self.xint_max)
-            G_inv = G_inv @ translate2d_inv(torch.round(
-                t[:, 0] * width), torch.round(t[:, 1] * height))
-
-        # --------------------------------------------------------
-        # Select parameters for general geometric transformations.
-        # --------------------------------------------------------
-
-        # Apply isotropic scaling with probability (scale * strength).
-        if self.scale > 0:
-            s = torch.exp2(torch.randn(
-                [batch_size], device=device) * self.scale_std)
-            s = torch.where(torch.rand(
-                [batch_size], device=device) < self.scale * self.p, s, torch.ones_like(s))
-            if debug_percentile is not None:
-                s = torch.full_like(s, torch.exp2(torch.erfinv(
-                    debug_percentile * 2 - 1) * self.scale_std))
-            G_inv = G_inv @ scale2d_inv(s, s)
-
-        # Apply pre-rotation with probability p_rot.
-        # P(pre OR post) = p
-        p_rot = 1 - torch.sqrt((1 - self.rotate * self.p).clamp(0, 1))
-        if self.rotate > 0:
-            theta = (torch.rand([batch_size], device=device)
-                     * 2 - 1) * np.pi * self.rotate_max
-            theta = torch.where(torch.rand(
-                [batch_size], device=device) < p_rot, theta, torch.zeros_like(theta))
-            if debug_percentile is not None:
-                theta = torch.full_like(
-                    theta, (debug_percentile * 2 - 1) * np.pi * self.rotate_max)
-            G_inv = G_inv @ rotate2d_inv(-theta)  # Before anisotropic scaling.
-
-        # Apply anisotropic scaling with probability (aniso * strength).
-        if self.aniso > 0:
-            s = torch.exp2(torch.randn(
-                [batch_size], device=device) * self.aniso_std)
-            s = torch.where(torch.rand(
-                [batch_size], device=device) < self.aniso * self.p, s, torch.ones_like(s))
-            if debug_percentile is not None:
-                s = torch.full_like(s, torch.exp2(torch.erfinv(
-                    debug_percentile * 2 - 1) * self.aniso_std))
-            G_inv = G_inv @ scale2d_inv(s, 1 / s)
-
-        # Apply post-rotation with probability p_rot.
-        if self.rotate > 0:
-            theta = (torch.rand([batch_size], device=device)
-                     * 2 - 1) * np.pi * self.rotate_max
-            theta = torch.where(torch.rand(
-                [batch_size], device=device) < p_rot, theta, torch.zeros_like(theta))
-            if debug_percentile is not None:
-                theta = torch.zeros_like(theta)
-            G_inv = G_inv @ rotate2d_inv(-theta)  # After anisotropic scaling.
-
-        # Apply fractional translation with probability (xfrac * strength).
-        if self.xfrac > 0:
-            t = torch.randn([batch_size, 2], device=device) * self.xfrac_std
-            t = torch.where(torch.rand(
-                [batch_size, 1], device=device) < self.xfrac * self.p, t, torch.zeros_like(t))
-            if debug_percentile is not None:
-                t = torch.full_like(t, torch.erfinv(
-                    debug_percentile * 2 - 1) * self.xfrac_std)
-            G_inv = G_inv @ translate2d_inv(t[:, 0] * width, t[:, 1] * height)
-
-        # ----------------------------------
-        # Execute geometric transformations.
-        # ----------------------------------
-
-        # Execute if the transform is not identity.
-        if G_inv is not I_3:
-
-            # Calculate padding.
-            cx = (width - 1) / 2
-            cy = (height - 1) / 2
-            cp = matrix([-cx, -cy, 1], [cx, -cy, 1], [cx, cy, 1],
-                        [-cx, cy, 1], device=device)  # [idx, xyz]
-            cp = G_inv @ cp.t()  # [batch, xyz, idx]
-            Hz_pad = self.Hz_geom.shape[0] // 4
-            margin = cp[:, :2, :].permute(
-                1, 0, 2).flatten(1)  # [xy, batch * idx]
-            # [x0, y0, x1, y1]
-            margin = torch.cat([-margin, margin]).max(dim=1).values
-            margin = margin + \
-                misc.constant([Hz_pad * 2 - cx, Hz_pad * 2 - cy]
-                              * 2, device=device)
-            margin = margin.max(misc.constant([0, 0] * 2, device=device))
-            margin = margin.min(misc.constant(
-                [width-1, height-1] * 2, device=device))
-            mx0, my0, mx1, my1 = margin.ceil().to(torch.int32)
-
-            # Pad image and adjust origin.
-            images = torch.nn.functional.pad(
-                input=images, pad=[mx0, mx1, my0, my1], mode='reflect')
-            G_inv = translate2d((mx0 - mx1) / 2, (my0 - my1) / 2) @ G_inv
-
-            # Upsample.
-            images = upfirdn2d.upsample2d(x=images, f=self.Hz_geom, up=2)
-            G_inv = scale2d(
-                2, 2, device=device) @ G_inv @ scale2d_inv(2, 2, device=device)
-            G_inv = translate2d(-0.5, -0.5,
-                                device=device) @ G_inv @ translate2d_inv(-0.5, -0.5, device=device)
-
-            # Execute transformation.
-            shape = [batch_size, num_channels,
-                     (height + Hz_pad * 2) * 2, (width + Hz_pad * 2) * 2]
-            G_inv = scale2d(2 / images.shape[3], 2 / images.shape[2], device=device) @ G_inv @ scale2d_inv(
-                2 / shape[3], 2 / shape[2], device=device)
-            grid = torch.nn.functional.affine_grid(
-                theta=G_inv[:, :2, :], size=shape, align_corners=False)
-            images = grid_sample_gradfix.grid_sample(images, grid)
-
-            # Downsample and crop.
-            images = upfirdn2d.downsample2d(
-                x=images, f=self.Hz_geom, down=2, padding=-Hz_pad*2, flip_filter=True)
-
-        # --------------------------------------------
-        # Select parameters for color transformations.
-        # --------------------------------------------
-
-        # Initialize homogeneous 3D transformation matrix: C @ color_in ==> color_out
-        I_4 = torch.eye(4, device=device)
-        C = I_4
-
-        # Apply brightness with probability (brightness * strength).
-        if self.brightness > 0:
-            b = torch.randn([batch_size], device=device) * self.brightness_std
-            b = torch.where(torch.rand(
-                [batch_size], device=device) < self.brightness * self.p, b, torch.zeros_like(b))
-            if debug_percentile is not None:
-                b = torch.full_like(b, torch.erfinv(
-                    debug_percentile * 2 - 1) * self.brightness_std)
-            C = translate3d(b, b, b) @ C
-
-        # Apply contrast with probability (contrast * strength).
-        if self.contrast > 0:
-            c = torch.exp2(torch.randn(
-                [batch_size], device=device) * self.contrast_std)
-            c = torch.where(torch.rand(
-                [batch_size], device=device) < self.contrast * self.p, c, torch.ones_like(c))
-            if debug_percentile is not None:
-                c = torch.full_like(c, torch.exp2(torch.erfinv(
-                    debug_percentile * 2 - 1) * self.contrast_std))
-            C = scale3d(c, c, c) @ C
-
-        # Apply luma flip with probability (lumaflip * strength).
-        # Luma axis.
-        v = misc.constant(np.asarray([1, 1, 1, 0]) / np.sqrt(3), device=device)
-        if self.lumaflip > 0:
-            i = torch.floor(torch.rand([batch_size, 1, 1], device=device) * 2)
-            i = torch.where(torch.rand(
-                [batch_size, 1, 1], device=device) < self.lumaflip * self.p, i, torch.zeros_like(i))
-            if debug_percentile is not None:
-                i = torch.full_like(i, torch.floor(debug_percentile * 2))
-            C = (I_4 - 2 * v.ger(v) * i) @ C  # Householder reflection.
-
-        # Apply hue rotation with probability (hue * strength).
-        if self.hue > 0 and num_channels > 1:
-            theta = (torch.rand([batch_size], device=device)
-                     * 2 - 1) * np.pi * self.hue_max
-            theta = torch.where(torch.rand(
-                [batch_size], device=device) < self.hue * self.p, theta, torch.zeros_like(theta))
-            if debug_percentile is not None:
-                theta = torch.full_like(
-                    theta, (debug_percentile * 2 - 1) * np.pi * self.hue_max)
-            C = rotate3d(v, theta) @ C  # Rotate around v.
-
-        # Apply saturation with probability (saturation * strength).
-        if self.saturation > 0 and num_channels > 1:
-            s = torch.exp2(torch.randn(
-                [batch_size, 1, 1], device=device) * self.saturation_std)
-            s = torch.where(torch.rand(
-                [batch_size, 1, 1], device=device) < self.saturation * self.p, s, torch.ones_like(s))
-            if debug_percentile is not None:
-                s = torch.full_like(s, torch.exp2(torch.erfinv(
-                    debug_percentile * 2 - 1) * self.saturation_std))
-            C = (v.ger(v) + (I_4 - v.ger(v)) * s) @ C
-
-        # ------------------------------
-        # Execute color transformations.
-        # ------------------------------
-
-        # Execute if the transform is not identity.
-        if C is not I_4:
-            images = images.reshape([batch_size, num_channels, height * width])
-            if num_channels == 3:
-                images = C[:, :3, :3] @ images + C[:, :3, 3:]
-            elif num_channels == 1:
-                C = C[:, :3, :].mean(dim=1, keepdims=True)
-                images = images * \
-                    C[:, :, :3].sum(dim=2, keepdims=True) + C[:, :, 3:]
-            else:
-                raise ValueError(
-                    'Image must be RGB (3 channels) or L (1 channel)')
-            images = images.reshape([batch_size, num_channels, height, width])
-
-        # ----------------------
-        # Image-space filtering.
-        # ----------------------
-
-        if self.imgfilter > 0:
-            num_bands = self.Hz_fbank.shape[0]
-            assert len(self.imgfilter_bands) == num_bands
-            # Expected power spectrum (1/f).
-            expected_power = misc.constant(
-                np.array([10, 1, 1, 1]) / 13, device=device)
-
-            # Apply amplification for each band with probability (imgfilter * strength * band_strength).
-            # Global gain vector (identity).
-            g = torch.ones([batch_size, num_bands], device=device)
-            for i, band_strength in enumerate(self.imgfilter_bands):
-                t_i = torch.exp2(torch.randn(
-                    [batch_size], device=device) * self.imgfilter_std)
-                t_i = torch.where(torch.rand(
-                    [batch_size], device=device) < self.imgfilter * self.p * band_strength, t_i, torch.ones_like(t_i))
-                if debug_percentile is not None:
-                    t_i = torch.full_like(t_i, torch.exp2(torch.erfinv(
-                        debug_percentile * 2 - 1) * self.imgfilter_std)) if band_strength > 0 else torch.ones_like(t_i)
-                # Temporary gain vector.
-                t = torch.ones([batch_size, num_bands], device=device)
-                # Replace i'th element.
-                t[:, i] = t_i
-                # Normalize power.
-                t = t / (expected_power * t.square()
-                         ).sum(dim=-1, keepdims=True).sqrt()
-                # Accumulate into global gain.
-                g = g * t
-
-            # Construct combined amplification filter.
-            # [batch, tap]
-            Hz_prime = g @ self.Hz_fbank
-            Hz_prime = Hz_prime.unsqueeze(1).repeat(
-                [1, num_channels, 1])   # [batch, channels, tap]
-            # [batch * channels, 1, tap]
-            Hz_prime = Hz_prime.reshape([batch_size * num_channels, 1, -1])
-
-            # Apply filter.
-            p = self.Hz_fbank.shape[1] // 2
-            images = images.reshape(
-                [1, batch_size * num_channels, height, width])
-            images = torch.nn.functional.pad(
-                input=images, pad=[p, p, p, p], mode='reflect')
-            images = conv2d_gradfix.conv2d(
-                input=images, weight=Hz_prime.unsqueeze(2), groups=batch_size*num_channels)
-            images = conv2d_gradfix.conv2d(
-                input=images, weight=Hz_prime.unsqueeze(3), groups=batch_size*num_channels)
-            images = images.reshape([batch_size, num_channels, height, width])
-
-        # ------------------------
-        # Image-space corruptions.
-        # ------------------------
-
-        # Apply additive RGB noise with probability (noise * strength).
-        if self.noise > 0:
-            sigma = torch.randn([batch_size, 1, 1, 1],
-                                device=device).abs() * self.noise_std
-            sigma = torch.where(torch.rand(
-                [batch_size, 1, 1, 1], device=device) < self.noise * self.p, sigma, torch.zeros_like(sigma))
-            if debug_percentile is not None:
-                sigma = torch.full_like(sigma, torch.erfinv(
-                    debug_percentile) * self.noise_std)
-            images = images + \
-                torch.randn([batch_size, num_channels, height,
-                            width], device=device) * sigma
-
-        # Apply cutout with probability (cutout * strength).
-        if self.cutout > 0:
-            size = torch.full([batch_size, 2, 1, 1, 1],
-                              self.cutout_size, device=device)
-            size = torch.where(torch.rand(
-                [batch_size, 1, 1, 1, 1], device=device) < self.cutout * self.p, size, torch.zeros_like(size))
-            center = torch.rand([batch_size, 2, 1, 1, 1], device=device)
-            if debug_percentile is not None:
-                size = torch.full_like(size, self.cutout_size)
-                center = torch.full_like(center, debug_percentile)
-            coord_x = torch.arange(width, device=device).reshape([1, 1, 1, -1])
-            coord_y = torch.arange(
-                height, device=device).reshape([1, 1, -1, 1])
-            mask_x = (((coord_x + 0.5) / width -
-                      center[:, 0]).abs() >= size[:, 0] / 2)
-            mask_y = (((coord_y + 0.5) / height -
-                      center[:, 1]).abs() >= size[:, 1] / 2)
-            mask = torch.logical_or(mask_x, mask_y).to(torch.float32)
-            images = images * mask
-
-        return images
-
-# ----------------------------------------------------------------------------