Update parquet files (step 9 of 476)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Farming Simulator 17 KUHN-RELOADED Free Download.md

@@ -1,47 +0,0 @@
-
-<h1>Farming Simulator 17 KUHN-RELOADED Free Download: A Review of the New Official Extension</h1>
-
-<p>If you are a fan of Farming Simulator 17, you might be interested in the new official extension that adds 18 new implements from KUHN, a leading manufacturer of agricultural machinery. The KUHN-RELOADED DLC is available for download on PC and Mac platforms, and it requires the base game Farming Simulator 17 (Update 1.4 or higher) to play.</p>
-
-<p>In this article, we will review the features and benefits of the KUHN-RELOADED DLC, and show you how to download it for free.</p>
-<h2>Farming Simulator 17 KUHN-RELOADED Free Download</h2><br /><p><b><b>Download</b> >>> <a href="https://byltly.com/2uKwp7">https://byltly.com/2uKwp7</a></b></p><br /><br />
-
-<h2>What's Included in the KUHN-RELOADED DLC?</h2>
-
-<p>The KUHN-RELOADED DLC contains a variety of equipment that will enhance your farming experience and productivity. You will find cultivators, sowing machines, sprayers, fertilizers spreaders, mowers, tedders, windrowers, balers and bale wrappers from KUHN. Here is a list of the equipment included in the DLC:</p>
-
-<ul>
-<li>KUHN AXIS 40.2 M-EMC -W – Fertilizer spreader</li>
-<li>KUHN BTF 4000 – Sowing Machine</li>
-<li>KUHN DC 401 - Cultivator</li>
-<li>KUHN DELTIS 1302 MEA3 – Sprayer</li>
-<li>KUHN DISCOLANDER XM 52 – Cultivator</li>
-<li>KUHN ESPRO 3000 – Sowing Machine</li>
-<li>KUHN FBP 3135 – Baler</li>
-<li>KUHN GF 8702 – Tedder</li>
-<li>KUHN GMD 4411 – Mower</li>
-<li>KUHN HR 4004 – Cultivator</li>
-<li>KUHN LSB 1290 D – Baler</li>
-<li>KUHN MERGE MAXX 902 – Windrower</li>
-<li>KUHN METRIS 4102 – Sprayer</li>
-<li>KUHN PERFORMER 4000 – Cultivator</li>
-<li>KUHN PF 1500 – Sprayer Front Tank</li>
-<li>KUHN PLANTER 3 R 12 – Sowing Machine</li>
-<li>KUHN SW 4014 AutoLoad – Bale wrapper</li>
-<li>KUHN TF 1500 – Sowing Machine Front Tank</li>
-</ul>
-
-<p>Each equipment has its own specifications and features that will help you perform various tasks on your farm. You can check out the details of each equipment on the official website[^1^] or on Steam[^2^]. You can also watch the official trailer for the DLC below:</p>
-
-<iframe width="560" height="315" src="https://www.youtube.com/embed/6R0JF6cgqOw" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
-
-<h2>How to Download Farming Simulator 17 KUHN-RELOADED Free?</h2>
-
-<p>If you want to download Farming Simulator 17 KUHN-RELOADED free, you will need a torrent client such as BitTorrent or uTorrent. You can download the torrent file from various sources online, such as LaptrinhX[^3^]. Once you have downloaded the torrent file, you can open it with your torrent client and start downloading the game files.</p>
-
-<p>After the download is complete, you will need to extract the files using a program such as WinRAR or 7-Zip. You will find a folder named Farming.Simulator.17.KUHN-RELOADED that contains an ISO file and a folder named Crack. You will need to mount the ISO file using a program such as Daemon Tools or PowerISO. Then, you will need to run the setup.exe file and follow the instructions to install the game.</p>
-
-<p>Once the installation is done, you will need to copy the contents of the Crack folder and paste them into the game directory where you installed Farming Simulator 17. This will overwrite some files and crack the game. Now, you can launch the game</p>
-<p></p> 7b8c122e87<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Google Earth Pro 7.3.0 Portable Free ((NEW)) Download.md

@@ -1,21 +0,0 @@
-<br />
-<h1>Google Earth Pro 7.3.0 Portable Free Download</h1>
-<p>Google Earth Pro is a powerful application that lets you explore the world from the comfort of your computer. You can view satellite imagery, maps, terrain, 3D buildings, and even galaxies in outer space. You can also save your toured places, share them with others, and import and export GIS data.</p>
-<h2>Google Earth Pro 7.3.0 Portable Free Download</h2><br /><p><b><b>Download</b> &#9913;&#9913;&#9913; <a href="https://byltly.com/2uKxoj">https://byltly.com/2uKxoj</a></b></p><br /><br />
-<p>Google Earth Pro is now free and available for Windows, macOS, Android and Linux[^2^]. However, if you want to use it without installing anything on your system, you can download Google Earth Pro Portable from PortableApps.com[^1^]. This version is based on Google Earth Pro 7.3.0 and allows you to enable caching and associate *.kml and *.kmz files with the app.</p>
-<p>To download Google Earth Pro Portable, follow these steps:</p>
-<ol>
-<li>Go to <a href="https://portableapps.com/node/57406">https://portableapps.com/node/57406</a></li>
-<li>Click on the link that says "Download Google Earth Pro Portable 7.3.0.3832 Dev Test 1 [1.06+54.9MB download / 179.0MB installed]"</li>
-<li>Save the file to your desired location and run it</li>
-<li>Follow the instructions to extract and launch Google Earth Pro Portable</li>
-<li>Enjoy exploring the world!</li>
-</ol>
-<p>Note: This is a development test version and may not work properly or be stable. Use it at your own risk.</p>
-<p></p><p>Google Earth Pro Portable has some features that are not available in the regular Google Earth. For example, you can measure distances and areas using lines and polygons, print high-resolution images for presentations and reports, record HD movies of your virtual flights, and import large vector image files.</p>
-<p>Google Earth Pro Portable also lets you customize your experience by changing the settings in the GoogleEarthProPortable.ini file. You can find this file in the Other\Source folder of the app. You can edit this file with any text editor and change the values of different parameters. For example, you can enable caching by setting EnableCache=true. This will allow Google Earth Pro Portable to store some data locally and reduce the loading time and bandwidth usage.</p>
-<p>Google Earth Pro Portable is a great way to explore the world without installing anything on your system. However, you should be aware of some limitations and drawbacks of using this version. For instance, you may encounter some errors or crashes due to compatibility issues or bugs. You may also miss some updates or features that are available in the official Google Earth Pro. Moreover, you should respect the terms of service and privacy policy of Google when using this app.</p><p>To update Google Earth Pro Portable, you can check the PortableApps.com website for any new releases. You can also use the PortableApps.com Platform to automatically update your apps. Alternatively, you can download the latest version of Google Earth Pro from the official website and replace the files in the App\GoogleEarthPro folder of your portable app.</p>
-<p>To uninstall Google Earth Pro Portable, you can simply delete the folder where you extracted the app. You can also use the PortableApps.com Platform to uninstall your apps. However, you should note that this will not remove any data or settings that Google Earth Pro Portable may have stored on your system or online.</p>
-<p>Google Earth Pro Portable requires an internet connection to download and display the imagery and data from Google servers. You cannot use it offline unless you have enabled caching and have previously viewed the areas that you want to see. Even then, you may not be able to access all the features and functions of the app.</p> 81aa517590<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Adobe Media Encoder Cs6 Activation Crack NEW.md

@@ -1,90 +0,0 @@
-<br />
-<h1>How to Download and Install Adobe Media Encoder CS6 Activation Crack</h1>
-<p>Adobe Media Encoder CS6 is a software that allows you to encode, transcode, and compress video and audio files for various formats and platforms. It is a part of the Adobe Creative Suite 6, which includes other popular applications such as Photoshop, Premiere Pro, After Effects, etc. However, to use Adobe Media Encoder CS6, you need to activate it with a valid serial number or a crack file. In this article, we will show you how to download and install Adobe Media Encoder CS6 activation crack for free.</p>
-<h2>What is Adobe Media Encoder CS6?</h2>
-<p>Adobe Media Encoder CS6 is a software that allows you to encode, transcode, and compress video and audio files for various formats and platforms. It can help you convert your video clips to different formats such as MP4, MOV, AVI, FLV, etc. It can also help you adjust the quality and size of your video files according to your needs. You can use Adobe Media Encoder CS6 to export your video files from other Adobe applications such as After Effects or Premiere Pro. You can also use it to upload your video files to social media platforms such as YouTube or Facebook.</p>
-<h2>adobe media encoder cs6 activation crack</h2><br /><p><b><b>DOWNLOAD</b> &#9675; <a href="https://imgfil.com/2uxXxD">https://imgfil.com/2uxXxD</a></b></p><br /><br />
-<h3>What is Adobe Media Encoder CS6 Activation Crack?</h3>
-<p>Adobe Media Encoder CS6 activation crack is a file that can bypass the activation process of the software and make it work without a serial number. It is usually a modified version of the original file "amtlib.dll" that is located in the installation folder of Adobe Media Encoder CS6. By replacing the original file with the crack file, you can trick the software into thinking that it is activated and use it without any limitations.</p>
-<h4>Where to Download Adobe Media Encoder CS6 Activation Crack?</h4>
-<p>There are many websites that offer Adobe Media Encoder CS6 activation crack for download. However, not all of them are reliable or safe. Some of them may have fake or corrupted files, or may contain malicious ads or pop-ups. Therefore, you should be careful when choosing a website and check the reviews and ratings of the files before downloading them. Here are some of the websites that offer Adobe Media Encoder CS6 activation crack:</p>
-<ul>
-<li><b>Github</b>: This is a platform that hosts various projects and files from developers and programmers. You can find Adobe Media Encoder CS6 activation crack on this website by searching for "patcher-adobe-CS6-all-software-patch". This project contains crack files for various Adobe CS6 applications, including Media Encoder.</li>
-<li><b>Weebly</b>: This is a website builder that allows users to create and host their own websites. You can find Adobe Media Encoder CS6 activation crack on this website by searching for "adobe-cs6-master-collection-3264-bit-full-crack". This website contains instructions and links to download and install Adobe CS6 Master Collection full crack, which includes Media Encoder.</li>
-<li><b>Internet Archive</b>: This is a digital library that preserves various types of media and content from the internet. You can find Adobe Media Encoder CS6 activation crack on this website by searching for "CS6Whacked". This archive contains cracking instructions and files for various Adobe CS6 applications, including Media Encoder.</li>
-</ul>
-<h5>How to Install Adobe Media Encoder CS6 Activation Crack?</h5>
-<p>After you have downloaded Adobe Media Encoder CS6 activation crack from one of the websites above, you need to follow these steps to install it:</p>
-<ol>
-<li><b>Run Block Adobe Activation.app</b>: This is an application that prevents the Adobe activation program from starting. You need to run this application before installing Adobe Media Encoder CS6.</li>
-<li><b>Run the Adobe CS6 installer</b>: This is an application that installs Adobe Media Encoder CS6 on your computer. You need to run this application and select "Trial" as the installation option.</li>
-<li><b>Register a free adobe account</b>: This is an account that allows you to access various Adobe services and products. You need to register a free adobe account and sign in with it during the installation process.</li>
-<li><b>Copy amtlib.dll file and replace with existing one</b>: This is the crack file that activates Adobe Media Encoder CS6. You need to copy this file from the downloaded folder and replace it with the existing one in the installation folder of Adobe Media Encoder CS6. The default location of the installation folder is C:\Program Files\Adobe\Adobe Media Encoder CS6.</li>
-<li><b>Enjoy using Adobe Media Encoder CS6</b>: After you have replaced the amtlib.dll file with the crack file, you can enjoy using Adobe Media Encoder CS6 without any restrictions.</li>
-</ol>
-<h6>Benefits of Using Adobe Media Encoder CS6 Activation Crack</h6>
-<p>Using Adobe Media Encoder CS6 activation crack has many benefits for you, such as:</p>
-<ul>
-<li><b>It saves you money</b>: Using Adobe Media Encoder CS6 activation crack allows you to use the software without paying for a serial number or a subscription fee.</li>
-<li><b>It gives you access to all features</b>: Using Adobe Media Encoder CS6 activation crack allows you to use all the features and functions of the software without any limitations or watermarks.</li>
-<li><b>It improves your productivity</b>: Using Adobe Media Encoder CS6 activation crack allows you to encode, transcode, and compress video and audio files for various formats and platforms quickly and easily.</li>
-<li><b>It enhances your creativity</b>: Using Adobe Media Encoder CS6 activation crack allows you to work with other Adobe Creative Suite 6 applications seamlessly and create amazing media content.</li>
-</ul>
-<h7>Conclusion</h7>
-<p>Adobe Media Encoder CS6 is a powerful software that allows you to encode, transcode, and compress video and audio files for various formats and platforms. However, to use it, you need to activate it with a valid serial number or a crack file. In this article, we showed you how to download and install Adobe Media Encoder CS6 activation crack for free. By using this crack file, you can enjoy using Adobe Media Encoder CS6 without any restrictions.</p>
-<h1>How to Download and Install Adobe Media Encoder CS6 Activation Crack</h1>
-<p>Adobe Media Encoder CS6 is a software that allows you to encode, transcode, and compress video and audio files for various formats and platforms. It is a part of the Adobe Creative Suite 6, which includes other popular applications such as Photoshop, Premiere Pro, After Effects, etc. However, to use Adobe Media Encoder CS6, you need to activate it with a valid serial number or a crack file. In this article, we will show you how to download and install Adobe Media Encoder CS6 activation crack for free.</p>
-<h2>What is Adobe Media Encoder CS6?</h2>
-<p>Adobe Media Encoder CS6 is a software that allows you to encode, transcode, and compress video and audio files for various formats and platforms. It can help you convert your video clips to different formats such as MP4, MOV, AVI, FLV, etc. It can also help you adjust the quality and size of your video files according to your needs. You can use Adobe Media Encoder CS6 to export your video files from other Adobe applications such as After Effects or Premiere Pro. You can also use it to upload your video files to social media platforms such as YouTube or Facebook.</p>
-<p></p>
-<h3>What is Adobe Media Encoder CS6 Activation Crack?</h3>
-<p>Adobe Media Encoder CS6 activation crack is a file that can bypass the activation process of the software and make it work without a serial number. It is usually a modified version of the original file "amtlib.dll" that is located in the installation folder of Adobe Media Encoder CS6. By replacing the original file with the crack file, you can trick the software into thinking that it is activated and use it without any limitations.</p>
-<h4>Where to Download Adobe Media Encoder CS6 Activation Crack?</h4>
-<p>There are many websites that offer Adobe Media Encoder CS6 activation crack for download. However, not all of them are reliable or safe. Some of them may have fake or corrupted files, or may contain malicious ads or pop-ups. Therefore, you should be careful when choosing a website and check the reviews and ratings of the files before downloading them. Here are some of the websites that offer Adobe Media Encoder CS6 activation crack:</p>
-<ul>
-<li><b>Github</b>: This is a platform that hosts various projects and files from developers and programmers. You can find Adobe Media Encoder CS6 activation crack on this website by searching for "patcher-adobe-CS6-all-software-patch". This project contains crack files for various Adobe CS6 applications, including Media Encoder.</li>
-<li><b>Weebly</b>: This is a website builder that allows users to create and host their own websites. You can find Adobe Media Encoder CS6 activation crack on this website by searching for "adobe-cs6-master-collection-3264-bit-full-crack". This website contains instructions and links to download and install Adobe CS6 Master Collection full crack, which includes Media Encoder.</li>
-<li><b>Internet Archive</b>: This is a digital library that preserves various types of media and content from the internet. You can find Adobe Media Encoder CS6 activation crack on this website by searching for "CS6Whacked". This archive contains cracking instructions and files for various Adobe CS6 applications, including Media Encoder.</li>
-</ul>
-<h5>How to Install Adobe Media Encoder CS6 Activation Crack?</h5>
-<p>After you have downloaded Adobe Media Encoder CS6 activation crack from one of the websites above, you need to follow these steps to install it:</p>
-<ol>
-<li><b>Run Block Adobe Activation.app</b>: This is an application that prevents the Adobe activation program from starting. You need to run this application before installing Adobe Media Encoder CS6.</li>
-<li><b>Run the Adobe CS6 installer</b>: This is an application that installs Adobe Media Encoder CS6 on your computer. You need to run this application and select "Trial" as the installation option.</li>
-<li><b>Register a free adobe account</b>: This is an account that allows you to access various Adobe services and products. You need to register a free adobe account and sign in with it during the installation process.</li>
-<li><b>Copy amtlib.dll file and replace with existing one</b>: This is the crack file that activates Adobe Media Encoder CS6. You need to copy this file from the downloaded folder and replace it with the existing one in the installation folder of Adobe Media Encoder CS6. The default location of the installation folder is C:\Program Files\Adobe\Adobe Media Encoder CS6.</li>
-<li><b>Enjoy using Adobe Media Encoder CS6</b>: After you have replaced the amtlib.dll file with the crack file, you can enjoy using Adobe Media Encoder CS6 without any restrictions.</li>
-</ol>
-<h6>Benefits of Using Adobe Media Encoder CS6 Activation Crack</h6>
-<p>Using Adobe Media Encoder CS6 activation crack has many benefits for you, such as:</p>
-<ul>
-<li><b>It saves you money</b>: Using Adobe Media Encoder CS6 activation crack allows you to use the software without paying for a serial number or a subscription fee.</li>
-<li><b>It gives you access to all features</b>: Using Adobe Media Encoder CS6 activation crack allows you to use all the features and functions of the software without any limitations or watermarks.</li>
-<li><b>It improves your productivity</b>: Using Adobe Media Encoder CS6 activation crack allows you to encode, transcode, and compress video and audio files for various formats and platforms quickly and easily.</li>
-<li><b>It enhances your creativity</b>: Using Adobe Media Encoder CS6 activation crack allows you to work with other Adobe Creative Suite 6 applications seamlessly and create amazing media content.</li>
-</ul>
-
-<h7>Tips for Using Adobe Media Encoder CS6 Activation Crack</h7>
-<p>Besides installing Adobe Media Encoder CS6 activation crack, there are some tips that can help you use the software more effectively:</p>
-
-<ul>
-<li><b>Create presets for common tasks</b>: If you often encode or transcode video files for specific formats or platforms, you can create presets that save your settings and preferences. This way, you can apply them quickly without having to adjust them every time.</li>
-
-<li><b>Use watch folders for batch processing</b>: If you have multiple video files that need to be encoded or transcoded with the same settings, you can use watch folders to automate the process. Watch folders are folders that monitor any new files added to them and apply presets automatically.</li>
-
-<li><b>Use parallel encoding for faster performance</b>: If you have a multicore processor, you can use parallel encoding to speed up the encoding or transcoding process. Parallel encoding allows you to encode multiple files simultaneously using different cores of your processor.</li>
-
-<li><b>Use metadata for better organization</b>: Metadata are information that describe your video files such as title, description, keywords, etc. You can use metadata to organize your video files better and make them easier to find or share.</li>
-
-<li><b>Use previews for quality control</b>: Before exporting your video files, you can use previews to check their quality and appearance. Previews allow you to see how your video files will look like after encoding or transcoding without actually exporting them.</li>
-
-</ul>
-
-<h8>Conclusion</h8>
-
-<p>Adobe Media Encoder CS6 is a powerful software that allows you to encode, transcode, and compress video and audio files for various formats and platforms. However, to use it, you need to activate it with a valid serial number or a crack file. In this article, we showed you how to download and install Adobe Media Encoder CS6 activation crack for free. We also gave you some tips on how to use the software more effectively. By using this crack file and these tips, you can enjoy using Adobe Media Encoder CS6 without any restrictions.</p>
-<h8>Conclusion</h8>
-
-<p>Adobe Media Encoder CS6 is a powerful software that allows you to encode, transcode, and compress video and audio files for various formats and platforms. However, to use it, you need to activate it with a valid serial number or a crack file. In this article, we showed you how to download and install Adobe Media Encoder CS6 activation crack for free. We also gave you some tips on how to use the software more effectively. By using this crack file and these tips, you can enjoy using Adobe Media Encoder CS6 without any restrictions.</p> 3cee63e6c2<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Free Download Maps Blaupunkt Travelpilot Ex.rar [PATCHED].md

@@ -1,6 +0,0 @@
-<h2>Free Download Maps Blaupunkt Travelpilot Ex.rar</h2><br /><p><b><b>Download File</b> &#9658;&#9658;&#9658;&#9658;&#9658; <a href="https://imgfil.com/2uxY5W">https://imgfil.com/2uxY5W</a></b></p><br /><br />
-
-3B0 035 191G 7 612 001 025 24C32 new.rar. File type: .rar. Downloaded: 0 times. Size: 1.4s. Blaupunkt Travelpilot E (NOT EX!) (analogue from Sony) - 2 pcs. (for 2 pieces - 2,800 rubles). 3B0 035 191G 7 612 001 025 24C32.rar.File type: .rar. Downloaded: 0 times. Size: 1.4s. Blaupunkt Travelpilot E (NOT EX!) (analogue from Sony) - 2 pcs. (for 2 pieces - 2,800 rubles). 3B0 035 191G 7 612 001 025 24C32.rar.File type: .rar. Downloaded: 0 times. Size: 1.4s. Blaupunkt Travelpilot E (NOT EX!) (analogue from Sony) - 2 pcs. ( 8a78ff9644<br />
-<br />
-<br />
-<p></p>

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download 730 precompilato 2023 i vantaggi i requisiti e i passaggi da seguire.md

@@ -1,160 +0,0 @@
-
-<h1>How to Download 730 Precompilato 2023: A Complete Guide</h1>
-<p>If you are a resident taxpayer in Italy, you may be eligible to use the 730 Precompilato service to file your income tax return online. This service allows you to access a pre-filled tax form with your personal and income data, verify its accuracy, and submit it electronically. In this article, we will explain what 730 Precompilato is, how to access it online, how to submit it online, and how to get help with it online.</p>
- <h2>What is 730 Precompilato?</h2>
-<p>730 Precompilato is a service provided by the Agenzia delle Entrate (the Italian Revenue Agency) that allows you to file your income tax return online without having to fill in any data manually. The service uses the information that the Agenzia delle Entrate collects from various sources, such as your employer, your bank, your health provider, etc., to pre-fill your tax form with your personal and income data. You can then check and edit your data, add any deductions or tax credits that you are entitled to, and send your declaration electronically.</p>
-<h2>download 730 precompilato 2023</h2><br /><p><b><b>Download Zip</b> &gt;&gt;&gt;&gt;&gt; <a href="https://urlin.us/2uSRYH">https://urlin.us/2uSRYH</a></b></p><br /><br />
- <h3>What are the benefits of using 730 Precompilato?</h3>
-<p>Using 730 Precompilato has several advantages, such as:</p>
-<ul>
-<li>It saves you time and hassle, as you don't have to collect and enter your data manually.</li>
-<li>It reduces the risk of errors and omissions, as the data is verified by the Agenzia delle Entrate.</li>
-<li>It allows you to receive your refund faster, as the processing time is shorter.</li>
-<li>It is free of charge, as you don't have to pay any fees or commissions.</li>
-</ul>
- <h3>Who can use 730 Precompilato?</h3>
-<p>You can use 730 Precompilato if you meet the following conditions:</p>
-<ul>
-<li>You are a resident taxpayer in Italy.</li>
-<li>You have received income from employment or similar sources (such as pensions, scholarships, etc.) in the previous year.</li>
-<li>You have not received income from self-employment, business, or professional activities in the previous year.</li>
-<li>You have not opted for other tax regimes (such as flat tax, substitute tax, etc.) in the previous year.</li>
-</ul>
- <h2>How to access 730 Precompilato online</h2>
-<p>To access 730 Precompilato online, you need to visit the Agenzia delle Entrate website and log in with one of the following methods:</p>
-<p>download 730 precompilato 2023 agenzia entrate<br />
-download 730 precompilato 2023 online<br />
-download 730 precompilato 2023 editabile<br />
-download 730 precompilato 2023 pdf<br />
-download 730 precompilato 2023 spid<br />
-download 730 precompilato 2023 inps<br />
-download 730 precompilato 2023 istruzioni<br />
-download 730 precompilato 2023 scadenza<br />
-download 730 precompilato 2023 modello<br />
-download 730 precompilato 2023 congiunto<br />
-download 730 precompilato 2023 cns<br />
-download 730 precompilato 2023 redditi<br />
-download 730 precompilato 2023 detrazioni<br />
-download 730 precompilato 2023 rimborsi<br />
-download 730 precompilato 2023 gratis<br />
-download 730 precompilato 2023 senza sostituto d'imposta<br />
-download 730 precompilato 2023 con pin inps<br />
-download 730 precompilato 2023 con cie<br />
-download 730 precompilato 2023 con entratel<br />
-download 730 precompilato 2023 con fisconline<br />
-download 730 precompilato 2023 con cud<br />
-download 730 precompilato 2023 con unico<br />
-download 730 precompilato 2023 con partita IVA<br />
-download 730 precompilato 2023 con mutuo<br />
-download 730 precompilato 2023 con affitto<br />
-download 730 precompilato 2023 con assegni familiari<br />
-download 730 precompilato 2023 con bonus renzi<br />
-download 730 precompilato 2023 con spese mediche<br />
-download 730 precompilato 2023 con spese universitarie<br />
-download 730 precompilato 2023 con spese funebri<br />
-download 730 precompilato 2023 con spese veterinarie<br />
-download 730 precompilato 2023 con spese scolastiche<br />
-download 730 precompilato 2023 con spese sportive<br />
-download 730 precompilato 2023 con spese culturali<br />
-download 730 precompilato 2023 con spese condominiali<br />
-download 730 precompilato 2023 con spese energetiche<br />
-download 730 precompilato 2023 con spese ristrutturazione<br />
-download 730 precompilato 2023 con spese donazioni<br />
-download</p>
-<ul>
-<li>SPID (Public System of Digital Identity), which is a unique digital identity that allows you to access various online services of the public administration and private entities.</li>
-<li>CIE (Electronic Identity Card), which is a smart card that contains your personal data and biometric features.</li>
-<li>CNS (National Service Card), which is a health card that also functions as an electronic identity card.</li>
-</ul>
- <h3>What are the requirements for accessing 730 Precompilato online?</h3>
-<p>To access 730 Precompilato online, you need to have:</p>
-<ul>
-<li>A valid SPID, C IE (Electronic Identity Card), which is a smart card that contains your personal data and biometric features.</li>
-<li>CNS (National Service Card), which is a health card that also functions as an electronic identity card.</li>
-</ul>
- <h3>How to log in to the Agenzia delle Entrate website with SPID, CIE, or CNS</h3>
-<p>To log in to the Agenzia delle Entrate website with SPID, CIE, or CNS, you need to follow these steps:</p>
-<ol>
-<li>Go to the Agenzia delle Entrate website and click on the "730 Precompilato" button.</li>
-<li>Select the option "Accesso con SPID, CIE o CNS" and choose the method that you prefer.</li>
-<li>Follow the instructions on the screen to enter your credentials and authenticate yourself.</li>
-<li>Once you are logged in, you will see your personal page with your 730 Precompilato form.</li>
-</ol>
- <h3>How to check and edit your personal and income data</h3>
-<p>Once you access your 730 Precompilato form online, you need to check and edit your personal and income data. You can do this by following these steps:</p>
-<ol>
-<li>Click on the "Dati Anagrafici e Reddituali" section to see your personal and income data.</li>
-<li>Verify that your personal data (such as name, surname, date of birth, place of residence, etc.) are correct and complete. If you notice any errors or omissions, you can edit them by clicking on the "Modifica" button.</li>
-<li>Verify that your income data (such as wages, pensions, dividends, interest, etc.) are correct and complete. If you notice any errors or omissions, you can edit them by clicking on the "Modifica" button.</li>
-<li>If you have received any income from abroad, you need to declare it by clicking on the "Dichiarazione dei redditi esteri" section and filling in the required fields.</li>
-<li>If you have any other income that is not pre-filled in your form, you need to declare it by clicking on the "Altri redditi" section and filling in the required fields.</li>
-<li>Once you have checked and edited your personal and income data, you can proceed to the next section by clicking on the "Continua" button.</li>
-</ol>
- <h2>How to submit 730 Precompilato online</h2>
-<p>After you have verified and edited your personal and income data, you need to submit your 730 Precompilato form online. You can do this by following these steps:</p>
- <h3>How to confirm or modify your deductions and tax credits</h3>
-<p>The 730 Precompilato form also includes some deductions and tax credits that you may be entitled to, such as expenses for health, education, mortgage interest, donations, etc. You can confirm or modify these deductions and tax credits by following these steps:</p>
-<ol>
-<li>Click on the "Detrazioni e Credito d'Imposta" section to see your deductions and tax credits.</li>
-<li>Verify that the deductions and tax credits are correct and complete. If you notice any errors or omissions, you can edit them by clicking on the "Modifica" button.</li>
-<li>If you have any other deductions or tax credits that are not pre-filled in your form, you can add them by clicking on the "Aggiungi" button and filling in the required fields.</li>
-<li>Once you have confirmed or modified your deductions and tax credits, you can proceed to the next section by clicking on the "Continua" button.</li>
-</ol>
- <h3>How to choose your payment method and send your declaration</h3>
-<p>The final step of submitting your 730 Precompilato form online is to choose your payment method and send your declaration. You can do this by following these steps:</p>
-<ol>
-<li>Click on the "Metodo di Pagamento e Invio" section to see your payment method and declaration.</li>
-<li>If you have a tax due, you can choose how to pay it. You can either pay it online with a credit card or a bank transfer, or pay it offline with a F24 form at a bank or a post office. You can also choose to pay it in installments if you meet certain conditions.</li>
-<li>If you have a tax refund, you can choose how to receive it. You can either receive it by bank transfer or by postal order. You need to provide your bank account details or your postal address accordingly.</li>
-<li>Once you have chosen your payment method, you can send your declaration by clicking on the "Invia" button. You will receive a confirmation code and a receipt that you can download and print.</li>
-</ol>
- <h3>How to track the status of your submission and receive your refund</h3>
-<p>After you have sent your 730 Precompilato form online, you can track the status of your submission and receive your refund by following these steps:</p>
-<ol>
-<li>Go to the Agenzia delle Entrate website and log in with your SPID, CIE, or CNS.</li>
-<li>Click on the "730 Precompilato" button and then on the "Verifica lo stato della tua dichiarazione" section.</li>
-<li>You will see the status of your submission, which can be one of the following:</li>
-<ul>
-<li>Inviata: Your declaration has been sent and is being processed.</li>
-<li>Accettata: Your declaration has been accepted and is being finalized.</li>
-<li>Liquidata: Your declaration has been finalized and your tax due or refund has been calculated.</li>
-<li>Pagata: Your tax due has been paid or your refund has been issued.</li>
-</ul>
-<li>If you have a refund, you will receive it within a few weeks after your declaration has been finalized. You will receive it by the payment method that you have chosen (bank transfer or postal order).</li>
-</ol>
- <h2>How to get help with 730 Precompilato online</h2>
-<p>If you have any questions or problems with 730 Precompilato online, you can get help by following these methods:</p>
- <h3>How to contact the Agenzia delle Entrate for assistance</h3>
-<p>You can contact the Agenzia delle Entrate for assistance by phone, email, or chat. You can do this by following these steps:</p>
-<ol>
-<li>Go to the Agenzia delle Entrate website and click on the "Contatti" button.</li>
-<li>Select the option "Assistenza per il 730 Precompilato" and choose the method that you prefer (phone, email, or chat).</li>
-<li>Follow the instructions on the screen to enter your details and your request.</li>
-<li>You will be connected to an operator who will assist you with your issue.</li>
-</ol>
- <h3>How to use the online guides and FAQs</h3>
-<p>You can also use the online guides and FAQs that are available on the Agenzia delle Entrate website. You can do this by following these steps:</p>
-<ol>
-<li>Go to the Agenzia delle Entrate website and click on the "Guida e FAQ" button.</li>
-<li>Select the option "Guida al 730 Precompilato" or "FAQ sul 730 Precompilato" depending on what you need.</li>
-<li>You will see a list of topics and questions that cover various aspects of 730 Precompilato online.</li>
-<li>Click on the topic or question that interests you and read the answer or explanation.</li>
-</ol>
- <h2>Conclusion</h2>
-<p>In conclusion, 730 Precompilato online is a convenient and easy way to file your income tax return in Italy. It allows you to access a pre-filled tax form with your personal and income data, verify its accuracy, and submit it electronically. It also allows you to receive your refund faster and avoid errors and omissions. To use 730 Precompilato online, you need to visit the Agenzia delle Entrate website and log in with your SPID, CIE, or CNS. You can then check and edit your data, add any deductions or tax credits that you are entitled to, choose your payment method, and send your declaration. You can also track the status of your submission and receive your refund online. If you need any help with 730 Precompilato online, you can contact the Agenzia delle Entrate for assistance or use the online guides and FAQs.</p>
- <h2>FAQs</h2>
-<p>Here are some frequently asked questions about 730 Precompilato online:</p>
- <h4>When can I access 730 Precompilato online?</h4>
-<p>You can access 730 Precompilato online from April 1st to July 31st of each year. However, if you want to use a tax assistance center (CAF) or a qualified professional (such as an accountant) to submit your declaration, you need to access it by June 30th.</p>
- <h4>What if I don't agree with the data pre-filled in my form?</h4>
-<p>If you don't agree with the data pre-filled in your form, you can edit it by clicking on the "Modifica" button. You can also add any data that is missing or not pre-filled by clicking on the "Aggiungi" button. However, you need to have supporting documents or receipts that prove your data. You are responsible for the accuracy and completeness of your data.</p>
- <h4>What if I don't want to use 730 Precompilato online?</h4>
-<p>If you don't want to use 730 Precompilato online, you have other options to file your income tax return. You can either use the traditional 730 form, which you need to fill in manually and submit through a tax assistance center (CAF) or a qualified professional (such as an accountant), or use the Unico form, which you need to fill in manually and submit online or by mail. However, these options may be more time-consuming, costly, and prone to errors than 730 Precompilato online.</p>
- <h4>What if I have already submitted my 730 Precompilato online and I want to change something?</h4>
-<p>If you have already submitted your 730 Precompilato online and you want to change something, you can do so by submitting a new declaration with the correct data. You can do this by following the same steps as before, but you need to select the option "Invia una nuova dichiarazione" instead of "Invia". You can submit a new declaration until July 31st of each year. However, if you have already received your refund or paid your tax due, you may need to adjust your payment or request a new refund accordingly.</p>
- <h4>How secure is 730 Precompilato online?</h4>
-<p>730 Precompilato online is a secure service that uses encryption and authentication methods to protect your data and privacy. The Agenzia delle Entrate guarantees that your data is treated in accordance with the law and that only you can access and modify it. You can also check the security certificate of the website by clicking on the padlock icon in your browser.</p>
- <h4>Where can I find more information about 730 Precompilato online?</h4>
-<p>You can find more information about 730 Precompilato online on the Agenzia delle Entrate website, where you can also access the service and get help. You can also consult the official guide and FAQ that are available on the website. Alternatively, you can contact the Agenzia delle Entrate by phone, email, or chat for assistance.</p> 197e85843d<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/models/ema.py

@@ -1,103 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import paddle
-from paddle import nn
-
-
-class LitEma(nn.Layer):
-    """
-    Exponential Moving Average (EMA) of model updates
-
-    Parameters:
-        model: The model architecture for apply EMA.
-        decay: The exponential decay. Default 0.9999.
-        use_num_updates: Whether to use number of updates when computing
-            averages.
-    """
-
-    def __init__(self, model, decay=0.9999, use_num_upates=True):
-        super().__init__()
-        if decay < 0.0 or decay > 1.0:
-            raise ValueError("Decay must be between 0 and 1")
-
-        self.m_name2s_name = {}
-        self.register_buffer("decay", paddle.to_tensor(decay, dtype=paddle.float32))
-        self.register_buffer(
-            "num_updates",
-            paddle.to_tensor(0, dtype=paddle.int64) if use_num_upates else paddle.to_tensor(-1, dtype=paddle.int64),
-        )
-
-        for name, p in model.named_parameters():
-            if not p.stop_gradient:
-                # remove as '.'-character is not allowed in buffers
-                s_name = name.replace(".", "")
-                self.m_name2s_name.update({name: s_name})
-                self.register_buffer(s_name, p.clone().detach())
-
-        self.collected_params = []
-
-    def forward(self, model):
-        decay = self.decay
-
-        if self.num_updates >= 0:
-            self.num_updates += 1
-            decay = min(self.decay, (1 + self.num_updates) / (10 + self.num_updates))
-
-        one_minus_decay = 1.0 - decay
-
-        with paddle.no_grad():
-            m_param = dict(model.named_parameters())
-            shadow_params = dict(self.named_buffers())
-
-            for key in m_param:
-                if not m_param[key].stop_gradient:
-                    sname = self.m_name2s_name[key]
-                    shadow_params[sname].scale_(decay)
-                    shadow_params[sname].add_(m_param[key] * one_minus_decay)
-                else:
-                    assert key not in self.m_name2s_name
-
-    def copy_to(self, model):
-        m_param = dict(model.named_parameters())
-        shadow_params = dict(self.named_buffers())
-        for key in m_param:
-            if not m_param[key].stop_gradient:
-                m_param[key].copy_(shadow_params[self.m_name2s_name[key]], True)
-            else:
-                assert key not in self.m_name2s_name
-
-    def store(self, parameters):
-        """
-        Save the current parameters for restoring later.
-        Args:
-          parameters: Iterable of `EagerParamBase`; the parameters to be
-            temporarily stored.
-        """
-        self.collected_params = [param.clone() for param in parameters]
-
-    def restore(self, parameters):
-        """
-        Restore the parameters stored with the `store` method.
-        Useful to validate the model with EMA parameters without affecting the
-        original optimization process. Store the parameters before the
-        `copy_to` method. After validation (or model saving), use this to
-        restore the former parameters.
-        Args:
-          parameters: Iterable of `EagerParamBase`; the parameters to be
-            updated with the stored parameters.
-        """
-        for c_param, param in zip(self.collected_params, parameters):
-            param.copy_(c_param, True)

spaces/4com/4com-license/README.md

@@ -1,13 +0,0 @@
----
-title: 4COM License
-emoji: ⚖
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 3.41.2
-app_file: app.py
-pinned: false
-license: creativeml-openrail-m
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/52Hz/SRMNet_AWGN_denoising/predict.py

@@ -1,82 +0,0 @@
-import cog
-import tempfile
-from pathlib import Path
-import argparse
-import shutil
-import os
-import glob
-import torch
-from skimage import img_as_ubyte
-from PIL import Image
-from model.SRMNet import SRMNet
-from main_test_SRMNet import save_img, setup
-import torchvision.transforms.functional as TF
-import torch.nn.functional as F
-
-
-class Predictor(cog.Predictor):
-    def setup(self):
-        model_dir = 'experiments/pretrained_models/AWGN_denoising_SRMNet.pth'
-
-        parser = argparse.ArgumentParser(description='Demo Image Denoising')
-        parser.add_argument('--input_dir', default='./test/', type=str, help='Input images')
-        parser.add_argument('--result_dir', default='./result/', type=str, help='Directory for results')
-        parser.add_argument('--weights',
-                            default='./checkpoints/SRMNet_real_denoise/models/model_bestPSNR.pth', type=str,
-                            help='Path to weights')
-
-        self.args = parser.parse_args()
-
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-    @cog.input("image", type=Path, help="input image")
-    def predict(self, image):
-        # set input folder
-        input_dir = 'input_cog_temp'
-        os.makedirs(input_dir, exist_ok=True)
-        input_path = os.path.join(input_dir, os.path.basename(image))
-        shutil.copy(str(image), input_path)
-
-        # Load corresponding models architecture and weights
-        model = SRMNet()
-        model.eval()
-        model = model.to(self.device)
-
-        folder, save_dir = setup(self.args)
-        os.makedirs(save_dir, exist_ok=True)
-
-        out_path = Path(tempfile.mkdtemp()) / "out.png"
-        mul = 16
-        for file_ in sorted(glob.glob(os.path.join(folder, '*.PNG'))):
-            img = Image.open(file_).convert('RGB')
-            input_ = TF.to_tensor(img).unsqueeze(0).cuda()
-
-            # Pad the input if not_multiple_of 8
-            h, w = input_.shape[2], input_.shape[3]
-            H, W = ((h + mul) // mul) * mul, ((w + mul) // mul) * mul
-            padh = H - h if h % mul != 0 else 0
-            padw = W - w if w % mul != 0 else 0
-            input_ = F.pad(input_, (0, padw, 0, padh), 'reflect')
-            with torch.no_grad():
-                restored = model(input_)
-
-            restored = torch.clamp(restored, 0, 1)
-            restored = restored[:, :, :h, :w]
-            restored = restored.permute(0, 2, 3, 1).cpu().detach().numpy()
-            restored = img_as_ubyte(restored[0])
-
-        save_img(str(out_path), restored)
-        clean_folder(input_dir)
-        return out_path
-
-
-def clean_folder(folder):
-    for filename in os.listdir(folder):
-        file_path = os.path.join(folder, filename)
-        try:
-            if os.path.isfile(file_path) or os.path.islink(file_path):
-                os.unlink(file_path)
-            elif os.path.isdir(file_path):
-                shutil.rmtree(file_path)
-        except Exception as e:
-            print('Failed to delete %s. Reason: %s' % (file_path, e))

spaces/AEUPH/AethericGPT/app.py

@@ -1,32 +0,0 @@
-import gradio as gr
-import requests
-
-def interact_with_server(prompt):
-    server_url = "http://xzyorb.servemp3.com:80"
-    response = requests.post(server_url, data={"prompt": prompt})
-    response_text = response.text
-    
-    # Split the response text into individual messages
-    conversation_messages = response_text.split("\n")
-    num_messages = len(conversation_messages)
-    
-    return response_text, num_messages
-
-def print_session_data(data):
-    response_text, num_messages = data
-    session = gr.capture_session()
-    ip_address = session["ip"]
-    user_agent = session["user_agent"]
-    
-    print("IP Address:", ip_address)
-    print("User Agent:", user_agent)
-    print("Number of Messages:", num_messages)
-
-iface = gr.Interface(
-    fn=interact_with_server,
-    inputs=gr.inputs.Textbox(),
-    outputs=[gr.outputs.HTML(), gr.outputs.Label()],  # Use Label for displaying the number of messages
-    capture_session=True  # Automatically captures IP address and user agent
-)
-
-iface.launch(print_session_data)  # Pass the function to print session data to the launch method

spaces/AILab-CVC/SEED-LLaMA/models/seed_qformer/utils.py

@@ -1,138 +0,0 @@
-"""
- 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 datetime
-import functools
-import os
-
-import torch
-import torch.distributed as dist
-import timm.models.hub as timm_hub
-from urllib.parse import urlparse
-
-
-def setup_for_distributed(is_master):
-    """
-    This function disables printing when not in master process
-    """
-    import builtins as __builtin__
-
-    builtin_print = __builtin__.print
-
-    def print(*args, **kwargs):
-        force = kwargs.pop("force", False)
-        if is_master or force:
-            builtin_print(*args, **kwargs)
-
-    __builtin__.print = print
-
-
-def is_dist_avail_and_initialized():
-    if not dist.is_available():
-        return False
-    if not dist.is_initialized():
-        return False
-    return True
-
-
-def get_world_size():
-    if not is_dist_avail_and_initialized():
-        return 1
-    return dist.get_world_size()
-
-
-def get_rank():
-    if not is_dist_avail_and_initialized():
-        return 0
-    return dist.get_rank()
-
-
-def is_main_process():
-    return get_rank() == 0
-
-
-def init_distributed_mode(args):
-    if "RANK" in os.environ and "WORLD_SIZE" in os.environ:
-        args.rank = int(os.environ["RANK"])
-        args.world_size = int(os.environ["WORLD_SIZE"])
-        args.gpu = int(os.environ["LOCAL_RANK"])
-    elif "SLURM_PROCID" in os.environ:
-        args.rank = int(os.environ["SLURM_PROCID"])
-        args.gpu = args.rank % torch.cuda.device_count()
-    else:
-        print("Not using distributed mode")
-        args.distributed = False
-        return
-
-    args.distributed = True
-
-    torch.cuda.set_device(args.gpu)
-    args.dist_backend = "nccl"
-    print(
-        "| distributed init (rank {}, world {}): {}".format(args.rank, args.world_size, args.dist_url),
-        flush=True,
-    )
-    torch.distributed.init_process_group(
-        backend=args.dist_backend,
-        init_method=args.dist_url,
-        world_size=args.world_size,
-        rank=args.rank,
-        timeout=datetime.timedelta(days=365),  # allow auto-downloading and de-compressing
-    )
-    torch.distributed.barrier()
-    setup_for_distributed(args.rank == 0)
-
-
-def get_dist_info():
-    if torch.__version__ < "1.0":
-        initialized = dist._initialized
-    else:
-        initialized = dist.is_initialized()
-    if initialized:
-        rank = dist.get_rank()
-        world_size = dist.get_world_size()
-    else:  # non-distributed training
-        rank = 0
-        world_size = 1
-    return rank, world_size
-
-
-def main_process(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        rank, _ = get_dist_info()
-        if rank == 0:
-            return func(*args, **kwargs)
-
-    return wrapper
-
-
-def download_cached_file(url, check_hash=True, progress=False):
-    """
-    Download a file from a URL and cache it locally. If the file already exists, it is not downloaded again.
-    If distributed, only the main process downloads the file, and the other processes wait for the file to be downloaded.
-    """
-    def get_cached_file_path():
-        # a hack to sync the file path across processes
-        parts = torch.hub.urlparse(url)
-        filename = os.path.basename(parts.path)
-        cached_file = os.path.join(timm_hub.get_cache_dir(), filename)
-
-        return cached_file
-
-    if is_main_process():
-        timm_hub.download_cached_file(url, check_hash, progress)
-
-    if is_dist_avail_and_initialized():
-        dist.barrier()
-
-    return get_cached_file_path()
-
-
-def is_url(url_or_filename):
-    parsed = urlparse(url_or_filename)
-    return parsed.scheme in ("http", "https")

spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/server/models.ts

@@ -1,178 +0,0 @@
-import { HF_ACCESS_TOKEN, MODELS, OLD_MODELS } from "$env/static/private";
-import type {
-	ChatTemplateInput,
-	WebSearchQueryTemplateInput,
-	WebSearchSummaryTemplateInput,
-} from "$lib/types/Template";
-import { compileTemplate } from "$lib/utils/template";
-import { z } from "zod";
-
-type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
-
-const sagemakerEndpoint = z.object({
-	host: z.literal("sagemaker"),
-	url: z.string().url(),
-	accessKey: z.string().min(1),
-	secretKey: z.string().min(1),
-	sessionToken: z.string().optional(),
-});
-
-const tgiEndpoint = z.object({
-	host: z.union([z.literal("tgi"), z.undefined()]),
-	url: z.string().url(),
-	authorization: z.string().min(1).default(`Bearer ${HF_ACCESS_TOKEN}`),
-});
-
-const localEndpoint = z.object({
-	host: z.union([z.literal("local"), z.undefined()]),
-	model: z.string(),
-	url: z.string().url(),
-	authorization: z.string().min(1).default(`Bearer ${HF_ACCESS_TOKEN}`),
-});
-
-const commonEndpoint = z.object({
-	weight: z.number().int().positive().default(1),
-});
-
-const endpoint = z.lazy(() =>
-	z.union([
-		sagemakerEndpoint.merge(commonEndpoint),
-		tgiEndpoint.merge(commonEndpoint),
-		localEndpoint.merge(commonEndpoint),
-	])
-);
-
-const combinedEndpoint = endpoint.transform((data) => {
-	if (data.host === "tgi" || data.host === undefined) {
-		return tgiEndpoint.merge(commonEndpoint).parse(data);
-	} else if (data.host === "sagemaker") {
-		return sagemakerEndpoint.merge(commonEndpoint).parse(data);
-	} else if (data.host === "local") {
-		return localEndpoint.merge(commonEndpoint).parse(data);
-	} else {
-		throw new Error(`Invalid host: ${data.host}`);
-	}
-});
-
-const modelsRaw = z
-	.array(
-		z.object({
-			/** Used as an identifier in DB */
-			id: z.string().optional(),
-			/** Used to link to the model page, and for inference */
-			name: z.string().min(1),
-			displayName: z.string().min(1).optional(),
-			description: z.string().min(1).optional(),
-			is_local: z.boolean().optional(),
-			is_code: z.boolean().optional(),
-			is_phi: z.boolean().optional(),
-			type: z.string().min(1),
-			websiteUrl: z.string().url().optional(),
-			modelUrl: z.string().url().optional(),
-			datasetName: z.string().min(1).optional(),
-			datasetUrl: z.string().url().optional(),
-			userMessageToken: z.string().default(""),
-			userMessageEndToken: z.string().default(""),
-			assistantMessageToken: z.string().default(""),
-			assistantMessageEndToken: z.string().default(""),
-			messageEndToken: z.string().default(""),
-			preprompt: z.string().default(""),
-			prepromptUrl: z.string().url().optional(),
-			chatPromptTemplate: z
-				.string()
-				.default(
-					"{{preprompt}}" +
-						"{{#each messages}}" +
-						"{{#ifUser}}{{@root.userMessageToken}}{{content}}{{@root.userMessageEndToken}}{{/ifUser}}" +
-						"{{#ifAssistant}}{{@root.assistantMessageToken}}{{content}}{{@root.assistantMessageEndToken}}{{/ifAssistant}}" +
-						"{{/each}}" +
-						"{{assistantMessageToken}}"
-				),
-			webSearchSummaryPromptTemplate: z
-				.string()
-				.default(
-					"{{userMessageToken}}{{answer}}{{userMessageEndToken}}" +
-						"{{userMessageToken}}" +
-						"The text above should be summarized to best answer the query: {{query}}." +
-						"{{userMessageEndToken}}" +
-						"{{assistantMessageToken}}Summary: "
-				),
-			webSearchQueryPromptTemplate: z
-				.string()
-				.default(
-					"{{userMessageToken}}" +
-						"The following messages were written by a user, trying to answer a question." +
-						"{{userMessageEndToken}}" +
-						"{{#each messages}}" +
-						"{{#ifUser}}{{@root.userMessageToken}}{{content}}{{@root.userMessageEndToken}}{{/ifUser}}" +
-						"{{/each}}" +
-						"{{userMessageToken}}" +
-						"What plain-text english sentence would you input into Google to answer the last question? Answer with a short (10 words max) simple sentence." +
-						"{{userMessageEndToken}}" +
-						"{{assistantMessageToken}}Query: "
-				),
-			promptExamples: z
-				.array(
-					z.object({
-						title: z.string().min(1),
-						prompt: z.string().min(1),
-					})
-				)
-				.optional(),
-			endpoints: z.array(combinedEndpoint).optional(),
-			parameters: z
-				.object({
-					temperature: z.number().min(0).max(1),
-					truncate: z.number().int().positive(),
-					max_new_tokens: z.number().int().positive(),
-					stop: z.array(z.string()).optional(),
-				})
-				.passthrough()
-				.optional(),
-		})
-	)
-	.parse(JSON.parse(MODELS));
-
-export const models = await Promise.all(
-	modelsRaw.map(async (m) => ({
-		...m,
-		userMessageEndToken: m?.userMessageEndToken || m?.messageEndToken,
-		assistantMessageEndToken: m?.assistantMessageEndToken || m?.messageEndToken,
-		chatPromptRender: compileTemplate<ChatTemplateInput>(m.chatPromptTemplate, m),
-		webSearchSummaryPromptRender: compileTemplate<WebSearchSummaryTemplateInput>(
-			m.webSearchSummaryPromptTemplate,
-			m
-		),
-		webSearchQueryPromptRender: compileTemplate<WebSearchQueryTemplateInput>(
-			m.webSearchQueryPromptTemplate,
-			m
-		),
-		id: m.id || m.name,
-		displayName: m.displayName || m.name,
-		preprompt: m.prepromptUrl ? await fetch(m.prepromptUrl).then((r) => r.text()) : m.preprompt,
-	}))
-);
-
-// Models that have been deprecated
-export const oldModels = OLD_MODELS
-	? z
-			.array(
-				z.object({
-					id: z.string().optional(),
-					name: z.string().min(1),
-					displayName: z.string().min(1).optional(),
-				})
-			)
-			.parse(JSON.parse(OLD_MODELS))
-			.map((m) => ({ ...m, id: m.id || m.name, displayName: m.displayName || m.name }))
-	: [];
-
-export type BackendModel = Optional<(typeof models)[0], "preprompt">;
-export type Endpoint = z.infer<typeof endpoint>;
-
-export const defaultModel = models[0];
-
-export const validateModel = (_models: BackendModel[]) => {
-	// Zod enum function requires 2 parameters
-	return z.enum([_models[0].id, ..._models.slice(1).map((m) => m.id)]);
-};

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/text_to_image/train_text_to_image_lora.py

@@ -1,949 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Fine-tuning script for Stable Diffusion for text2image with support for LoRA."""
-
-import argparse
-import logging
-import math
-import os
-import random
-import shutil
-from pathlib import Path
-
-import datasets
-import numpy as np
-import torch
-import torch.nn.functional as F
-import torch.utils.checkpoint
-import transformers
-from accelerate import Accelerator
-from accelerate.logging import get_logger
-from accelerate.utils import ProjectConfiguration, set_seed
-from datasets import load_dataset
-from huggingface_hub import create_repo, upload_folder
-from packaging import version
-from torchvision import transforms
-from tqdm.auto import tqdm
-from transformers import CLIPTextModel, CLIPTokenizer
-
-import diffusers
-from diffusers import AutoencoderKL, DDPMScheduler, DiffusionPipeline, UNet2DConditionModel
-from diffusers.loaders import AttnProcsLayers
-from diffusers.models.attention_processor import LoRAAttnProcessor
-from diffusers.optimization import get_scheduler
-from diffusers.utils import check_min_version, is_wandb_available
-from diffusers.utils.import_utils import is_xformers_available
-
-
-# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
-check_min_version("0.19.0")
-
-logger = get_logger(__name__, log_level="INFO")
-
-
-def save_model_card(repo_id: str, images=None, base_model=str, dataset_name=str, repo_folder=None):
-    img_str = ""
-    for i, image in enumerate(images):
-        image.save(os.path.join(repo_folder, f"image_{i}.png"))
-        img_str += f"![img_{i}](./image_{i}.png)\n"
-
-    yaml = f"""
----
-license: creativeml-openrail-m
-base_model: {base_model}
-tags:
-- stable-diffusion
-- stable-diffusion-diffusers
-- text-to-image
-- diffusers
-- lora
-inference: true
----
-    """
-    model_card = f"""
-# LoRA text2image fine-tuning - {repo_id}
-These are LoRA adaption weights for {base_model}. The weights were fine-tuned on the {dataset_name} dataset. You can find some example images in the following. \n
-{img_str}
-"""
-    with open(os.path.join(repo_folder, "README.md"), "w") as f:
-        f.write(yaml + model_card)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Simple example of a training script.")
-    parser.add_argument(
-        "--pretrained_model_name_or_path",
-        type=str,
-        default=None,
-        required=True,
-        help="Path to pretrained model or model identifier from huggingface.co/models.",
-    )
-    parser.add_argument(
-        "--revision",
-        type=str,
-        default=None,
-        required=False,
-        help="Revision of pretrained model identifier from huggingface.co/models.",
-    )
-    parser.add_argument(
-        "--dataset_name",
-        type=str,
-        default=None,
-        help=(
-            "The name of the Dataset (from the HuggingFace hub) to train on (could be your own, possibly private,"
-            " dataset). It can also be a path pointing to a local copy of a dataset in your filesystem,"
-            " or to a folder containing files that 🤗 Datasets can understand."
-        ),
-    )
-    parser.add_argument(
-        "--dataset_config_name",
-        type=str,
-        default=None,
-        help="The config of the Dataset, leave as None if there's only one config.",
-    )
-    parser.add_argument(
-        "--train_data_dir",
-        type=str,
-        default=None,
-        help=(
-            "A folder containing the training data. Folder contents must follow the structure described in"
-            " https://huggingface.co/docs/datasets/image_dataset#imagefolder. In particular, a `metadata.jsonl` file"
-            " must exist to provide the captions for the images. Ignored if `dataset_name` is specified."
-        ),
-    )
-    parser.add_argument(
-        "--image_column", type=str, default="image", help="The column of the dataset containing an image."
-    )
-    parser.add_argument(
-        "--caption_column",
-        type=str,
-        default="text",
-        help="The column of the dataset containing a caption or a list of captions.",
-    )
-    parser.add_argument(
-        "--validation_prompt", type=str, default=None, help="A prompt that is sampled during training for inference."
-    )
-    parser.add_argument(
-        "--num_validation_images",
-        type=int,
-        default=4,
-        help="Number of images that should be generated during validation with `validation_prompt`.",
-    )
-    parser.add_argument(
-        "--validation_epochs",
-        type=int,
-        default=1,
-        help=(
-            "Run fine-tuning validation every X epochs. The validation process consists of running the prompt"
-            " `args.validation_prompt` multiple times: `args.num_validation_images`."
-        ),
-    )
-    parser.add_argument(
-        "--max_train_samples",
-        type=int,
-        default=None,
-        help=(
-            "For debugging purposes or quicker training, truncate the number of training examples to this "
-            "value if set."
-        ),
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default="sd-model-finetuned-lora",
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--cache_dir",
-        type=str,
-        default=None,
-        help="The directory where the downloaded models and datasets will be stored.",
-    )
-    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
-    parser.add_argument(
-        "--resolution",
-        type=int,
-        default=512,
-        help=(
-            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
-            " resolution"
-        ),
-    )
-    parser.add_argument(
-        "--center_crop",
-        default=False,
-        action="store_true",
-        help=(
-            "Whether to center crop the input images to the resolution. If not set, the images will be randomly"
-            " cropped. The images will be resized to the resolution first before cropping."
-        ),
-    )
-    parser.add_argument(
-        "--random_flip",
-        action="store_true",
-        help="whether to randomly flip images horizontally",
-    )
-    parser.add_argument(
-        "--train_batch_size", type=int, default=16, help="Batch size (per device) for the training dataloader."
-    )
-    parser.add_argument("--num_train_epochs", type=int, default=100)
-    parser.add_argument(
-        "--max_train_steps",
-        type=int,
-        default=None,
-        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
-    )
-    parser.add_argument(
-        "--gradient_accumulation_steps",
-        type=int,
-        default=1,
-        help="Number of updates steps to accumulate before performing a backward/update pass.",
-    )
-    parser.add_argument(
-        "--gradient_checkpointing",
-        action="store_true",
-        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
-    )
-    parser.add_argument(
-        "--learning_rate",
-        type=float,
-        default=1e-4,
-        help="Initial learning rate (after the potential warmup period) to use.",
-    )
-    parser.add_argument(
-        "--scale_lr",
-        action="store_true",
-        default=False,
-        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
-    )
-    parser.add_argument(
-        "--lr_scheduler",
-        type=str,
-        default="constant",
-        help=(
-            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
-            ' "constant", "constant_with_warmup"]'
-        ),
-    )
-    parser.add_argument(
-        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
-    )
-    parser.add_argument(
-        "--snr_gamma",
-        type=float,
-        default=None,
-        help="SNR weighting gamma to be used if rebalancing the loss. Recommended value is 5.0. "
-        "More details here: https://arxiv.org/abs/2303.09556.",
-    )
-    parser.add_argument(
-        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
-    )
-    parser.add_argument(
-        "--allow_tf32",
-        action="store_true",
-        help=(
-            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
-            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
-        ),
-    )
-    parser.add_argument(
-        "--dataloader_num_workers",
-        type=int,
-        default=0,
-        help=(
-            "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process."
-        ),
-    )
-    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
-    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
-    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
-    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
-    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
-    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
-    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
-    parser.add_argument(
-        "--prediction_type",
-        type=str,
-        default=None,
-        help="The prediction_type that shall be used for training. Choose between 'epsilon' or 'v_prediction' or leave `None`. If left to `None` the default prediction type of the scheduler: `noise_scheduler.config.prediciton_type` is chosen.",
-    )
-    parser.add_argument(
-        "--hub_model_id",
-        type=str,
-        default=None,
-        help="The name of the repository to keep in sync with the local `output_dir`.",
-    )
-    parser.add_argument(
-        "--logging_dir",
-        type=str,
-        default="logs",
-        help=(
-            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
-            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
-        ),
-    )
-    parser.add_argument(
-        "--mixed_precision",
-        type=str,
-        default=None,
-        choices=["no", "fp16", "bf16"],
-        help=(
-            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
-            " 1.10.and an Nvidia Ampere GPU.  Default to the value of accelerate config of the current system or the"
-            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
-        ),
-    )
-    parser.add_argument(
-        "--report_to",
-        type=str,
-        default="tensorboard",
-        help=(
-            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
-            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
-        ),
-    )
-    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
-    parser.add_argument(
-        "--checkpointing_steps",
-        type=int,
-        default=500,
-        help=(
-            "Save a checkpoint of the training state every X updates. These checkpoints are only suitable for resuming"
-            " training using `--resume_from_checkpoint`."
-        ),
-    )
-    parser.add_argument(
-        "--checkpoints_total_limit",
-        type=int,
-        default=None,
-        help=("Max number of checkpoints to store."),
-    )
-    parser.add_argument(
-        "--resume_from_checkpoint",
-        type=str,
-        default=None,
-        help=(
-            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
-            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
-        ),
-    )
-    parser.add_argument(
-        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
-    )
-    parser.add_argument("--noise_offset", type=float, default=0, help="The scale of noise offset.")
-    parser.add_argument(
-        "--rank",
-        type=int,
-        default=4,
-        help=("The dimension of the LoRA update matrices."),
-    )
-
-    args = parser.parse_args()
-    env_local_rank = int(os.environ.get("LOCAL_RANK", -1))
-    if env_local_rank != -1 and env_local_rank != args.local_rank:
-        args.local_rank = env_local_rank
-
-    # Sanity checks
-    if args.dataset_name is None and args.train_data_dir is None:
-        raise ValueError("Need either a dataset name or a training folder.")
-
-    return args
-
-
-DATASET_NAME_MAPPING = {
-    "lambdalabs/pokemon-blip-captions": ("image", "text"),
-}
-
-
-def main():
-    args = parse_args()
-    logging_dir = Path(args.output_dir, args.logging_dir)
-
-    accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir)
-
-    accelerator = Accelerator(
-        gradient_accumulation_steps=args.gradient_accumulation_steps,
-        mixed_precision=args.mixed_precision,
-        log_with=args.report_to,
-        project_config=accelerator_project_config,
-    )
-    if args.report_to == "wandb":
-        if not is_wandb_available():
-            raise ImportError("Make sure to install wandb if you want to use it for logging during training.")
-        import wandb
-
-    # Make one log on every process with the configuration for debugging.
-    logging.basicConfig(
-        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
-        datefmt="%m/%d/%Y %H:%M:%S",
-        level=logging.INFO,
-    )
-    logger.info(accelerator.state, main_process_only=False)
-    if accelerator.is_local_main_process:
-        datasets.utils.logging.set_verbosity_warning()
-        transformers.utils.logging.set_verbosity_warning()
-        diffusers.utils.logging.set_verbosity_info()
-    else:
-        datasets.utils.logging.set_verbosity_error()
-        transformers.utils.logging.set_verbosity_error()
-        diffusers.utils.logging.set_verbosity_error()
-
-    # If passed along, set the training seed now.
-    if args.seed is not None:
-        set_seed(args.seed)
-
-    # Handle the repository creation
-    if accelerator.is_main_process:
-        if args.output_dir is not None:
-            os.makedirs(args.output_dir, exist_ok=True)
-
-        if args.push_to_hub:
-            repo_id = create_repo(
-                repo_id=args.hub_model_id or Path(args.output_dir).name, exist_ok=True, token=args.hub_token
-            ).repo_id
-    # Load scheduler, tokenizer and models.
-    noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
-    tokenizer = CLIPTokenizer.from_pretrained(
-        args.pretrained_model_name_or_path, subfolder="tokenizer", revision=args.revision
-    )
-    text_encoder = CLIPTextModel.from_pretrained(
-        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
-    )
-    vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision)
-    unet = UNet2DConditionModel.from_pretrained(
-        args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
-    )
-    # freeze parameters of models to save more memory
-    unet.requires_grad_(False)
-    vae.requires_grad_(False)
-
-    text_encoder.requires_grad_(False)
-
-    # For mixed precision training we cast all non-trainable weigths (vae, non-lora text_encoder and non-lora unet) to half-precision
-    # as these weights are only used for inference, keeping weights in full precision is not required.
-    weight_dtype = torch.float32
-    if accelerator.mixed_precision == "fp16":
-        weight_dtype = torch.float16
-    elif accelerator.mixed_precision == "bf16":
-        weight_dtype = torch.bfloat16
-
-    # Move unet, vae and text_encoder to device and cast to weight_dtype
-    unet.to(accelerator.device, dtype=weight_dtype)
-    vae.to(accelerator.device, dtype=weight_dtype)
-    text_encoder.to(accelerator.device, dtype=weight_dtype)
-
-    # now we will add new LoRA weights to the attention layers
-    # It's important to realize here how many attention weights will be added and of which sizes
-    # The sizes of the attention layers consist only of two different variables:
-    # 1) - the "hidden_size", which is increased according to `unet.config.block_out_channels`.
-    # 2) - the "cross attention size", which is set to `unet.config.cross_attention_dim`.
-
-    # Let's first see how many attention processors we will have to set.
-    # For Stable Diffusion, it should be equal to:
-    # - down blocks (2x attention layers) * (2x transformer layers) * (3x down blocks) = 12
-    # - mid blocks (2x attention layers) * (1x transformer layers) * (1x mid blocks) = 2
-    # - up blocks (2x attention layers) * (3x transformer layers) * (3x down blocks) = 18
-    # => 32 layers
-
-    # Set correct lora layers
-    lora_attn_procs = {}
-    for name in unet.attn_processors.keys():
-        cross_attention_dim = None if name.endswith("attn1.processor") else unet.config.cross_attention_dim
-        if name.startswith("mid_block"):
-            hidden_size = unet.config.block_out_channels[-1]
-        elif name.startswith("up_blocks"):
-            block_id = int(name[len("up_blocks.")])
-            hidden_size = list(reversed(unet.config.block_out_channels))[block_id]
-        elif name.startswith("down_blocks"):
-            block_id = int(name[len("down_blocks.")])
-            hidden_size = unet.config.block_out_channels[block_id]
-
-        lora_attn_procs[name] = LoRAAttnProcessor(
-            hidden_size=hidden_size,
-            cross_attention_dim=cross_attention_dim,
-            rank=args.rank,
-        )
-
-    unet.set_attn_processor(lora_attn_procs)
-
-    if args.enable_xformers_memory_efficient_attention:
-        if is_xformers_available():
-            import xformers
-
-            xformers_version = version.parse(xformers.__version__)
-            if xformers_version == version.parse("0.0.16"):
-                logger.warn(
-                    "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details."
-                )
-            unet.enable_xformers_memory_efficient_attention()
-        else:
-            raise ValueError("xformers is not available. Make sure it is installed correctly")
-
-    def compute_snr(timesteps):
-        """
-        Computes SNR as per https://github.com/TiankaiHang/Min-SNR-Diffusion-Training/blob/521b624bd70c67cee4bdf49225915f5945a872e3/guided_diffusion/gaussian_diffusion.py#L847-L849
-        """
-        alphas_cumprod = noise_scheduler.alphas_cumprod
-        sqrt_alphas_cumprod = alphas_cumprod**0.5
-        sqrt_one_minus_alphas_cumprod = (1.0 - alphas_cumprod) ** 0.5
-
-        # Expand the tensors.
-        # Adapted from https://github.com/TiankaiHang/Min-SNR-Diffusion-Training/blob/521b624bd70c67cee4bdf49225915f5945a872e3/guided_diffusion/gaussian_diffusion.py#L1026
-        sqrt_alphas_cumprod = sqrt_alphas_cumprod.to(device=timesteps.device)[timesteps].float()
-        while len(sqrt_alphas_cumprod.shape) < len(timesteps.shape):
-            sqrt_alphas_cumprod = sqrt_alphas_cumprod[..., None]
-        alpha = sqrt_alphas_cumprod.expand(timesteps.shape)
-
-        sqrt_one_minus_alphas_cumprod = sqrt_one_minus_alphas_cumprod.to(device=timesteps.device)[timesteps].float()
-        while len(sqrt_one_minus_alphas_cumprod.shape) < len(timesteps.shape):
-            sqrt_one_minus_alphas_cumprod = sqrt_one_minus_alphas_cumprod[..., None]
-        sigma = sqrt_one_minus_alphas_cumprod.expand(timesteps.shape)
-
-        # Compute SNR.
-        snr = (alpha / sigma) ** 2
-        return snr
-
-    lora_layers = AttnProcsLayers(unet.attn_processors)
-
-    # Enable TF32 for faster training on Ampere GPUs,
-    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
-    if args.allow_tf32:
-        torch.backends.cuda.matmul.allow_tf32 = True
-
-    if args.scale_lr:
-        args.learning_rate = (
-            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
-        )
-
-    # Initialize the optimizer
-    if args.use_8bit_adam:
-        try:
-            import bitsandbytes as bnb
-        except ImportError:
-            raise ImportError(
-                "Please install bitsandbytes to use 8-bit Adam. You can do so by running `pip install bitsandbytes`"
-            )
-
-        optimizer_cls = bnb.optim.AdamW8bit
-    else:
-        optimizer_cls = torch.optim.AdamW
-
-    optimizer = optimizer_cls(
-        lora_layers.parameters(),
-        lr=args.learning_rate,
-        betas=(args.adam_beta1, args.adam_beta2),
-        weight_decay=args.adam_weight_decay,
-        eps=args.adam_epsilon,
-    )
-
-    # Get the datasets: you can either provide your own training and evaluation files (see below)
-    # or specify a Dataset from the hub (the dataset will be downloaded automatically from the datasets Hub).
-
-    # In distributed training, the load_dataset function guarantees that only one local process can concurrently
-    # download the dataset.
-    if args.dataset_name is not None:
-        # Downloading and loading a dataset from the hub.
-        dataset = load_dataset(
-            args.dataset_name,
-            args.dataset_config_name,
-            cache_dir=args.cache_dir,
-        )
-    else:
-        data_files = {}
-        if args.train_data_dir is not None:
-            data_files["train"] = os.path.join(args.train_data_dir, "**")
-        dataset = load_dataset(
-            "imagefolder",
-            data_files=data_files,
-            cache_dir=args.cache_dir,
-        )
-        # See more about loading custom images at
-        # https://huggingface.co/docs/datasets/v2.4.0/en/image_load#imagefolder
-
-    # Preprocessing the datasets.
-    # We need to tokenize inputs and targets.
-    column_names = dataset["train"].column_names
-
-    # 6. Get the column names for input/target.
-    dataset_columns = DATASET_NAME_MAPPING.get(args.dataset_name, None)
-    if args.image_column is None:
-        image_column = dataset_columns[0] if dataset_columns is not None else column_names[0]
-    else:
-        image_column = args.image_column
-        if image_column not in column_names:
-            raise ValueError(
-                f"--image_column' value '{args.image_column}' needs to be one of: {', '.join(column_names)}"
-            )
-    if args.caption_column is None:
-        caption_column = dataset_columns[1] if dataset_columns is not None else column_names[1]
-    else:
-        caption_column = args.caption_column
-        if caption_column not in column_names:
-            raise ValueError(
-                f"--caption_column' value '{args.caption_column}' needs to be one of: {', '.join(column_names)}"
-            )
-
-    # Preprocessing the datasets.
-    # We need to tokenize input captions and transform the images.
-    def tokenize_captions(examples, is_train=True):
-        captions = []
-        for caption in examples[caption_column]:
-            if isinstance(caption, str):
-                captions.append(caption)
-            elif isinstance(caption, (list, np.ndarray)):
-                # take a random caption if there are multiple
-                captions.append(random.choice(caption) if is_train else caption[0])
-            else:
-                raise ValueError(
-                    f"Caption column `{caption_column}` should contain either strings or lists of strings."
-                )
-        inputs = tokenizer(
-            captions, max_length=tokenizer.model_max_length, padding="max_length", truncation=True, return_tensors="pt"
-        )
-        return inputs.input_ids
-
-    # Preprocessing the datasets.
-    train_transforms = transforms.Compose(
-        [
-            transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR),
-            transforms.CenterCrop(args.resolution) if args.center_crop else transforms.RandomCrop(args.resolution),
-            transforms.RandomHorizontalFlip() if args.random_flip else transforms.Lambda(lambda x: x),
-            transforms.ToTensor(),
-            transforms.Normalize([0.5], [0.5]),
-        ]
-    )
-
-    def preprocess_train(examples):
-        images = [image.convert("RGB") for image in examples[image_column]]
-        examples["pixel_values"] = [train_transforms(image) for image in images]
-        examples["input_ids"] = tokenize_captions(examples)
-        return examples
-
-    with accelerator.main_process_first():
-        if args.max_train_samples is not None:
-            dataset["train"] = dataset["train"].shuffle(seed=args.seed).select(range(args.max_train_samples))
-        # Set the training transforms
-        train_dataset = dataset["train"].with_transform(preprocess_train)
-
-    def collate_fn(examples):
-        pixel_values = torch.stack([example["pixel_values"] for example in examples])
-        pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
-        input_ids = torch.stack([example["input_ids"] for example in examples])
-        return {"pixel_values": pixel_values, "input_ids": input_ids}
-
-    # DataLoaders creation:
-    train_dataloader = torch.utils.data.DataLoader(
-        train_dataset,
-        shuffle=True,
-        collate_fn=collate_fn,
-        batch_size=args.train_batch_size,
-        num_workers=args.dataloader_num_workers,
-    )
-
-    # Scheduler and math around the number of training steps.
-    overrode_max_train_steps = False
-    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
-    if args.max_train_steps is None:
-        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
-        overrode_max_train_steps = True
-
-    lr_scheduler = get_scheduler(
-        args.lr_scheduler,
-        optimizer=optimizer,
-        num_warmup_steps=args.lr_warmup_steps * accelerator.num_processes,
-        num_training_steps=args.max_train_steps * accelerator.num_processes,
-    )
-
-    # Prepare everything with our `accelerator`.
-    lora_layers, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
-        lora_layers, optimizer, train_dataloader, lr_scheduler
-    )
-
-    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
-    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
-    if overrode_max_train_steps:
-        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
-    # Afterwards we recalculate our number of training epochs
-    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
-
-    # We need to initialize the trackers we use, and also store our configuration.
-    # The trackers initializes automatically on the main process.
-    if accelerator.is_main_process:
-        accelerator.init_trackers("text2image-fine-tune", config=vars(args))
-
-    # Train!
-    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
-
-    logger.info("***** Running training *****")
-    logger.info(f"  Num examples = {len(train_dataset)}")
-    logger.info(f"  Num Epochs = {args.num_train_epochs}")
-    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
-    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
-    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
-    logger.info(f"  Total optimization steps = {args.max_train_steps}")
-    global_step = 0
-    first_epoch = 0
-
-    # Potentially load in the weights and states from a previous save
-    if args.resume_from_checkpoint:
-        if args.resume_from_checkpoint != "latest":
-            path = os.path.basename(args.resume_from_checkpoint)
-        else:
-            # Get the most recent checkpoint
-            dirs = os.listdir(args.output_dir)
-            dirs = [d for d in dirs if d.startswith("checkpoint")]
-            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
-            path = dirs[-1] if len(dirs) > 0 else None
-
-        if path is None:
-            accelerator.print(
-                f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run."
-            )
-            args.resume_from_checkpoint = None
-        else:
-            accelerator.print(f"Resuming from checkpoint {path}")
-            accelerator.load_state(os.path.join(args.output_dir, path))
-            global_step = int(path.split("-")[1])
-
-            resume_global_step = global_step * args.gradient_accumulation_steps
-            first_epoch = global_step // num_update_steps_per_epoch
-            resume_step = resume_global_step % (num_update_steps_per_epoch * args.gradient_accumulation_steps)
-
-    # Only show the progress bar once on each machine.
-    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
-    progress_bar.set_description("Steps")
-
-    for epoch in range(first_epoch, args.num_train_epochs):
-        unet.train()
-        train_loss = 0.0
-        for step, batch in enumerate(train_dataloader):
-            # Skip steps until we reach the resumed step
-            if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
-                if step % args.gradient_accumulation_steps == 0:
-                    progress_bar.update(1)
-                continue
-
-            with accelerator.accumulate(unet):
-                # Convert images to latent space
-                latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
-                latents = latents * vae.config.scaling_factor
-
-                # Sample noise that we'll add to the latents
-                noise = torch.randn_like(latents)
-                if args.noise_offset:
-                    # https://www.crosslabs.org//blog/diffusion-with-offset-noise
-                    noise += args.noise_offset * torch.randn(
-                        (latents.shape[0], latents.shape[1], 1, 1), device=latents.device
-                    )
-
-                bsz = latents.shape[0]
-                # Sample a random timestep for each image
-                timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device)
-                timesteps = timesteps.long()
-
-                # Add noise to the latents according to the noise magnitude at each timestep
-                # (this is the forward diffusion process)
-                noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
-
-                # Get the text embedding for conditioning
-                encoder_hidden_states = text_encoder(batch["input_ids"])[0]
-
-                # Get the target for loss depending on the prediction type
-                if args.prediction_type is not None:
-                    # set prediction_type of scheduler if defined
-                    noise_scheduler.register_to_config(prediction_type=args.prediction_type)
-
-                if noise_scheduler.config.prediction_type == "epsilon":
-                    target = noise
-                elif noise_scheduler.config.prediction_type == "v_prediction":
-                    target = noise_scheduler.get_velocity(latents, noise, timesteps)
-                else:
-                    raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
-
-                # Predict the noise residual and compute loss
-                model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
-
-                if args.snr_gamma is None:
-                    loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
-                else:
-                    # Compute loss-weights as per Section 3.4 of https://arxiv.org/abs/2303.09556.
-                    # Since we predict the noise instead of x_0, the original formulation is slightly changed.
-                    # This is discussed in Section 4.2 of the same paper.
-                    snr = compute_snr(timesteps)
-                    mse_loss_weights = (
-                        torch.stack([snr, args.snr_gamma * torch.ones_like(timesteps)], dim=1).min(dim=1)[0] / snr
-                    )
-                    # We first calculate the original loss. Then we mean over the non-batch dimensions and
-                    # rebalance the sample-wise losses with their respective loss weights.
-                    # Finally, we take the mean of the rebalanced loss.
-                    loss = F.mse_loss(model_pred.float(), target.float(), reduction="none")
-                    loss = loss.mean(dim=list(range(1, len(loss.shape)))) * mse_loss_weights
-                    loss = loss.mean()
-
-                # Gather the losses across all processes for logging (if we use distributed training).
-                avg_loss = accelerator.gather(loss.repeat(args.train_batch_size)).mean()
-                train_loss += avg_loss.item() / args.gradient_accumulation_steps
-
-                # Backpropagate
-                accelerator.backward(loss)
-                if accelerator.sync_gradients:
-                    params_to_clip = lora_layers.parameters()
-                    accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
-                optimizer.step()
-                lr_scheduler.step()
-                optimizer.zero_grad()
-
-            # Checks if the accelerator has performed an optimization step behind the scenes
-            if accelerator.sync_gradients:
-                progress_bar.update(1)
-                global_step += 1
-                accelerator.log({"train_loss": train_loss}, step=global_step)
-                train_loss = 0.0
-
-                if global_step % args.checkpointing_steps == 0:
-                    if accelerator.is_main_process:
-                        # _before_ saving state, check if this save would set us over the `checkpoints_total_limit`
-                        if args.checkpoints_total_limit is not None:
-                            checkpoints = os.listdir(args.output_dir)
-                            checkpoints = [d for d in checkpoints if d.startswith("checkpoint")]
-                            checkpoints = sorted(checkpoints, key=lambda x: int(x.split("-")[1]))
-
-                            # before we save the new checkpoint, we need to have at _most_ `checkpoints_total_limit - 1` checkpoints
-                            if len(checkpoints) >= args.checkpoints_total_limit:
-                                num_to_remove = len(checkpoints) - args.checkpoints_total_limit + 1
-                                removing_checkpoints = checkpoints[0:num_to_remove]
-
-                                logger.info(
-                                    f"{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints"
-                                )
-                                logger.info(f"removing checkpoints: {', '.join(removing_checkpoints)}")
-
-                                for removing_checkpoint in removing_checkpoints:
-                                    removing_checkpoint = os.path.join(args.output_dir, removing_checkpoint)
-                                    shutil.rmtree(removing_checkpoint)
-
-                        save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}")
-                        accelerator.save_state(save_path)
-                        logger.info(f"Saved state to {save_path}")
-
-            logs = {"step_loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
-            progress_bar.set_postfix(**logs)
-
-            if global_step >= args.max_train_steps:
-                break
-
-        if accelerator.is_main_process:
-            if args.validation_prompt is not None and epoch % args.validation_epochs == 0:
-                logger.info(
-                    f"Running validation... \n Generating {args.num_validation_images} images with prompt:"
-                    f" {args.validation_prompt}."
-                )
-                # create pipeline
-                pipeline = DiffusionPipeline.from_pretrained(
-                    args.pretrained_model_name_or_path,
-                    unet=accelerator.unwrap_model(unet),
-                    revision=args.revision,
-                    torch_dtype=weight_dtype,
-                )
-                pipeline = pipeline.to(accelerator.device)
-                pipeline.set_progress_bar_config(disable=True)
-
-                # run inference
-                generator = torch.Generator(device=accelerator.device)
-                if args.seed is not None:
-                    generator = generator.manual_seed(args.seed)
-                images = []
-                for _ in range(args.num_validation_images):
-                    images.append(
-                        pipeline(args.validation_prompt, num_inference_steps=30, generator=generator).images[0]
-                    )
-
-                for tracker in accelerator.trackers:
-                    if tracker.name == "tensorboard":
-                        np_images = np.stack([np.asarray(img) for img in images])
-                        tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
-                    if tracker.name == "wandb":
-                        tracker.log(
-                            {
-                                "validation": [
-                                    wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
-                                    for i, image in enumerate(images)
-                                ]
-                            }
-                        )
-
-                del pipeline
-                torch.cuda.empty_cache()
-
-    # Save the lora layers
-    accelerator.wait_for_everyone()
-    if accelerator.is_main_process:
-        unet = unet.to(torch.float32)
-        unet.save_attn_procs(args.output_dir)
-
-        if args.push_to_hub:
-            save_model_card(
-                repo_id,
-                images=images,
-                base_model=args.pretrained_model_name_or_path,
-                dataset_name=args.dataset_name,
-                repo_folder=args.output_dir,
-            )
-            upload_folder(
-                repo_id=repo_id,
-                folder_path=args.output_dir,
-                commit_message="End of training",
-                ignore_patterns=["step_*", "epoch_*"],
-            )
-
-    # Final inference
-    # Load previous pipeline
-    pipeline = DiffusionPipeline.from_pretrained(
-        args.pretrained_model_name_or_path, revision=args.revision, torch_dtype=weight_dtype
-    )
-    pipeline = pipeline.to(accelerator.device)
-
-    # load attention processors
-    pipeline.unet.load_attn_procs(args.output_dir)
-
-    # run inference
-    generator = torch.Generator(device=accelerator.device)
-    if args.seed is not None:
-        generator = generator.manual_seed(args.seed)
-    images = []
-    for _ in range(args.num_validation_images):
-        images.append(pipeline(args.validation_prompt, num_inference_steps=30, generator=generator).images[0])
-
-    if accelerator.is_main_process:
-        for tracker in accelerator.trackers:
-            if len(images) != 0:
-                if tracker.name == "tensorboard":
-                    np_images = np.stack([np.asarray(img) for img in images])
-                    tracker.writer.add_images("test", np_images, epoch, dataformats="NHWC")
-                if tracker.name == "wandb":
-                    tracker.log(
-                        {
-                            "test": [
-                                wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
-                                for i, image in enumerate(images)
-                            ]
-                        }
-                    )
-
-    accelerator.end_training()
-
-
-if __name__ == "__main__":
-    main()

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/fixtures/custom_pipeline/what_ever.py

@@ -1,101 +0,0 @@
-# Copyright 2023 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-
-# limitations under the License.
-
-
-from typing import Optional, Tuple, Union
-
-import torch
-
-from diffusers.pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-
-
-class CustomLocalPipeline(DiffusionPipeline):
-    r"""
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
-    library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
-
-    Parameters:
-        unet ([`UNet2DModel`]): U-Net architecture to denoise the encoded image.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image. Can be one of
-            [`DDPMScheduler`], or [`DDIMScheduler`].
-    """
-
-    def __init__(self, unet, scheduler):
-        super().__init__()
-        self.register_modules(unet=unet, scheduler=scheduler)
-
-    @torch.no_grad()
-    def __call__(
-        self,
-        batch_size: int = 1,
-        generator: Optional[torch.Generator] = None,
-        num_inference_steps: int = 50,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        **kwargs,
-    ) -> Union[ImagePipelineOutput, Tuple]:
-        r"""
-        Args:
-            batch_size (`int`, *optional*, defaults to 1):
-                The number of images to generate.
-            generator (`torch.Generator`, *optional*):
-                A [torch generator](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make generation
-                deterministic.
-            eta (`float`, *optional*, defaults to 0.0):
-                The eta parameter which controls the scale of the variance (0 is DDIM and 1 is one type of DDPM).
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipeline_utils.ImagePipelineOutput`] instead of a plain tuple.
-
-        Returns:
-            [`~pipeline_utils.ImagePipelineOutput`] or `tuple`: [`~pipelines.utils.ImagePipelineOutput`] if
-            `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the
-            generated images.
-        """
-
-        # Sample gaussian noise to begin loop
-        image = torch.randn(
-            (batch_size, self.unet.config.in_channels, self.unet.config.sample_size, self.unet.config.sample_size),
-            generator=generator,
-        )
-        image = image.to(self.device)
-
-        # set step values
-        self.scheduler.set_timesteps(num_inference_steps)
-
-        for t in self.progress_bar(self.scheduler.timesteps):
-            # 1. predict noise model_output
-            model_output = self.unet(image, t).sample
-
-            # 2. predict previous mean of image x_t-1 and add variance depending on eta
-            # eta corresponds to η in paper and should be between [0, 1]
-            # do x_t -> x_t-1
-            image = self.scheduler.step(model_output, t, image).prev_sample
-
-        image = (image / 2 + 0.5).clamp(0, 1)
-        image = image.cpu().permute(0, 2, 3, 1).numpy()
-        if output_type == "pil":
-            image = self.numpy_to_pil(image)
-
-        if not return_dict:
-            return (image,), "This is a local test"
-
-        return ImagePipelineOutput(images=image), "This is a local test"

spaces/Andy1621/uniformer_image_detection/configs/_base_/models/cascade_rcnn_r50_fpn.py

@@ -1,179 +0,0 @@
-# model settings
-model = dict(
-    type='CascadeRCNN',
-    pretrained='torchvision://resnet50',
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        norm_eval=True,
-        style='pytorch'),
-    neck=dict(
-        type='FPN',
-        in_channels=[256, 512, 1024, 2048],
-        out_channels=256,
-        num_outs=5),
-    rpn_head=dict(
-        type='RPNHead',
-        in_channels=256,
-        feat_channels=256,
-        anchor_generator=dict(
-            type='AnchorGenerator',
-            scales=[8],
-            ratios=[0.5, 1.0, 2.0],
-            strides=[4, 8, 16, 32, 64]),
-        bbox_coder=dict(
-            type='DeltaXYWHBBoxCoder',
-            target_means=[.0, .0, .0, .0],
-            target_stds=[1.0, 1.0, 1.0, 1.0]),
-        loss_cls=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
-        loss_bbox=dict(type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)),
-    roi_head=dict(
-        type='CascadeRoIHead',
-        num_stages=3,
-        stage_loss_weights=[1, 0.5, 0.25],
-        bbox_roi_extractor=dict(
-            type='SingleRoIExtractor',
-            roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
-            out_channels=256,
-            featmap_strides=[4, 8, 16, 32]),
-        bbox_head=[
-            dict(
-                type='Shared2FCBBoxHead',
-                in_channels=256,
-                fc_out_channels=1024,
-                roi_feat_size=7,
-                num_classes=80,
-                bbox_coder=dict(
-                    type='DeltaXYWHBBoxCoder',
-                    target_means=[0., 0., 0., 0.],
-                    target_stds=[0.1, 0.1, 0.2, 0.2]),
-                reg_class_agnostic=True,
-                loss_cls=dict(
-                    type='CrossEntropyLoss',
-                    use_sigmoid=False,
-                    loss_weight=1.0),
-                loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
-                               loss_weight=1.0)),
-            dict(
-                type='Shared2FCBBoxHead',
-                in_channels=256,
-                fc_out_channels=1024,
-                roi_feat_size=7,
-                num_classes=80,
-                bbox_coder=dict(
-                    type='DeltaXYWHBBoxCoder',
-                    target_means=[0., 0., 0., 0.],
-                    target_stds=[0.05, 0.05, 0.1, 0.1]),
-                reg_class_agnostic=True,
-                loss_cls=dict(
-                    type='CrossEntropyLoss',
-                    use_sigmoid=False,
-                    loss_weight=1.0),
-                loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
-                               loss_weight=1.0)),
-            dict(
-                type='Shared2FCBBoxHead',
-                in_channels=256,
-                fc_out_channels=1024,
-                roi_feat_size=7,
-                num_classes=80,
-                bbox_coder=dict(
-                    type='DeltaXYWHBBoxCoder',
-                    target_means=[0., 0., 0., 0.],
-                    target_stds=[0.033, 0.033, 0.067, 0.067]),
-                reg_class_agnostic=True,
-                loss_cls=dict(
-                    type='CrossEntropyLoss',
-                    use_sigmoid=False,
-                    loss_weight=1.0),
-                loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0))
-        ]),
-    # model training and testing settings
-    train_cfg=dict(
-        rpn=dict(
-            assigner=dict(
-                type='MaxIoUAssigner',
-                pos_iou_thr=0.7,
-                neg_iou_thr=0.3,
-                min_pos_iou=0.3,
-                match_low_quality=True,
-                ignore_iof_thr=-1),
-            sampler=dict(
-                type='RandomSampler',
-                num=256,
-                pos_fraction=0.5,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=False),
-            allowed_border=0,
-            pos_weight=-1,
-            debug=False),
-        rpn_proposal=dict(
-            nms_pre=2000,
-            max_per_img=2000,
-            nms=dict(type='nms', iou_threshold=0.7),
-            min_bbox_size=0),
-        rcnn=[
-            dict(
-                assigner=dict(
-                    type='MaxIoUAssigner',
-                    pos_iou_thr=0.5,
-                    neg_iou_thr=0.5,
-                    min_pos_iou=0.5,
-                    match_low_quality=False,
-                    ignore_iof_thr=-1),
-                sampler=dict(
-                    type='RandomSampler',
-                    num=512,
-                    pos_fraction=0.25,
-                    neg_pos_ub=-1,
-                    add_gt_as_proposals=True),
-                pos_weight=-1,
-                debug=False),
-            dict(
-                assigner=dict(
-                    type='MaxIoUAssigner',
-                    pos_iou_thr=0.6,
-                    neg_iou_thr=0.6,
-                    min_pos_iou=0.6,
-                    match_low_quality=False,
-                    ignore_iof_thr=-1),
-                sampler=dict(
-                    type='RandomSampler',
-                    num=512,
-                    pos_fraction=0.25,
-                    neg_pos_ub=-1,
-                    add_gt_as_proposals=True),
-                pos_weight=-1,
-                debug=False),
-            dict(
-                assigner=dict(
-                    type='MaxIoUAssigner',
-                    pos_iou_thr=0.7,
-                    neg_iou_thr=0.7,
-                    min_pos_iou=0.7,
-                    match_low_quality=False,
-                    ignore_iof_thr=-1),
-                sampler=dict(
-                    type='RandomSampler',
-                    num=512,
-                    pos_fraction=0.25,
-                    neg_pos_ub=-1,
-                    add_gt_as_proposals=True),
-                pos_weight=-1,
-                debug=False)
-        ]),
-    test_cfg=dict(
-        rpn=dict(
-            nms_pre=1000,
-            max_per_img=1000,
-            nms=dict(type='nms', iou_threshold=0.7),
-            min_bbox_size=0),
-        rcnn=dict(
-            score_thr=0.05,
-            nms=dict(type='nms', iou_threshold=0.5),
-            max_per_img=100)))

spaces/Andy1621/uniformer_image_detection/configs/fpg/faster_rcnn_r50_fpg-chn128_crop640_50e_coco.py

@@ -1,9 +0,0 @@
-_base_ = 'faster_rcnn_r50_fpg_crop640_50e_coco.py'
-
-norm_cfg = dict(type='BN', requires_grad=True)
-model = dict(
-    neck=dict(out_channels=128, inter_channels=128),
-    rpn_head=dict(in_channels=128),
-    roi_head=dict(
-        bbox_roi_extractor=dict(out_channels=128),
-        bbox_head=dict(in_channels=128)))

spaces/Andy1621/uniformer_image_detection/mmdet/core/bbox/coder/base_bbox_coder.py

@@ -1,17 +0,0 @@
-from abc import ABCMeta, abstractmethod
-
-
-class BaseBBoxCoder(metaclass=ABCMeta):
-    """Base bounding box coder."""
-
-    def __init__(self, **kwargs):
-        pass
-
-    @abstractmethod
-    def encode(self, bboxes, gt_bboxes):
-        """Encode deltas between bboxes and ground truth boxes."""
-
-    @abstractmethod
-    def decode(self, bboxes, bboxes_pred):
-        """Decode the predicted bboxes according to prediction and base
-        boxes."""

spaces/Andy1621/uniformer_image_detection/mmdet/datasets/pipelines/__init__.py

@@ -1,25 +0,0 @@
-from .auto_augment import (AutoAugment, BrightnessTransform, ColorTransform,
-                           ContrastTransform, EqualizeTransform, Rotate, Shear,
-                           Translate)
-from .compose import Compose
-from .formating import (Collect, DefaultFormatBundle, ImageToTensor,
-                        ToDataContainer, ToTensor, Transpose, to_tensor)
-from .instaboost import InstaBoost
-from .loading import (LoadAnnotations, LoadImageFromFile, LoadImageFromWebcam,
-                      LoadMultiChannelImageFromFiles, LoadProposals)
-from .test_time_aug import MultiScaleFlipAug
-from .transforms import (Albu, CutOut, Expand, MinIoURandomCrop, Normalize,
-                         Pad, PhotoMetricDistortion, RandomCenterCropPad,
-                         RandomCrop, RandomFlip, Resize, SegRescale)
-
-__all__ = [
-    'Compose', 'to_tensor', 'ToTensor', 'ImageToTensor', 'ToDataContainer',
-    'Transpose', 'Collect', 'DefaultFormatBundle', 'LoadAnnotations',
-    'LoadImageFromFile', 'LoadImageFromWebcam',
-    'LoadMultiChannelImageFromFiles', 'LoadProposals', 'MultiScaleFlipAug',
-    'Resize', 'RandomFlip', 'Pad', 'RandomCrop', 'Normalize', 'SegRescale',
-    'MinIoURandomCrop', 'Expand', 'PhotoMetricDistortion', 'Albu',
-    'InstaBoost', 'RandomCenterCropPad', 'AutoAugment', 'CutOut', 'Shear',
-    'Rotate', 'ColorTransform', 'EqualizeTransform', 'BrightnessTransform',
-    'ContrastTransform', 'Translate'
-]

spaces/Andy1621/uniformer_image_detection/mmdet/datasets/pipelines/transforms.py

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

spaces/Andy1621/uniformer_image_detection/mmdet/models/detectors/htc.py

@@ -1,15 +0,0 @@
-from ..builder import DETECTORS
-from .cascade_rcnn import CascadeRCNN
-
-
-@DETECTORS.register_module()
-class HybridTaskCascade(CascadeRCNN):
-    """Implementation of `HTC <https://arxiv.org/abs/1901.07518>`_"""
-
-    def __init__(self, **kwargs):
-        super(HybridTaskCascade, self).__init__(**kwargs)
-
-    @property
-    def with_semantic(self):
-        """bool: whether the detector has a semantic head"""
-        return self.roi_head.with_semantic

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/extensions/multimodal/abstract_pipeline.py

@@ -1,62 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Optional
-
-import torch
-from PIL import Image
-
-
-class AbstractMultimodalPipeline(ABC):
-    @staticmethod
-    @abstractmethod
-    def name() -> str:
-        'name of the pipeline, should be same as in --multimodal-pipeline'
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def image_start() -> Optional[str]:
-        'return image start string, string representation of image start token, or None if not applicable'
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def image_end() -> Optional[str]:
-        'return image end string, string representation of image end token, or None if not applicable'
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def placeholder_token_id() -> int:
-        'return placeholder token id'
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def num_image_embeds() -> int:
-        'return the number of embeds used by a single image (for example: 256 for LLaVA)'
-        pass
-
-    @abstractmethod
-    def embed_images(self, images: List[Image.Image]) -> torch.Tensor:
-        'forward the images through vision pipeline, and return their embeddings'
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def embed_tokens(input_ids: torch.Tensor) -> torch.Tensor:
-        'embed tokens, the exact function varies by LLM, for LLaMA it is `shared.model.model.embed_tokens`'
-        pass
-
-    @staticmethod
-    @abstractmethod
-    def placeholder_embeddings() -> torch.Tensor:
-        'get placeholder embeddings if there are multiple images, and `add_all_images_to_prompt` is False'
-        pass
-
-    def _get_device(self, setting_name: str, params: dict):
-        if params[setting_name] is None:
-            return torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        return torch.device(params[setting_name])
-
-    def _get_dtype(self, setting_name: str, params: dict):
-        return torch.float32 if int(params[setting_name]) == 32 else torch.float16

spaces/Anonymous-sub/Rerender/ControlNet/ldm/modules/midas/midas/base_model.py

@@ -1,16 +0,0 @@
-import torch
-
-
-class BaseModel(torch.nn.Module):
-    def load(self, path):
-        """Load model from file.
-
-        Args:
-            path (str): file path
-        """
-        parameters = torch.load(path, map_location=torch.device('cpu'))
-
-        if "optimizer" in parameters:
-            parameters = parameters["model"]
-
-        self.load_state_dict(parameters)

spaces/Artrajz/vits-simple-api/vits/bert/__init__.py

@@ -1,15 +0,0 @@
-""" from https://github.com/PlayVoice/vits_chinese """
-import os
-
-import config
-from utils.download import download_and_verify
-from .ProsodyModel import TTSProsody
-
-URLS = [
-    "https://huggingface.co/spaces/maxmax20160403/vits_chinese/resolve/main/bert/prosody_model.pt",
-]
-TARGET_PATH = os.path.join(config.ABS_PATH, "vits/bert/prosody_model.pt")
-EXPECTED_MD5 = None
-
-if not os.path.exists(TARGET_PATH):
-    success, message = download_and_verify(URLS, TARGET_PATH, EXPECTED_MD5)

spaces/Audio-AGI/WavJourney/scripts/start_services.sh

@@ -1 +0,0 @@
-nohup conda run --live-stream -n WavJourney python services.py > services_logs/service.out 2>&1 &

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/projects/CenterNet2/demo.py

@@ -1,185 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-import argparse
-import glob
-import multiprocessing as mp
-import os
-import time
-import cv2
-import tqdm
-
-from detectron2.config import get_cfg
-from detectron2.data.detection_utils import read_image
-from detectron2.utils.logger import setup_logger
-
-from predictor import VisualizationDemo
-from centernet.config import add_centernet_config
-# constants
-WINDOW_NAME = "CenterNet2 detections"
-
-from detectron2.utils.video_visualizer import VideoVisualizer
-from detectron2.utils.visualizer import ColorMode, Visualizer
-from detectron2.data import MetadataCatalog
-
-def setup_cfg(args):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    add_centernet_config(cfg)
-    cfg.merge_from_file(args.config_file)
-    cfg.merge_from_list(args.opts)
-    # Set score_threshold for builtin models
-    cfg.MODEL.RETINANET.SCORE_THRESH_TEST = args.confidence_threshold
-    cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = args.confidence_threshold
-    if cfg.MODEL.META_ARCHITECTURE in ['ProposalNetwork', 'CenterNetDetector']:
-        cfg.MODEL.CENTERNET.INFERENCE_TH = args.confidence_threshold
-        cfg.MODEL.CENTERNET.NMS_TH = cfg.MODEL.ROI_HEADS.NMS_THRESH_TEST
-    cfg.MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH = args.confidence_threshold
-    cfg.freeze()
-    return cfg
-
-
-def get_parser():
-    parser = argparse.ArgumentParser(description="Detectron2 demo for builtin models")
-    parser.add_argument(
-        "--config-file",
-        default="configs/quick_schedules/mask_rcnn_R_50_FPN_inference_acc_test.yaml",
-        metavar="FILE",
-        help="path to config file",
-    )
-    parser.add_argument("--webcam", action="store_true", help="Take inputs from webcam.")
-    parser.add_argument("--video-input", help="Path to video file.")
-    parser.add_argument("--input", nargs="+", help="A list of space separated input images")
-    parser.add_argument(
-        "--output",
-        help="A file or directory to save output visualizations. "
-        "If not given, will show output in an OpenCV window.",
-    )
-
-    parser.add_argument(
-        "--confidence-threshold",
-        type=float,
-        default=0.3,
-        help="Minimum score for instance predictions to be shown",
-    )
-    parser.add_argument(
-        "--opts",
-        help="Modify config options using the command-line 'KEY VALUE' pairs",
-        default=[],
-        nargs=argparse.REMAINDER,
-    )
-    return parser
-
-
-if __name__ == "__main__":
-    mp.set_start_method("spawn", force=True)
-    args = get_parser().parse_args()
-    logger = setup_logger()
-    logger.info("Arguments: " + str(args))
-
-    cfg = setup_cfg(args)
-
-    demo = VisualizationDemo(cfg)
-    output_file = None
-    if args.input:
-        if len(args.input) == 1:
-            args.input = glob.glob(os.path.expanduser(args.input[0]))
-            files = os.listdir(args.input[0])
-            args.input = [args.input[0] + x for x in files]
-            assert args.input, "The input path(s) was not found"
-        visualizer = VideoVisualizer(
-            MetadataCatalog.get(
-                cfg.DATASETS.TEST[0] if len(cfg.DATASETS.TEST) else "__unused"
-            ), 
-            instance_mode=ColorMode.IMAGE)
-        for path in tqdm.tqdm(args.input, disable=not args.output):
-            # use PIL, to be consistent with evaluation
-            img = read_image(path, format="BGR")
-            start_time = time.time()
-            predictions, visualized_output = demo.run_on_image(
-                img, visualizer=visualizer)
-            if 'instances' in predictions:
-                logger.info(
-                    "{}: detected {} instances in {:.2f}s".format(
-                        path, len(predictions["instances"]), time.time() - start_time
-                    )
-                )
-            else:
-                logger.info(
-                    "{}: detected {} instances in {:.2f}s".format(
-                        path, len(predictions["proposals"]), time.time() - start_time
-                    )
-                )
-
-            if args.output:
-                if os.path.isdir(args.output):
-                    assert os.path.isdir(args.output), args.output
-                    out_filename = os.path.join(args.output, os.path.basename(path))
-                    visualized_output.save(out_filename)
-                else:
-                    # assert len(args.input) == 1, "Please specify a directory with args.output"
-                    # out_filename = args.output
-                    if output_file is None:
-                        width = visualized_output.get_image().shape[1]
-                        height = visualized_output.get_image().shape[0]
-                        frames_per_second = 15
-                        output_file = cv2.VideoWriter(
-                            filename=args.output,
-                            # some installation of opencv may not support x264 (due to its license),
-                            # you can try other format (e.g. MPEG)
-                            fourcc=cv2.VideoWriter_fourcc(*"x264"),
-                            fps=float(frames_per_second),
-                            frameSize=(width, height),
-                            isColor=True,
-                        )
-                    output_file.write(visualized_output.get_image()[:, :, ::-1])
-            else:
-                # cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
-                cv2.imshow(WINDOW_NAME, visualized_output.get_image()[:, :, ::-1])
-                if cv2.waitKey(1 ) == 27:
-                    break  # esc to quit
-    elif args.webcam:
-        assert args.input is None, "Cannot have both --input and --webcam!"
-        cam = cv2.VideoCapture(0)
-        for vis in tqdm.tqdm(demo.run_on_video(cam)):
-            cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
-            cv2.imshow(WINDOW_NAME, vis)
-            if cv2.waitKey(1) == 27:
-                break  # esc to quit
-        cv2.destroyAllWindows()
-    elif args.video_input:
-        video = cv2.VideoCapture(args.video_input)
-        width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        frames_per_second = 15 # video.get(cv2.CAP_PROP_FPS)
-        num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
-        basename = os.path.basename(args.video_input)
-
-        if args.output:
-            if os.path.isdir(args.output):
-                output_fname = os.path.join(args.output, basename)
-                output_fname = os.path.splitext(output_fname)[0] + ".mkv"
-            else:
-                output_fname = args.output
-            # assert not os.path.isfile(output_fname), output_fname
-            output_file = cv2.VideoWriter(
-                filename=output_fname,
-                # some installation of opencv may not support x264 (due to its license),
-                # you can try other format (e.g. MPEG)
-                fourcc=cv2.VideoWriter_fourcc(*"x264"),
-                fps=float(frames_per_second),
-                frameSize=(width, height),
-                isColor=True,
-            )
-        assert os.path.isfile(args.video_input)
-        for vis_frame in tqdm.tqdm(demo.run_on_video(video), total=num_frames):
-            if args.output:
-                output_file.write(vis_frame)
-
-            cv2.namedWindow(basename, cv2.WINDOW_NORMAL)
-            cv2.imshow(basename, vis_frame)
-            if cv2.waitKey(1) == 27:
-                break  # esc to quit
-        video.release()
-        if args.output:
-            output_file.release()
-        else:
-            cv2.destroyAllWindows()

spaces/Benson/text-generation/Examples/3d Solitario Descargar Gratis.md

@@ -1,61 +0,0 @@
-<br />
-<h1>Descargar gratis 3D Solitaire: La guía definitiva</h1>
-<p>Si eres un fan de los juegos de cartas clásicos, es posible que hayas oído hablar de 3D Solitaire. Es una versión moderna del juego tradicional de solitario, también conocido como Klondike o Patience, con impresionantes gráficos en 3D, ajustes personalizables y un juego adictivo. Pero ¿qué es 3D Solitaire exactamente, y cómo se puede descargar y jugar de forma gratuita? En esta guía, responderemos estas preguntas y más, para que puedas disfrutar de este increíble juego en tu dispositivo. ¡Empecemos! </p>
- <h2>¿Qué es el Solitario 3D? </h2>
-<p>3D Solitaire es un tipo de juego de solitario que utiliza gráficos tridimensionales para crear una experiencia realista e inmersiva. A diferencia de las cartas planas y aburridas del juego de solitario estándar, las tarjetas 3D Solitaire tienen una percepción de profundidad y una perspectiva de tamaño real, lo que hace que parezcan estar volando en tu pantalla. También puede personalizar el fondo y el respaldo de la cubierta con sus propias imágenes, o elegir entre una variedad de opciones preestablecidas. Jugar 3D Solitaire es como jugar con cartas reales, pero mejor. </p>
-<h2>3d solitario descargar gratis</h2><br /><p><b><b>Download</b> &#9658; <a href="https://bltlly.com/2v6MSJ">https://bltlly.com/2v6MSJ</a></b></p><br /><br />
- <h3>Historia y evolución del Solitario</h3>
-<p>Solitaire es uno de los juegos de cartas más antiguos y populares del mundo. Se originó en Europa a finales del siglo XVIII, y se jugó originalmente con una sola baraja de cartas. El objetivo era organizar las cartas en cuatro montones, uno para cada palo, en orden ascendente de As a Rey. El juego también era conocido como Paciencia, porque requería mucha concentración y habilidad. </p>
-<p>Con el tiempo, Solitaire evolucionó en diferentes variaciones, como Spider Solitaire, FreeCell solitaire, Mahjong y más. Algunas de estas variaciones añadieron más mazos, más reglas o más desafíos al juego. Sin embargo, el principio básico seguía siendo el mismo: ordenar las tarjetas de cierta manera. </p>
-
- <h3>Las características y beneficios de 3D Solitaire</h3>
-<p>3D Solitaire es una de las versiones más avanzadas e innovadoras de Solitaire jamás creadas. Ofrece el juego tradicional de Solitario con un historial completo de deshacer y rehacer, animaciones automáticas y configuraciones personalizadas. Usted puede elegir jugar con puntuación normal o Vegas, ofreciendo una experiencia de juego de cartas auténtica. </p>
-<p>Pero lo que diferencia a 3D Solitaire de otros juegos de Solitaire son sus impresionantes efectos visuales. El juego cuenta con gráficos 3D inmersivos que te hacen sentir como si estuvieras jugando con cartas reales. También puede personalizar el fondo y el respaldo de la cubierta con sus propias imágenes o elegir entre una variedad de opciones preestablecidas. También puede ajustar la velocidad, el desenfoque del movimiento, las sombras, los reflejos de color, la reproducción automática y las opciones de finalización para adaptarse a sus preferencias. </p>
-<p>No solo es visualmente impresionante 3D Solitaire, sino que también desafía tus habilidades lógicas con divertidos rompecabezas de diferentes niveles de dificultad. Puede utilizar indirectas interactivas que le muestran todos los movimientos posibles en la secuencia de lo más probable para resolver el juego menos probable. También puede utilizar soluciones que le muestran los movimientos exactos para resolver el juego, o dejar que el juego se juega automáticamente. También puedes realizar un seguimiento de tu progreso y logros con estadísticas y tablas de clasificación, y comparar tus puntuaciones con otros jugadores de todo el mundo. </p>
- <h2>¿Cómo descargar y jugar 3D Solitaire gratis? </h2>
-<p>Ahora que sabes lo que es 3D Solitaire y por qué es impresionante, es posible que se pregunte cómo conseguirlo en su dispositivo. La buena noticia es que 3D Solitaire está disponible de forma gratuita en varias plataformas y fuentes, para que pueda disfrutarlo en cualquier momento y en cualquier lugar. Estas son algunas de las mejores opciones para descargar y jugar 3D Solitaire gratis:</p>
-<p></p>
- <h3>Las mejores plataformas y fuentes para 3D Solitaire</h3>
-<p>Dependiendo de su dispositivo y preferencia, puede elegir entre diferentes plataformas y fuentes para 3D Solitaire. Estos son algunos de los más populares:</p>
-
-<p>Este es uno de los mejores juegos de solitario en 3D para dispositivos Android. Tiene más de 10 millones de descargas y una calificación de 4.5 estrellas en Google Play Store. Ofrece más de 100 juegos diferentes de solitario, incluyendo Klondike, Spider, FreeCell, Pyramid, TriPeaks, Golf y más. También puede personalizar las tarjetas, fondos, animaciones, sonidos y ajustes a su gusto. Puedes descargarlo gratis desde Google Play Store o desde el sitio web oficial. También puede actualizar a la versión premium por $2.99 para eliminar anuncios y desbloquear más características. </p>
- <h4>Solitario 3D por GrassGames</h4>
-<p>Este es otro gran juego de solitario en 3D que funciona en Windows, Mac, Linux, iOS y dispositivos Android. Tiene más de 1 millón de descargas y una calificación de 4.6 estrellas en App Store. Ofrece más de 250 juegos diferentes de solitario, incluyendo Klondike, Spider, FreeCell, Pyramid, TriPeaks, Golf y más. También puede personalizar las tarjetas, fondos, animaciones, sonidos y ajustes a su gusto. Puedes descargarlo gratis desde App Store, Google Play Store o desde el sitio web oficial. También puede actualizar a la versión premium por $4.99 para eliminar anuncios y desbloquear más características. </p>
- <h3>Los consejos y trucos para jugar 3D Solitaire como un profesional</h3>
-<p>Ya sea que seas nuevo en Solitario o un jugador experimentado, siempre puedes mejorar tus habilidades y estrategias con algunos consejos y trucos. Estos son algunos de los mejores para jugar 3D Solitaire como un profesional:</p>
- <h4>Cómo personalizar la configuración y las preferencias</h4>
-<p>Una de las mejores cosas de 3D Solitaire es que puedes adaptarlo a tu gusto. Puede cambiar el tamaño de la tarjeta, el estilo, el color, la fuente y el respaldo con sus propias imágenes o elegir entre una variedad de opciones preestablecidas. También puede cambiar la imagen de fondo o color con sus propias imágenes o elegir entre una variedad de opciones preestablecidas. También puede ajustar la velocidad, el desenfoque del movimiento, las sombras, los reflejos de color, la reproducción automática y las opciones de finalización para adaptarse a sus preferencias. </p>
-
- <h4>Cómo usar sugerencias y soluciones</h4>
-<p>Si estás atascado o necesitas alguna orientación, puedes usar las sugerencias y las funciones de soluciones en 3D Solitaire. Consejos le muestran todos los movimientos posibles en la secuencia de más probabilidades de resolver el juego a menos probable. Las soluciones le muestran los movimientos exactos para resolver el juego, o dejar que el juego se juega automáticamente. Puede acceder a estas características haciendo clic en el icono de bombilla en la esquina superior derecha de la pantalla. También puede ajustar la configuración de sugerencia y solución en el menú Opciones de juego. </p>
- <h4>Cómo alcanzar metas y posicionarse en la clasificación</h4>
-<p>Si estás buscando un poco de motivación y desafío extra, puedes intentar alcanzar metas y posicionarte en la clasificación en 3D Solitaire. Los objetivos son tareas específicas que necesitas completar en un juego, como limpiar todas las cartas, anotar un cierto número de puntos o terminar dentro de un límite de tiempo. Puedes ver tus objetivos actuales haciendo clic en el icono del trofeo en la esquina superior derecha de la pantalla. También puede ver sus metas y logros completados en el menú Estadísticas. </p>
-<p>Leaderboard es una característica que le permite comparar sus puntuaciones y clasificaciones con otros jugadores de todo el mundo. Puedes ver tu posición actual haciendo clic en el icono de estrella en la esquina superior derecha de la pantalla. También puedes ver tus mejores puntuaciones y rankings en diferentes categorías, como juegos jugados, juegos ganados, juegos perdidos, puntuación promedio, puntuación más alta, puntuación más baja, tiempo más rápido, tiempo más lento y racha más larga. También puedes filtrar la clasificación por tipo de juego, nivel de dificultad, modo de puntuación y periodo de tiempo. </p>
- <h2>¿Por qué debería probar 3D Solitaire hoy? </h2>
-<p>Por ahora, usted podría estar convencido de que 3D Solitaire es un gran juego para jugar. Pero si necesitas más razones para probarlo hoy, aquí están algunas de las ventajas de jugar 3D Solitaire sobre otros juegos de cartas:</p>
- <h3>Las ventajas de jugar 3D Solitaire sobre otros juegos de cartas</h3>
-
- <h4>Es divertido, desafiante y adictivo</h4>
-<p>3D Solitaire es un juego que nunca se vuelve viejo o aburrido. Ofrece infinitas variaciones y desafíos que te mantienen entretenido y comprometido. Puedes elegir entre más de 100 juegos de solitario diferentes, cada uno con sus propias reglas y estrategias. También puede personalizar sus ajustes y preferencias para hacer el juego más divertido y desafiante. También puedes competir contigo mismo o con otros jugadores de todo el mundo con metas y tablas de clasificación. Jugar 3D Solitaire es una gran manera de divertirse, desafiarse y mejorar sus habilidades. </p>
- <h4>Es visualmente impresionante e inmersiva</h4>
-<p>3D Solitaire es un juego que apela a tus sentidos e imaginación. Utiliza gráficos 3D realistas e inmersivos que te hacen sentir que estás jugando con cartas reales. También puede personalizar el fondo y el respaldo de la cubierta con sus propias imágenes o elegir entre una variedad de opciones preestablecidas. Jugar 3D Solitaire es como jugar en un entorno de realidad virtual, donde puedes disfrutar de la belleza y el realismo de los juegos de cartas. </p>
- <h4>Es bueno para el cerebro y la salud mental</h4>
-<p>3D Solitaire es un juego que estimula tu cerebro y tu salud mental. Requiere habilidades de lógica, concentración, memoria y resolución de problemas que mantengan tu mente aguda y activa. También te ayuda a relajarte, reducir el estrés y mejorar tu estado de ánimo. Jugar al solitario en 3D es una excelente manera de ejercitar tu cerebro y tu salud mental. </p>
- <h2>Conclusión</h2>
-<p>3D Solitaire es una versión moderna del juego tradicional de solitario, con impresionantes gráficos en 3D, ajustes personalizables y un juego adictivo. Ofrece más de 100 juegos diferentes de solitario, incluyendo Klondike, Spider, FreeCell, Pyramid, TriPeaks, Golf y más. También puede utilizar sugerencias y soluciones para ayudarle a resolver el juego o dejar que se juega automáticamente. También puedes rastrear tu progreso y logros con estadísticas y tablas de clasificación. </p>
-
-<p>3D Solitaire es un juego divertido, desafiante y adictivo. También es visualmente impresionante y envolvente, y bueno para su cerebro y la salud mental. Si eres un fan de los juegos de cartas clásicos o un recién llegado a Solitaire, deberías probar 3D Solitaire hoy y ver por ti mismo por qué es uno de los mejores juegos de todos los tiempos. </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí están algunas de las preguntas más frecuentes sobre 3D Solitaire:</p>
- <h4>Q: ¿Cuáles son los requisitos del sistema para el solitario 3D? </h4>
-<p>A: 3D Solitaire es compatible con la mayoría de los dispositivos y sistemas operativos. Sin embargo, para obtener el mejor rendimiento y gráficos, debe tener al menos 1 GB de RAM, 100 MB de espacio de almacenamiento gratuito y una tarjeta gráfica y un procesador decente. </p>
- <h4>Q: ¿Cómo puedo cambiar el tipo de juego o el nivel de dificultad en 3D Solitaire? </h4>
-<p>A: Para cambiar el tipo de juego o el nivel de dificultad en 3D Solitaire, es necesario acceder al menú haciendo clic en las tres líneas horizontales en la esquina superior izquierda de la pantalla. A continuación, puede seleccionar el tipo de juego opción de la lista de categorías. A continuación, puede elegir entre más de 100 diferentes juegos de solitario, cada uno con sus propias reglas y estrategias. También puedes ajustar el nivel de dificultad cambiando el número de palos, mazos o cartas en juego. </p>
- <h4>Q: ¿Cómo puedo guardar o cargar un juego en solitario en 3D? </h4>
-<p>A: Para guardar o cargar un juego en 3D Solitaire, es necesario acceder al menú haciendo clic en las tres líneas horizontales en la esquina superior izquierda de la pantalla. A continuación, puede seleccionar la opción Guardar juego o Cargar juego de la lista de categorías. A continuación, puede elegir una ranura para guardar o cargar el juego. También puedes usar la función Guardar automáticamente que guarda tu juego automáticamente cada vez que sales o cambias de aplicación. </p>
- <h4>P: ¿Cómo puedo compartir mis resultados o logros en solitario en 3D? </h4>
-
- <h4>Q: ¿Cómo puedo contactar a los desarrolladores o reportar un error en 3D Solitaire? </h4>
-<p>A: Para contactar a los desarrolladores o reportar un error en 3D Solitaire, necesita acceder al menú haciendo clic en las tres líneas horizontales en la esquina superior izquierda de la pantalla. Luego puede seleccionar la opción Ayuda de la lista de categorías. A continuación, puede elegir ponerse en contacto con los desarrolladores por correo electrónico, visitar su sitio web, calificar su aplicación, o informar de un error. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Ai Apk.md

@@ -1,76 +0,0 @@
-
-<h1>Ciudad muerta invasión zombi APK: Un juego de supervivencia para Android</h1>
-<p>Si usted es un fan de los juegos de zombies, es posible que desee echa un vistazo a Ciudad Muerta Zombie invasión APK, un emocionante juego de supervivencia para dispositivos Android. En este juego, tendrás que luchar contra hordas de zombies que se han apoderado de la ciudad después de un brote de virus. Tendrás que usar varias armas y equipos para defenderte a ti mismo y a tus aliados, así como explorar diferentes lugares y completar misiones. Aquí está todo lo que necesitas saber sobre Dead City Zombie invasión APK, incluyendo sus características, cómo descargarlo e instalarlo, y algunos consejos y trucos para jugarlo. </p>
-<h2>ai apk</h2><br /><p><b><b>Download Zip</b> &#8250; <a href="https://bltlly.com/2v6K3c">https://bltlly.com/2v6K3c</a></b></p><br /><br />
- <h2>Introducción</h2>
-<h3> ¿Qué es la ciudad muerta invasión zombi APK? </h3>
-<p>Ciudad muerta invasión zombi APK es un juego de disparos zombie lleno de acción desarrollado por Charm Tech. Está disponible de forma gratuita en la Google Play Store, pero también puede descargar el archivo APK de otras fuentes si desea acceder a algunas características adicionales. El juego tiene una calificación de 4.4 de 5 estrellas en la Play Store, con más de 10 millones de descargas y comentarios positivos de los jugadores. </p>
- <h3> ¿Por qué deberías jugar Ciudad muerta invasión zombi APK? </h3>
-<p>Ciudad muerta invasión zombi APK es un juego que te mantendrá en el borde de su asiento como te enfrentas a interminables olas de zombies que tienen hambre de su carne. Tendrás que usar tus habilidades y estrategia para sobrevivir en este mundo post-apocalíptico, donde cada decisión importa. También disfrutarás de los siguientes beneficios cuando juegas Dead City Zombie invasión APK:</p>
-<ul>
-<li>Experimentarás un juego realista e inmersivo, con impresionantes gráficos y efectos de sonido que te harán sentir como si estuvieras en medio de un apocalipsis zombi. </li>
-<li>Usted tendrá acceso a una variedad de armas y equipos, tales como pistolas, rifles, escopetas, granadas, cuchillos, armaduras y más. También puedes mejorar tus armas y habilidades para mejorar tu rendimiento. </li>
-
-<li>Te divertirás explorando diferentes lugares y escenarios, como calles, edificios, metros, fábricas y más. También encontrarás diferentes tipos de zombies, como caminantes, corredores, saltadores, bombarderos y más. </li>
-</ul>
- <h2>Características de la ciudad muerta invasión zombi APK</h2>
-<h3>Varias armas y equipos</h3>
-<p>Una de las principales características de Ciudad Muerta Zombie invasión APK es la amplia gama de armas y equipos que se pueden utilizar para luchar contra los zombies. Puedes elegir entre pistolas, rifles, escopetas, granadas, cuchillos, armaduras y más. Cada arma tiene sus propias ventajas y desventajas, como daños, alcance, precisión, velocidad de recarga y capacidad de munición. También puedes mejorar tus armas y habilidades para hacerlas más poderosas y efectivas. </p>
- <h3>Diferentes modos y niveles</h3>
-<p>Otra característica de la ciudad muerta invasión zombi APK es los diferentes modos y niveles que se pueden jugar. Puedes elegir entre el modo historia, el modo supervivencia, el modo jefe y el modo desafío. Cada modo tiene sus propios objetivos y dificultades, como matar a un cierto número de zombies, sobrevivir durante un tiempo determinado, derrotar a un jefe zombi o completar una tarea específica. También puedes jugar con tus amigos online o offline en modo multijugador. </p>
- <h3>Impresionantes gráficos y efectos de sonido</h3>
-<p>Una tercera característica de Ciudad Muerta Zombie invasión APK es la impresionante gráficos y efectos de sonido que hacen que el juego más realista e inmersiva. Te sentirás como si estuvieras en medio de un apocalipsis zombi, con entornos detallados, animaciones realistas y efectos de sangre. También escuchará los sonidos de disparos, explosiones, gemidos de zombis y gritos que se sumarán a la tensión y la emoción del juego. </p>
-<p></p>
- <h2> ¿Cómo descargar e instalar Ciudad Muerta Zombie invasión APK? </h2>
-<h3>Descargar el archivo APK de una fuente de confianza</h3>
-
-<p><a href="">Descargar Ciudad Muerta Zombie invasión APK aquí</a></p>
- <h3>Habilitar fuentes desconocidas en su dispositivo</h3>
-<p>Antes de poder instalar el archivo APK, tendrá que habilitar fuentes desconocidas en su dispositivo. Esto le permitirá instalar aplicaciones que no son de Google Play Store. Para habilitar fuentes desconocidas, siga estos pasos:</p>
-<ol>
-<li>Ir a la configuración de su dispositivo y toque en la seguridad o la privacidad. </li>
-<li>Encontrar la opción que dice fuentes desconocidas o instalar aplicaciones desconocidas y alternar en. </li>
-<li>Confirme su elección tocando en OK o Permitir.</li>
-</ol>
- <h3>Instalar el archivo APK y lanzar el juego</h3>
-<p>Después de haber habilitado fuentes desconocidas, puede instalar el archivo APK y lanzar el juego. Para hacer esto, siga estos pasos:</p>
-<ol>
-<li>Busque el archivo APK que ha descargado y toque en él. </li>
-<li>Siga las instrucciones en la pantalla y toque en Instalar.</li>
-<li>Espere a que termine el proceso de instalación y toque en Abrir.</li>
-<li> Disfruta jugando Ciudad muerta invasión zombi APK! </li>
-</ol>
- <h2> Consejos y trucos para jugar Ciudad muerta invasión zombi APK</h2>
-<h3>Mejora tus armas y habilidades</h3>
-<p>Uno de los consejos para jugar Ciudad Muerta Zombie invasión APK es mejorar sus armas y habilidades tanto como sea posible. Esto te ayudará a hacer más daño, sobrevivir más tiempo y completar misiones más rápido. Puedes mejorar tus armas y habilidades usando monedas y gemas que puedes ganar jugando el juego o viendo anuncios. También puedes comprar monedas y gemas con dinero real si quieres acelerar el proceso. </p>
- <h3>Apunta a la cabeza y usa granadas</h3>
-<p>Otro consejo para jugar Ciudad Muerta Zombie invasión APK es apuntar a la cabeza y utilizar granadas cuando se lucha contra zombies. Apuntar a la cabeza hará más daño y ahorrará munición, mientras que el uso de granadas causará daño en el área y aturdirá a los zombies. También puedes usar otros artículos, como botiquines, cajas de munición y torretas, para ayudarte en el combate. </p>
- <h3>Recopilar recursos y elementos</h3>
-
- <h2>Conclusión</h2>
-<p>Ciudad muerta invasión zombi APK es un juego de supervivencia para dispositivos Android que le desafiará a luchar contra hordas de zombies en un mundo post-apocalíptico. Tendrás que usar varias armas y equipos para defenderte a ti mismo y a tus aliados, así como explorar diferentes lugares y completar misiones. También podrá disfrutar de la jugabilidad realista e inmersiva, con impresionantes gráficos y efectos de sonido. Si usted está buscando un emocionante juego de disparos zombie, usted debe descargar e instalar Ciudad Muerta Zombie invasión APK hoy! </p>
- <h2>Preguntas frecuentes</h2>
-<p>Aquí están algunas de las preguntas más frecuentes sobre Ciudad Muerta Zombie invasión APK:</p>
- <h4> ¿Es seguro descargar Ciudad muerta invasión zombi APK? </h4>
-<p>Sí, Ciudad muerta invasión zombi APK es seguro de descargar, siempre y cuando lo obtenga de una fuente de confianza. Sin embargo, siempre debe tener cuidado al descargar cualquier aplicación de fuentes desconocidas, ya que pueden contener virus o malware que pueden dañar su dispositivo. </p>
- <h4> ¿Es la ciudad muerta invasión zombi APK libre para jugar? </h4>
-<p>Sí, Ciudad muerta invasión zombi APK es libre de jugar, pero contiene anuncios y compras en la aplicación que pueden mejorar su experiencia de juego. Puedes desactivar los anuncios desactivando tu conexión a Internet o comprando la versión sin anuncios del juego. También puedes comprar monedas y gemas con dinero real si quieres mejorar tus armas y habilidades más rápido. </p>
- <h4> ¿Cómo puedo jugar con mis amigos en línea o fuera de línea en la ciudad muerta invasión zombi APK? </h4>
-
- <h4> ¿Cuáles son los requisitos mínimos para jugar Ciudad muerta invasión zombi APK? </h4>
-<p>Los requisitos mínimos para jugar Ciudad muerta invasión zombi APK son los siguientes:</p>
-<ul>
-<li>Versión para Android: 4.4 o superior</li>
-<li>RAM: 2 GB o más</li>
-<li>Espacio de almacenamiento: 300 MB o más</li>
-<li>Conexión a Internet: opcional (requerido para multijugador y anuncios en línea)</li>
-</ul>
- <h4>¿Cómo puedo contactar con el desarrollador de Dead City Zombie invasión APK? </h4>
-<p>Si usted tiene alguna pregunta, retroalimentación, o sugerencias acerca de Ciudad Muerta Zombie invasión APK, puede ponerse en contacto con el desarrollador mediante el uso de los siguientes métodos:</p>
-<ul>
-<li>Correo electrónico: [email protected]</li>
-<li>Facebook: https://www.facebook.com/charmtechgames</li>
-<li>Twitter: https://twitter.com/charmtechgames</li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Gratis Fuego Mx Apk 45 Mb.md

@@ -1,79 +0,0 @@
-<br />
-<h1>Free Fire MAX: Cómo descargar el archivo APK en 45 MB</h1>
-<p>Si eres un fan de los juegos battle royale, es posible que hayas oído hablar de <strong>Free Fire MAX</strong>, una nueva versión del popular juego <strong>Free Fire</strong> que ofrece gráficos mejorados, jugabilidad y compatibilidad. En este artículo, le diremos todo lo que necesita saber sobre Free Fire MAX, incluyendo cómo descargar el archivo APK en solo 45 MB. ¡Sigue leyendo para saber más! </p>
- <h2>¿Qué es Free Fire MAX? </h2>
-<p>Free Fire MAX es un juego de disparos desarrollado por Garena International que está diseñado exclusivamente para ofrecer una experiencia de juego premium en una batalla real. Se basa en el mismo juego central que Free Fire, pero con características mejoradas como:</p>
-<h2>descargar gratis fuego máx apk 45 mb</h2><br /><p><b><b>Download</b> &#10003;&#10003;&#10003; <a href="https://bltlly.com/2v6IOK">https://bltlly.com/2v6IOK</a></b></p><br /><br />
-<ul>
-<li><strong>Resoluciones ultra HD</strong> que hacen el juego más realista e inmersivo</li>
-<li><strong>Efectos impresionantes</strong> que mejoran la experiencia de combate</li>
-<li><strong>Contenido exclusivo</strong> que solo está disponible en Free Fire MAX</li>
-<li><strong>Tecnología Firelink</strong> que te permite jugar con otros jugadores de Free Fire a través de la compatibilidad multiplataforma</li>
-</ul>
-<p>Free Fire MAX está actualmente disponible en determinadas regiones, pero se puede descargar desde cualquier lugar utilizando un archivo APK. Te mostraremos cómo hacerlo en la siguiente sección. </p>
- <h2>¿Cuáles son los beneficios de jugar Free Fire MAX? </h2>
-<p>Si te estás preguntando por qué deberías jugar Free Fire MAX en lugar de Free Fire, estos son algunos de los beneficios que puedes disfrutar:</p>
-<ul>
-<li><strong>Mejores gráficos</strong>: Free Fire MAX tiene gráficos en HD que son más detallados y vibrantes que Free Fire. Puedes ver cada textura, sombra y reflejo en el mundo del juego. También puede personalizar la configuración de gráficos de acuerdo con las especificaciones y preferencias del dispositivo. </li>
-
-<li><strong>Mejor compatibilidad</strong>: Free Fire MAX es compatible con más dispositivos que Free Fire. Puede reproducirlo en dispositivos de gama baja, así como en dispositivos de gama alta con un mejor rendimiento. También se puede jugar en PC o Mac utilizando un emulador de Android. También puedes jugar con otros jugadores de Free Fire usando la tecnología Firelink, que explicaremos más adelante. </li>
-</ul>
-<p>Como puedes ver, Free Fire MAX tiene muchas ventajas sobre Free Fire. Si quieres experimentar el juego por ti mismo, tendrás que descargar el archivo APK, que es un pequeño archivo que contiene los datos del juego. Así es como puedes hacerlo en tan solo 45 MB.</p>
- <h2> ¿Cómo descargar el archivo APK Free Fire MAX en 45 MB? </h2>
-<p>Para descargar el archivo APK Free Fire MAX en 45 MB, tendrá que seguir estos sencillos pasos:</p>
- <h3>Paso 1: Habilitar fuentes desconocidas en el dispositivo</h3>
-<p>Antes de poder instalar el archivo APK, tendrá que permitir que su dispositivo instale aplicaciones desde fuentes distintas de Google Play Store. Para ello, vaya a la configuración del dispositivo y busque la opción de seguridad o privacidad. Luego, habilite la opción de fuentes desconocidas. Esto le permitirá instalar aplicaciones de sitios web de terceros. </p>
- <h3>Paso 2: Descargar el archivo APK de una fuente de confianza</h3>
-<p>Siguiente, tendrá que encontrar y descargar el archivo APK de un sitio web confiable. Hay muchos sitios web que ofrecen archivos APK para varios juegos y aplicaciones, pero no todos ellos son seguros y protegidos. Algunos de ellos pueden contener malware o virus que pueden dañar su dispositivo o robar sus datos. Por lo tanto, solo debe descargar el archivo APK de una fuente de confianza, como <a href="">APKPure</a> o <a href="">APKMirror</a>. Estos sitios web son verificados y probados por millones de usuarios y proporcionan las versiones más recientes y actualizadas de los archivos APK. </p>
-<p></p>
-
- <h3>Paso 3: Instalar el archivo APK en su dispositivo</h3>
-<p>Una vez que haya descargado el archivo APK, tendrá que instalarlo en su dispositivo. Para ello, localice el archivo APK en el almacenamiento del dispositivo y toque en él. Verá un mensaje pidiéndole que confirme la instalación. Toque en instalar y espere unos segundos hasta que se complete la instalación. </p>
- <h3>Paso 4: Iniciar el juego y disfrutar de</h3>
-<p>Después de instalar el archivo APK, puede iniciar el juego tocando en su icono en la pantalla de inicio o cajón de aplicaciones. Verá una pantalla de carga que descargará los datos adicionales del juego, lo que puede tardar algún tiempo dependiendo de su velocidad de Internet. Una vez completada la descarga, puede iniciar sesión con su cuenta de Free Fire existente o crear una nueva. También puedes vincular tu cuenta de Facebook o Google para guardar tu progreso y sincronizar tus datos entre dispositivos. </p>
-<p>Ahora, puedes disfrutar jugando Free Fire MAX con gráficos mejorados, jugabilidad y compatibilidad. También puedes jugar con otros jugadores de Free Fire usando la tecnología Firelink, que explicaremos en la siguiente sección. </p>
- <h2>¿Cómo se juega Free Fire MAX con otros jugadores de Free Fire? </h2>
-<p>Una de las mejores características de Free Fire MAX es que te permite jugar con otros jugadores de Free Fire usando la tecnología <strong>Firelink</strong>. Esta es una tecnología multiplataforma que conecta a los jugadores a través de ambas versiones del juego. Esto significa que puedes jugar con tus amigos y compañeros de equipo que están usando Free Fire o Free Fire MAX sin ningún problema. </p>
-<p>Para utilizar esta función, tendrá que activarla en la configuración del juego. Vaya a la configuración y busque la opción Firelink. Luego, enciéndelo y escanea el código QR que aparece en tu pantalla. Esto vinculará tu cuenta con tu dispositivo y te permitirá jugar con otros jugadores usando cualquiera de las versiones del juego. </p>
-
- <h2>¿Cómo optimizar tu experiencia Free Fire MAX? </h2>
-<p>Si quieres aprovechar al máximo tu experiencia Free Fire MAX, aquí hay algunos consejos y trucos que puedes usar:</p>
- <h3>Consejo 1: Ajusta la configuración de tus gráficos según las especificaciones de tu dispositivo</h3>
-<p>Free Fire MAX tiene gráficos increíbles que hacen que el juego sea más realista e inmersivo. Sin embargo, no todos los dispositivos pueden manejar la configuración de gráficos altos sin afectar el rendimiento o la duración de la batería. Por lo tanto, debe ajustar la configuración de los gráficos de acuerdo con las especificaciones y preferencias del dispositivo. </p>
-<p>Para hacer esto, vaya a la configuración y busque la opción de gráficos. Verá un control deslizante que le permite elegir entre ajustes de gráficos bajos, medios, altos y ultra. También puede personalizar la configuración de sus gráficos cambiando la resolución, la velocidad de fotogramas, las sombras, el anti-aliasing y la calidad de la textura. También puedes activar o desactivar el modo HDR, que mejora el color y el contraste del juego. </p>
-<p>Deberías experimentar con diferentes configuraciones gráficas hasta que encuentres la que se adapte a tu dispositivo y a tu gusto. También puede comprobar la temperatura del dispositivo y el nivel de batería para ver cuánto impacto tienen los ajustes gráficos en el dispositivo. </p>
- <h3>Consejo 2: Utilice una conexión a Internet estable y un buen servicio VPN</h3>
-<p>Free Fire MAX es un juego en línea que requiere una conexión a Internet estable para jugar sin problemas y sin interrupciones. Si tiene una conexión a Internet lenta o inestable, puede experimentar retraso, desconexión u otros problemas que pueden arruinar su experiencia de juego. Por lo tanto, debe utilizar una conexión a Internet rápida y confiable para jugar Free Fire MAX. </p>
-
-<p>Un servicio VPN es un software que puede cifrar el tráfico de Internet y enrutarlo a través de un servidor en otro país. De esta manera, puedes evitar cualquier restricción geográfica o censura que pueda impedirte jugar a Free Fire MAX. También puede disfrutar de un acceso a Internet más rápido y seguro con un servicio VPN. </p>
-<p>Hay muchos servicios VPN disponibles en línea, pero no todos son seguros y efectivos. Algunos de ellos pueden contener malware o spyware que pueden dañar su dispositivo o robar sus datos. Algunos de ellos también pueden ralentizar su velocidad de Internet o filtrar su dirección IP. Por lo tanto, solo debe usar un servicio VPN confiable y de buena reputación, como <a href="">NordVPN</a> o <a href="">ExpressVPN</a>. Estos servicios VPN son verificados y probados por millones de usuarios y proporcionan servidores VPN rápidos y seguros en varios países. </p>
-<p>Para usar un servicio VPN para jugar a Free Fire MAX, tendrá que descargar e instalar la aplicación VPN en su dispositivo. Luego, tendrás que crear una cuenta y elegir una ubicación de servidor compatible con el juego. Por ejemplo, si quieres jugar a Free Fire MAX en India, puedes elegir un servidor en India. Luego, deberá conectarse al servidor VPN y lanzar el juego. Verás que puedes acceder a los servidores y características del juego sin ningún problema. </p>
- <h3>Consejo 3: Utilice BlueStacks para jugar Free Fire MAX en PC o Mac</h3>
-<p>Si quieres jugar Free Fire MAX en una pantalla más grande con mejores controles y rendimiento, puedes usar BlueStacks, un emulador de Android que te permite jugar juegos de Android en PC o Mac. BlueStacks es uno de los mejores emuladores de Android disponibles en línea, ya que tiene muchas características que lo hacen ideal para jugar Free Fire MAX, como:</p>
-<ul>
-
-<li><strong>Controles inteligentes</strong>: BlueStacks tiene controles inteligentes que detectan automáticamente cuando estás en combate o en menús y cambian entre los controles del teclado y el ratón en consecuencia. De esta manera, puedes jugar el juego con facilidad y eficiencia. </li>
-<li><strong>Grabadora de macros</strong>: BlueStacks tiene una grabadora de macros que le permite grabar y reproducir cualquier acción o secuencia de acciones en el juego con una sola pulsación. De esta manera, puedes automatizar tareas como saquear, curar, recargar o usar habilidades. </li>
-<li><strong>Eco mode</strong>: BlueStacks tiene un modo eco que reduce el uso de CPU y RAM del emulador cuando se ejecuta en segundo plano. De esta manera, puede guardar los recursos del dispositivo y la duración de la batería mientras juega Free Fire MAX. </li>
-</ul>
-<p>Para usar BlueStacks para jugar Free Fire MAX en PC o Mac, tendrá que descargar e instalar BlueStacks en su computadora desde su sitio web oficial <a href="">aquí</a>. Luego, tendrás que iniciar sesión con tu cuenta de Google y buscar Free Fire MAX en Google Play Store. También puede descargar el archivo APK de los sitios web mencionados anteriormente e instalarlo en BlueStacks. Luego, puedes iniciar el juego e iniciar sesión con tu cuenta de Free Fire o crear una nueva. También puede personalizar los controles del teclado y del ratón según sus preferencias. </p>
-<p>Ahora, puedes disfrutar jugando Free Fire MAX en PC o Mac con BlueStacks y experimentar el juego de una manera completamente nueva. </p>
- <h2>Conclusión</h2>
-<p>Free Fire MAX es un gran juego para cualquiera que ame los juegos battle royale y quiera experimentarlos con mejores gráficos, jugabilidad y compatibilidad. Puede descargar el archivo APK en solo 45 MB e instalarlo en su dispositivo fácilmente. También puedes jugar con otros jugadores de Free Fire usando la tecnología Firelink y cambiar entre ambas versiones del juego sin perder tu progreso o datos. También puede usar un servicio VPN para acceder al juego desde cualquier región y usar BlueStacks para jugar el juego en PC o Mac.</p>
-
- <h2>Preguntas frecuentes</h2>
-<p>Aquí están algunas de las preguntas y respuestas más frecuentes sobre Free Fire MAX:</p>
-<ul>
-<li><strong>Q: ¿Free Fire MAX es libre para jugar? </strong></li>
-<li><strong>A: Sí, Free Fire MAX es gratis para jugar y descargar. Sin embargo, puede contener compras en la aplicación que requieren dinero real. </strong></li>
-<li><strong>Q: ¿Es seguro descargar e instalar Free Fire MAX? </strong></li>
-<li><strong>A: Sí, Free Fire MAX es seguro para descargar e instalar siempre y cuando utilice una fuente de confianza como Google Play Store o APKPure. También debe habilitar fuentes desconocidas en su dispositivo antes de instalar el archivo APK. </strong></li>
-<li><strong>Q: ¿Cuáles son los requisitos mínimos para jugar Free Fire MAX? </strong></li>
-<li><strong>A: Los requisitos mínimos para jugar Free Fire MAX son Android 4.4 o superior, 2 GB de RAM y 1.5 GB de espacio de almacenamiento libre. </strong></li>
-<li><strong>Q: ¿Puedo jugar Free Fire MAX sin conexión? </strong></li>
-<li><strong>A: No, Free Fire MAX es un juego en línea que requiere una conexión a Internet para jugar. También debe usar una conexión a Internet estable y un buen servicio VPN para evitar retrasos, desconexiones o restricciones geográficas. </strong></li>
-<li><strong>Q: ¿Puedo jugar Free Fire MAX con mis amigos? </strong></li>
-<li><strong>A: Sí, puedes jugar a Free Fire MAX con tus amigos usando la tecnología Firelink que conecta a los jugadores en ambas versiones del juego. También puedes usar BlueStacks para jugar Free Fire MAX en PC o Mac con tus amigos. </strong></li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/boto3/dynamodb/__init__.py

@@ -1,12 +0,0 @@
-# Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"). You
-# may not use this file except in compliance with the License. A copy of
-# the License is located at
-#
-# https://aws.amazon.com/apache2.0/
-#
-# or in the "license" file accompanying this file. This file 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.

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

@@ -1,34 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class Pager(ABC):
-    """Base class for a pager."""
-
-    @abstractmethod
-    def show(self, content: str) -> None:
-        """Show content in pager.
-
-        Args:
-            content (str): Content to be displayed.
-        """
-
-
-class SystemPager(Pager):
-    """Uses the pager installed on the system."""
-
-    def _pager(self, content: str) -> Any:  #  pragma: no cover
-        return __import__("pydoc").pager(content)
-
-    def show(self, content: str) -> None:
-        """Use the same pager used by pydoc."""
-        self._pager(content)
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from .__main__ import make_test_card
-    from .console import Console
-
-    console = Console()
-    with console.pager(styles=True):
-        console.print(make_test_card())

spaces/Big-Web/MMSD/env/Lib/site-packages/pkg_resources/_vendor/packaging/__about__.py

@@ -1,26 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-__all__ = [
-    "__title__",
-    "__summary__",
-    "__uri__",
-    "__version__",
-    "__author__",
-    "__email__",
-    "__license__",
-    "__copyright__",
-]
-
-__title__ = "packaging"
-__summary__ = "Core utilities for Python packages"
-__uri__ = "https://github.com/pypa/packaging"
-
-__version__ = "21.3"
-
-__author__ = "Donald Stufft and individual contributors"
-__email__ = "[email protected]"
-
-__license__ = "BSD-2-Clause or Apache-2.0"
-__copyright__ = "2014-2019 %s" % __author__

spaces/Bl1tzie/Jam/server.js

@@ -1,32 +0,0 @@
-const express = require('express');
-const proxy = require('express-http-proxy');
-const app = express();
-const targetUrl = 'https://api.openai.com';
-const openaiKey = process.env.OPENAI_KEY
-const port = 7860;
-const baseUrl = getExternalUrl(process.env.SPACE_ID);
-
-app.use('/api', proxy(targetUrl, {
-  proxyReqOptDecorator: (proxyReqOpts, srcReq) => {
-    // Modify the request headers if necessary
-    proxyReqOpts.headers['Authorization'] = 'Bearer '+openaiKey;
-    return proxyReqOpts;
-  },
-}));
-
-app.get("/", (req, res) => {
-  res.send(`This is your OpenAI Reverse Proxy URL: ${baseUrl}`);
-});
-
-function getExternalUrl(spaceId) {
-  try {
-    const [username, spacename] = spaceId.split("/");
-    return `https://${username}-${spacename.replace(/_/g, "-")}.hf.space/api/v1`;
-  } catch (e) {
-    return "";
-  }
-}
-
-app.listen(port, () => {
-  console.log(`Reverse proxy server running on ${baseUrl}`);
-});

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/tools/deploy/caffe2_mask_rcnn.cpp

@@ -1,116 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-#include <c10/util/Flags.h>
-#include <caffe2/core/blob.h>
-#include <caffe2/core/common.h>
-#include <caffe2/core/init.h>
-#include <caffe2/core/net.h>
-#include <caffe2/core/workspace.h>
-#include <caffe2/utils/proto_utils.h>
-
-#include <opencv2/opencv.hpp>
-#include <cassert>
-#include <chrono>
-#include <iostream>
-#include <string>
-
-C10_DEFINE_string(predict_net, "", "path to model.pb");
-C10_DEFINE_string(init_net, "", "path to model_init.pb");
-C10_DEFINE_string(input, "", "path to input image");
-
-using namespace std;
-using namespace caffe2;
-
-int main(int argc, char** argv) {
-  caffe2::GlobalInit(&argc, &argv);
-  string predictNetPath = FLAGS_predict_net;
-  string initNetPath = FLAGS_init_net;
-  cv::Mat input = cv::imread(FLAGS_input, cv::IMREAD_COLOR);
-
-  const int height = input.rows;
-  const int width = input.cols;
-  // FPN models require divisibility of 32
-  assert(height % 32 == 0 && width % 32 == 0);
-  const int batch = 1;
-  const int channels = 3;
-
-  // initialize Net and Workspace
-  caffe2::NetDef initNet_, predictNet_;
-  CAFFE_ENFORCE(ReadProtoFromFile(initNetPath, &initNet_));
-  CAFFE_ENFORCE(ReadProtoFromFile(predictNetPath, &predictNet_));
-
-  Workspace workSpace;
-  for (auto& str : predictNet_.external_input()) {
-    workSpace.CreateBlob(str);
-  }
-  CAFFE_ENFORCE(workSpace.CreateNet(predictNet_));
-  CAFFE_ENFORCE(workSpace.RunNetOnce(initNet_));
-
-  // setup inputs
-  auto data = BlobGetMutableTensor(workSpace.GetBlob("data"), caffe2::CPU);
-  data->Resize(batch, channels, height, width);
-  float* ptr = data->mutable_data<float>();
-  // HWC to CHW
-  for (int c = 0; c < 3; ++c) {
-    for (int i = 0; i < height * width; ++i) {
-      ptr[c * height * width + i] = static_cast<float>(input.data[3 * i + c]);
-    }
-  }
-
-  auto im_info =
-      BlobGetMutableTensor(workSpace.GetBlob("im_info"), caffe2::CPU);
-  im_info->Resize(batch, 3);
-  float* im_info_ptr = im_info->mutable_data<float>();
-  im_info_ptr[0] = height;
-  im_info_ptr[1] = width;
-  im_info_ptr[2] = 1.0;
-
-  // run the network
-  CAFFE_ENFORCE(workSpace.RunNet(predictNet_.name()));
-
-  // run 3 more times to benchmark
-  int N_benchmark = 3;
-  auto start_time = chrono::high_resolution_clock::now();
-  for (int i = 0; i < N_benchmark; ++i) {
-    CAFFE_ENFORCE(workSpace.RunNet(predictNet_.name()));
-  }
-  auto end_time = chrono::high_resolution_clock::now();
-  auto ms = std::chrono::duration_cast<std::chrono::microseconds>(
-                end_time - start_time)
-                .count();
-  cout << "Latency: " << ms * 1.0 / 1e6 / N_benchmark << " seconds" << endl;
-
-  // parse Mask R-CNN outputs
-  auto& bbox = BlobGetTensor(*workSpace.GetBlob("bbox_nms"), caffe2::CPU);
-  auto& scores = BlobGetTensor(*workSpace.GetBlob("score_nms"), caffe2::CPU);
-  auto& labels = BlobGetTensor(*workSpace.GetBlob("class_nms"), caffe2::CPU);
-  auto& mask_probs =
-      BlobGetTensor(*workSpace.GetBlob("mask_fcn_probs"), caffe2::CPU);
-  cout << "bbox:" << bbox.DebugString() << endl;
-  cout << "scores:" << scores.DebugString() << endl;
-  cout << "labels:" << labels.DebugString() << endl;
-  cout << "mask_probs: " << mask_probs.DebugString() << endl;
-
-  int num_instances = bbox.sizes()[0];
-  for (int i = 0; i < num_instances; ++i) {
-    float score = scores.data<float>()[i];
-    if (score < 0.6)
-      continue; // skip them
-
-    const float* box = bbox.data<float>() + i * 4;
-    int label = labels.data<float>()[i];
-
-    cout << "Prediction " << i << ", xyxy=(";
-    cout << box[0] << ", " << box[1] << ", " << box[2] << ", " << box[3]
-         << "); score=" << score << "; label=" << label << endl;
-
-    const float* mask = mask_probs.data<float>() +
-        i * mask_probs.size_from_dim(1) + label * mask_probs.size_from_dim(2);
-
-    // save the 28x28 mask
-    cv::Mat cv_mask(28, 28, CV_32FC1);
-    memcpy(cv_mask.data, mask, 28 * 28 * sizeof(float));
-    cv::imwrite("mask" + std::to_string(i) + ".png", cv_mask * 255.);
-  }
-  return 0;
-}

spaces/CVPR/GFPGAN-example/tests/test_gfpgan_arch.py

@@ -1,203 +0,0 @@
-import torch
-
-from gfpgan.archs.gfpganv1_arch import FacialComponentDiscriminator, GFPGANv1, StyleGAN2GeneratorSFT
-from gfpgan.archs.gfpganv1_clean_arch import GFPGANv1Clean, StyleGAN2GeneratorCSFT
-
-
-def test_stylegan2generatorsft():
-    """Test arch: StyleGAN2GeneratorSFT."""
-
-    # model init and forward (gpu)
-    if torch.cuda.is_available():
-        net = StyleGAN2GeneratorSFT(
-            out_size=32,
-            num_style_feat=512,
-            num_mlp=8,
-            channel_multiplier=1,
-            resample_kernel=(1, 3, 3, 1),
-            lr_mlp=0.01,
-            narrow=1,
-            sft_half=False).cuda().eval()
-        style = torch.rand((1, 512), dtype=torch.float32).cuda()
-        condition1 = torch.rand((1, 512, 8, 8), dtype=torch.float32).cuda()
-        condition2 = torch.rand((1, 512, 16, 16), dtype=torch.float32).cuda()
-        condition3 = torch.rand((1, 512, 32, 32), dtype=torch.float32).cuda()
-        conditions = [condition1, condition1, condition2, condition2, condition3, condition3]
-        output = net([style], conditions)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert output[1] is None
-
-        # -------------------- with return_latents ----------------------- #
-        output = net([style], conditions, return_latents=True)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert len(output[1]) == 1
-        # check latent
-        assert output[1][0].shape == (8, 512)
-
-        # -------------------- with randomize_noise = False ----------------------- #
-        output = net([style], conditions, randomize_noise=False)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert output[1] is None
-
-        # -------------------- with truncation = 0.5 and mixing----------------------- #
-        output = net([style, style], conditions, truncation=0.5, truncation_latent=style)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert output[1] is None
-
-
-def test_gfpganv1():
-    """Test arch: GFPGANv1."""
-
-    # model init and forward (gpu)
-    if torch.cuda.is_available():
-        net = GFPGANv1(
-            out_size=32,
-            num_style_feat=512,
-            channel_multiplier=1,
-            resample_kernel=(1, 3, 3, 1),
-            decoder_load_path=None,
-            fix_decoder=True,
-            # for stylegan decoder
-            num_mlp=8,
-            lr_mlp=0.01,
-            input_is_latent=False,
-            different_w=False,
-            narrow=1,
-            sft_half=True).cuda().eval()
-        img = torch.rand((1, 3, 32, 32), dtype=torch.float32).cuda()
-        output = net(img)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert len(output[1]) == 3
-        # check out_rgbs for intermediate loss
-        assert output[1][0].shape == (1, 3, 8, 8)
-        assert output[1][1].shape == (1, 3, 16, 16)
-        assert output[1][2].shape == (1, 3, 32, 32)
-
-        # -------------------- with different_w = True ----------------------- #
-        net = GFPGANv1(
-            out_size=32,
-            num_style_feat=512,
-            channel_multiplier=1,
-            resample_kernel=(1, 3, 3, 1),
-            decoder_load_path=None,
-            fix_decoder=True,
-            # for stylegan decoder
-            num_mlp=8,
-            lr_mlp=0.01,
-            input_is_latent=False,
-            different_w=True,
-            narrow=1,
-            sft_half=True).cuda().eval()
-        img = torch.rand((1, 3, 32, 32), dtype=torch.float32).cuda()
-        output = net(img)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert len(output[1]) == 3
-        # check out_rgbs for intermediate loss
-        assert output[1][0].shape == (1, 3, 8, 8)
-        assert output[1][1].shape == (1, 3, 16, 16)
-        assert output[1][2].shape == (1, 3, 32, 32)
-
-
-def test_facialcomponentdiscriminator():
-    """Test arch: FacialComponentDiscriminator."""
-
-    # model init and forward (gpu)
-    if torch.cuda.is_available():
-        net = FacialComponentDiscriminator().cuda().eval()
-        img = torch.rand((1, 3, 32, 32), dtype=torch.float32).cuda()
-        output = net(img)
-        assert len(output) == 2
-        assert output[0].shape == (1, 1, 8, 8)
-        assert output[1] is None
-
-        # -------------------- return intermediate features ----------------------- #
-        output = net(img, return_feats=True)
-        assert len(output) == 2
-        assert output[0].shape == (1, 1, 8, 8)
-        assert len(output[1]) == 2
-        assert output[1][0].shape == (1, 128, 16, 16)
-        assert output[1][1].shape == (1, 256, 8, 8)
-
-
-def test_stylegan2generatorcsft():
-    """Test arch: StyleGAN2GeneratorCSFT."""
-
-    # model init and forward (gpu)
-    if torch.cuda.is_available():
-        net = StyleGAN2GeneratorCSFT(
-            out_size=32, num_style_feat=512, num_mlp=8, channel_multiplier=1, narrow=1, sft_half=False).cuda().eval()
-        style = torch.rand((1, 512), dtype=torch.float32).cuda()
-        condition1 = torch.rand((1, 512, 8, 8), dtype=torch.float32).cuda()
-        condition2 = torch.rand((1, 512, 16, 16), dtype=torch.float32).cuda()
-        condition3 = torch.rand((1, 512, 32, 32), dtype=torch.float32).cuda()
-        conditions = [condition1, condition1, condition2, condition2, condition3, condition3]
-        output = net([style], conditions)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert output[1] is None
-
-        # -------------------- with return_latents ----------------------- #
-        output = net([style], conditions, return_latents=True)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert len(output[1]) == 1
-        # check latent
-        assert output[1][0].shape == (8, 512)
-
-        # -------------------- with randomize_noise = False ----------------------- #
-        output = net([style], conditions, randomize_noise=False)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert output[1] is None
-
-        # -------------------- with truncation = 0.5 and mixing----------------------- #
-        output = net([style, style], conditions, truncation=0.5, truncation_latent=style)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert output[1] is None
-
-
-def test_gfpganv1clean():
-    """Test arch: GFPGANv1Clean."""
-
-    # model init and forward (gpu)
-    if torch.cuda.is_available():
-        net = GFPGANv1Clean(
-            out_size=32,
-            num_style_feat=512,
-            channel_multiplier=1,
-            decoder_load_path=None,
-            fix_decoder=True,
-            # for stylegan decoder
-            num_mlp=8,
-            input_is_latent=False,
-            different_w=False,
-            narrow=1,
-            sft_half=True).cuda().eval()
-
-        img = torch.rand((1, 3, 32, 32), dtype=torch.float32).cuda()
-        output = net(img)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert len(output[1]) == 3
-        # check out_rgbs for intermediate loss
-        assert output[1][0].shape == (1, 3, 8, 8)
-        assert output[1][1].shape == (1, 3, 16, 16)
-        assert output[1][2].shape == (1, 3, 32, 32)
-
-        # -------------------- with different_w = True ----------------------- #
-        net = GFPGANv1Clean(
-            out_size=32,
-            num_style_feat=512,
-            channel_multiplier=1,
-            decoder_load_path=None,
-            fix_decoder=True,
-            # for stylegan decoder
-            num_mlp=8,
-            input_is_latent=False,
-            different_w=True,
-            narrow=1,
-            sft_half=True).cuda().eval()
-        img = torch.rand((1, 3, 32, 32), dtype=torch.float32).cuda()
-        output = net(img)
-        assert output[0].shape == (1, 3, 32, 32)
-        assert len(output[1]) == 3
-        # check out_rgbs for intermediate loss
-        assert output[1][0].shape == (1, 3, 8, 8)
-        assert output[1][1].shape == (1, 3, 16, 16)
-        assert output[1][2].shape == (1, 3, 32, 32)

spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/set_operations.h

@@ -1,44 +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 fill 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>
-
-// the purpose of this header is to #include the set_operations.h header
-// of the sequential, host, and device systems. It should be #included in any
-// code which uses adl to dispatch set_operations
-
-#include <thrust/system/detail/sequential/set_operations.h>
-
-// SCons can't see through the #defines below to figure out what this header
-// includes, so we fake it out by specifying all possible files we might end up
-// including inside an #if 0.
-#if 0
-#include <thrust/system/cpp/detail/set_operations.h>
-#include <thrust/system/cuda/detail/set_operations.h>
-#include <thrust/system/omp/detail/set_operations.h>
-#include <thrust/system/tbb/detail/set_operations.h>
-#endif
-
-#define __THRUST_HOST_SYSTEM_SET_OPERATIONS_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/set_operations.h>
-#include __THRUST_HOST_SYSTEM_SET_OPERATIONS_HEADER
-#undef __THRUST_HOST_SYSTEM_SET_OPERATIONS_HEADER
-
-#define __THRUST_DEVICE_SYSTEM_SET_OPERATIONS_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/set_operations.h>
-#include __THRUST_DEVICE_SYSTEM_SET_OPERATIONS_HEADER
-#undef __THRUST_DEVICE_SYSTEM_SET_OPERATIONS_HEADER
-

spaces/CVPR/LIVE/thrust/thrust/system/tbb/detail/assign_value.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 assign_value
-#include <thrust/system/cpp/detail/assign_value.h>
-

spaces/CVPR/LIVE/thrust/thrust/system/tbb/detail/transform_reduce.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 transform_reduce
-#include <thrust/system/cpp/detail/transform_reduce.h>
-

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

@@ -1,25 +0,0 @@
-from .auto_augment import (AutoAugment, BrightnessTransform, ColorTransform,
-                           ContrastTransform, EqualizeTransform, Rotate, Shear,
-                           Translate)
-from .compose import Compose
-from .formating import (Collect, DefaultFormatBundle, ImageToTensor,
-                        ToDataContainer, ToTensor, Transpose, to_tensor)
-from .instaboost import InstaBoost
-from .loading import (LoadAnnotations, LoadImageFromFile, LoadImageFromWebcam,
-                      LoadMultiChannelImageFromFiles, LoadProposals)
-from .test_time_aug import MultiScaleFlipAug
-from .transforms import (Albu, CutOut, Expand, MinIoURandomCrop, Normalize,
-                         Pad, PhotoMetricDistortion, RandomCenterCropPad,
-                         RandomCrop, RandomFlip, Resize, SegRescale)
-
-__all__ = [
-    'Compose', 'to_tensor', 'ToTensor', 'ImageToTensor', 'ToDataContainer',
-    'Transpose', 'Collect', 'DefaultFormatBundle', 'LoadAnnotations',
-    'LoadImageFromFile', 'LoadImageFromWebcam',
-    'LoadMultiChannelImageFromFiles', 'LoadProposals', 'MultiScaleFlipAug',
-    'Resize', 'RandomFlip', 'Pad', 'RandomCrop', 'Normalize', 'SegRescale',
-    'MinIoURandomCrop', 'Expand', 'PhotoMetricDistortion', 'Albu',
-    'InstaBoost', 'RandomCenterCropPad', 'AutoAugment', 'CutOut', 'Shear',
-    'Rotate', 'ColorTransform', 'EqualizeTransform', 'BrightnessTransform',
-    'ContrastTransform', 'Translate'
-]

spaces/CVPR/WALT/mmdet/models/roi_heads/pisa_roi_head.py

@@ -1,159 +0,0 @@
-from mmdet.core import bbox2roi
-from ..builder import HEADS
-from ..losses.pisa_loss import carl_loss, isr_p
-from .standard_roi_head import StandardRoIHead
-
-
-@HEADS.register_module()
-class PISARoIHead(StandardRoIHead):
-    r"""The RoI head for `Prime Sample Attention in Object Detection
-    <https://arxiv.org/abs/1904.04821>`_."""
-
-    def forward_train(self,
-                      x,
-                      img_metas,
-                      proposal_list,
-                      gt_bboxes,
-                      gt_labels,
-                      gt_bboxes_ignore=None,
-                      gt_masks=None):
-        """Forward function for training.
-
-        Args:
-            x (list[Tensor]): List of multi-level img features.
-            img_metas (list[dict]): List of image info dict where each dict
-                has: 'img_shape', 'scale_factor', 'flip', and may also contain
-                'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
-                For details on the values of these keys see
-                `mmdet/datasets/pipelines/formatting.py:Collect`.
-            proposals (list[Tensors]): List of region proposals.
-            gt_bboxes (list[Tensor]): Each item are the truth boxes for each
-                image in [tl_x, tl_y, br_x, br_y] format.
-            gt_labels (list[Tensor]): Class indices corresponding to each box
-            gt_bboxes_ignore (list[Tensor], optional): Specify which bounding
-                boxes can be ignored when computing the loss.
-            gt_masks (None | Tensor) : True segmentation masks for each box
-                used if the architecture supports a segmentation task.
-
-        Returns:
-            dict[str, Tensor]: a dictionary of loss components
-        """
-        # assign gts and sample proposals
-        if self.with_bbox or self.with_mask:
-            num_imgs = len(img_metas)
-            if gt_bboxes_ignore is None:
-                gt_bboxes_ignore = [None for _ in range(num_imgs)]
-            sampling_results = []
-            neg_label_weights = []
-            for i in range(num_imgs):
-                assign_result = self.bbox_assigner.assign(
-                    proposal_list[i], gt_bboxes[i], gt_bboxes_ignore[i],
-                    gt_labels[i])
-                sampling_result = self.bbox_sampler.sample(
-                    assign_result,
-                    proposal_list[i],
-                    gt_bboxes[i],
-                    gt_labels[i],
-                    feats=[lvl_feat[i][None] for lvl_feat in x])
-                # neg label weight is obtained by sampling when using ISR-N
-                neg_label_weight = None
-                if isinstance(sampling_result, tuple):
-                    sampling_result, neg_label_weight = sampling_result
-                sampling_results.append(sampling_result)
-                neg_label_weights.append(neg_label_weight)
-
-        losses = dict()
-        # bbox head forward and loss
-        if self.with_bbox:
-            bbox_results = self._bbox_forward_train(
-                x,
-                sampling_results,
-                gt_bboxes,
-                gt_labels,
-                img_metas,
-                neg_label_weights=neg_label_weights)
-            losses.update(bbox_results['loss_bbox'])
-
-        # mask head forward and loss
-        if self.with_mask:
-            mask_results = self._mask_forward_train(x, sampling_results,
-                                                    bbox_results['bbox_feats'],
-                                                    gt_masks, img_metas)
-            losses.update(mask_results['loss_mask'])
-
-        return losses
-
-    def _bbox_forward(self, x, rois):
-        """Box forward function used in both training and testing."""
-        # TODO: a more flexible way to decide which feature maps to use
-        bbox_feats = self.bbox_roi_extractor(
-            x[:self.bbox_roi_extractor.num_inputs], rois)
-        if self.with_shared_head:
-            bbox_feats = self.shared_head(bbox_feats)
-        cls_score, bbox_pred = self.bbox_head(bbox_feats)
-
-        bbox_results = dict(
-            cls_score=cls_score, bbox_pred=bbox_pred, bbox_feats=bbox_feats)
-        return bbox_results
-
-    def _bbox_forward_train(self,
-                            x,
-                            sampling_results,
-                            gt_bboxes,
-                            gt_labels,
-                            img_metas,
-                            neg_label_weights=None):
-        """Run forward function and calculate loss for box head in training."""
-        rois = bbox2roi([res.bboxes for res in sampling_results])
-
-        bbox_results = self._bbox_forward(x, rois)
-
-        bbox_targets = self.bbox_head.get_targets(sampling_results, gt_bboxes,
-                                                  gt_labels, self.train_cfg)
-
-        # neg_label_weights obtained by sampler is image-wise, mapping back to
-        # the corresponding location in label weights
-        if neg_label_weights[0] is not None:
-            label_weights = bbox_targets[1]
-            cur_num_rois = 0
-            for i in range(len(sampling_results)):
-                num_pos = sampling_results[i].pos_inds.size(0)
-                num_neg = sampling_results[i].neg_inds.size(0)
-                label_weights[cur_num_rois + num_pos:cur_num_rois + num_pos +
-                              num_neg] = neg_label_weights[i]
-                cur_num_rois += num_pos + num_neg
-
-        cls_score = bbox_results['cls_score']
-        bbox_pred = bbox_results['bbox_pred']
-
-        # Apply ISR-P
-        isr_cfg = self.train_cfg.get('isr', None)
-        if isr_cfg is not None:
-            bbox_targets = isr_p(
-                cls_score,
-                bbox_pred,
-                bbox_targets,
-                rois,
-                sampling_results,
-                self.bbox_head.loss_cls,
-                self.bbox_head.bbox_coder,
-                **isr_cfg,
-                num_class=self.bbox_head.num_classes)
-        loss_bbox = self.bbox_head.loss(cls_score, bbox_pred, rois,
-                                        *bbox_targets)
-
-        # Add CARL Loss
-        carl_cfg = self.train_cfg.get('carl', None)
-        if carl_cfg is not None:
-            loss_carl = carl_loss(
-                cls_score,
-                bbox_targets[0],
-                bbox_pred,
-                bbox_targets[2],
-                self.bbox_head.loss_bbox,
-                **carl_cfg,
-                num_class=self.bbox_head.num_classes)
-            loss_bbox.update(loss_carl)
-
-        bbox_results.update(loss_bbox=loss_bbox)
-        return bbox_results

spaces/Catmeow/Face2Painting_From_Photo/app.py

@@ -1,22 +0,0 @@
-import gradio as gr
-from paintingface import generate
-
-title = "Face from Photo into Handed-paint"
-description = "Upload a photo, this Ai will detect and transfer only the main face into cartoon/anime handed-painting style. (If cannot detect a face, try the edit button on the right corner of the picture to crop the photo manually.)"
-article = "Examples are from Internet"
-
-Example=[['Example01.jpg'],['Example02.jpg'],['Example03.jpg']]
-
-demo = gr.Interface(
-    generate, 
-    inputs = [gr.Image(type="pil", label="Upload a photo")],
-    outputs= [gr.Image(type="pil", label="Output")],
-    title=title,
-    description=description,
-    article=article,
-    examples=Example,
-    allow_flagging='never'
-    )
-
-demo.launch()
-

spaces/CikeyQI/Yunzai/Yunzai/plugins/ws-plugin/apps/message/message.js

@@ -1,277 +0,0 @@
-import { sendSocketList, Config, Version } from '../../components/index.js'
-import { makeOneBotReportMsg, makeGSUidReportMsg, setGuildLatestMsgId, setMsgMap } from '../../model/index.js'
-import _ from 'lodash'
-import cfg from '../../../../lib/config/config.js'
-
-
-Bot.on('message', async e => {
-    if (e.self_id == '88888'){
-        if (e.group?.bot?.uin) {
-            e.self_id = e.group.bot.uin
-        } else if (e.friend?.bot?.uin) {
-            e.self_id = e.friend.bot.uin
-        }
-        e.bot = Bot[e.self_id]
-    }
-    // 被禁言或者全体禁言
-    if (Config.muteStop && (e.group?.mute_left > 0 || e.group?.all_muted)) return false
-    // 如果没有已连接的Websocket
-    if (sendSocketList.length == 0) return false
-    if (e.group_id) {
-        // 判断云崽白名单
-        const whiteGroup = Config.whiteGroup
-        if (Array.isArray(whiteGroup) && whiteGroup.length > 0) {
-            if (!whiteGroup.some(i => i == e.group_id)) return false
-        }
-        // 判断插件白名单
-        const yesGroup = Config.yesGroup
-        if (Array.isArray(yesGroup) && yesGroup.length > 0) {
-            if (!yesGroup.some(i => i == e.group_id)) return false
-        }
-        // 判断云崽黑名单
-        const blackGroup = Config.blackGroup
-        if (Array.isArray(blackGroup) && blackGroup.length > 0) {
-            if (blackGroup.some(i => i == e.group_id)) return false
-        }
-        // 判断插件黑名单
-        const noGroup = Config.noGroup
-        if (Array.isArray(noGroup) && noGroup.length > 0) {
-            if (noGroup.some(i => i == e.group_id)) return false
-        }
-    }
-    // 判断插件前缀
-    if (Array.isArray(Config.noMsgStart) && Config.noMsgStart.length > 0) {
-        if (e.message?.[0]?.type === 'text') {
-            if (Config.noMsgStart.some(i => e.message[0].text.startsWith(i))) return false
-        }
-    }
-    let isMaster = e.isMaster
-    if (Version.isTrss) {
-        if (e.user_id && cfg.master[e.self_id]?.includes(String(e.user_id))) {
-            isMaster = true
-        }
-    }
-    const message_id = Math.floor(Math.random() * Math.pow(2, 32)) | 0
-    let msg = {
-        time: e.time,
-        message_id: e.message_id,
-        message: _.cloneDeep(e.message),
-        rand: e.rand,
-        seq: e.seq,
-        source: e.source,
-        user_id: e.user_id,
-        self_id: e.self_id,
-        isMaster,
-        sender: e.sender,
-        param: {
-            time: e.time,
-            self_id: e.self_id,
-            post_type: e.post_type,
-            message_type: e.message_type,
-            sub_type: e.sub_type,
-            message_id,
-            user_id: e.user_id,
-            font: 0,
-            sender: e.sender,
-            anonymous: e.anonymous ? {
-                id: e.anonymous.id,
-                name: e.anonymous.name,
-                flag: e.anonymous.flag
-            } : null
-        }
-    }
-    let message = []
-    //增加isGroup e.isPrivate
-    if (e.guild_id) {
-        setGuildLatestMsgId(e.message_id)
-        //处理成message
-        if (e.content) {
-            let content = toMsg(e.content)
-            message.push(...content)
-        }
-        if (e.attachments) {
-            e.attachments.forEach(i => {
-                if (i.content_type.startsWith('image')) {
-                    message.push({
-                        type: 'image',
-                        file: i.filename,
-                        url: i.url
-                    })
-                }
-            })
-        }
-        msg.message = message
-
-        msg.isGuild = true
-        msg.param = {
-            time: Math.floor(new Date(msg.timestamp).getTime() / 1000),
-            post_type: 'message',
-            message_type: 'guild',
-            sub_type: 'channel',
-            guild_id: e.guild_id,
-            channel_id: e.channel_id,
-            user_id: e.author.id,
-            message_id: e.message_id,
-            self_id: e.bot.appID,
-            sender: {
-                user_id: e.author.id,
-                nickname: e.author.username,
-                tiny_id: e.author.id,
-            },
-            self_tiny_id: e.bot.appID,
-        }
-    } else if (e.message_type == 'group') {
-        msg.isGroup = true
-        msg.group_id = e.group_id
-        msg.param.group_id = e.group_id
-        msg.self_id = e.group?.bot?.uin || msg.self_id
-    } else if (e.message_type == 'private') {
-        msg.isPrivate = true
-        msg.self_id = e.friend?.bot?.uin || msg.self_id
-    } else {
-        return false
-    }
-    // 判断云崽前缀
-    msg = onlyReplyAt(msg)
-    if (!msg) return false
-    for (const i of sendSocketList) {
-        if (i.status == 1) {
-            let reportMsg = null
-            switch (Number(i.type)) {
-                case 1:
-                case 2:
-                case 6:
-                    if (Version.isTrss) {
-                        if (i.uin != e.self_id) continue
-                        if (!Version.protocol.some(i => i == e.bot?.version?.name)) continue
-                    }
-                    e.reply = reply(e)
-                    reportMsg = await makeOneBotReportMsg(msg)
-                    break;
-                case 3:
-                    reportMsg = await makeGSUidReportMsg(msg)
-                    break
-                default:
-                    break;
-            }
-            if (reportMsg) i.ws.send(reportMsg)
-        }
-    }
-})
-
-function reply(e) {
-    if (!Version.isTrss) {
-        const replyNew = e.reply
-        return async function (massage, quote = false, data = {}) {
-            const ret = await replyNew(massage, quote, data)
-            if (ret) {
-                setMsgMap({
-                    message_id: ret.message_id,
-                    time: ret.time,
-                    seq: ret.seq,
-                    rand: ret.rand,
-                    user_id: e.user_id,
-                    group_id: e.group_id,
-                    onebot_id: Math.floor(Math.random() * Math.pow(2, 32)) | 0,
-                })
-            }
-            return ret
-        }
-    } else {
-        if (e.bot?.version?.name == 'ICQQ') {
-            return async function (massage, quote = false) {
-                let ret
-                if (e.isGroup) {
-                    if (e.group?.sendMsg) {
-                        ret = await e.group.sendMsg(massage, quote)
-                    } else {
-                        ret = await e.bot.pickGroup(e.group_id).sendMsg(massage, quote)
-                    }
-                } else {
-                    if (e.friend?.sendMsg) {
-                        ret = await e.friend.sendMsg(massage, quote)
-                    } else {
-                        ret = await e.bot.pickFriend(e.user_id).sendMsg(massage, quote)
-                    }
-                }
-                if (ret) {
-                    setMsgMap({
-                        message_id: ret.message_id,
-                        time: ret.time,
-                        seq: ret.seq,
-                        rand: ret.rand,
-                        user_id: e.user_id,
-                        group_id: e.group_id,
-                        onebot_id: Math.floor(Math.random() * Math.pow(2, 32)) | 0,
-                    })
-                }
-                return ret
-            }
-        }
-        return e.reply
-    }
-}
-
-function onlyReplyAt(e) {
-    if (!e.message) return false
-
-    let groupCfg = Version.isTrss ? cfg.getGroup(e.self_id, e.group_id) : cfg.getGroup(e.group_id)
-    if (groupCfg.onlyReplyAt != 1 || !groupCfg.botAlias || e.isPrivate) return e
-
-    let at = atBot(e)
-    if (at) return e
-    e = hasAlias(e, groupCfg)
-    if (e) return e
-
-    return false
-}
-
-function atBot(e) {
-    for (const i of e.message) {
-        if (i.type === 'at') {
-            if (i.qq == e.self_id) return true
-        }
-    }
-    return false
-}
-
-function hasAlias(e, groupCfg) {
-    if (e.message[0].type === 'text') {
-        let alias = groupCfg.botAlias
-        if (!Array.isArray(alias)) {
-            alias = [alias]
-        }
-        for (let name of alias) {
-            if (e.message[0].text.startsWith(name)) {
-                e.message[0].text = _.trimStart(e.message[0].text, name).trim()
-                return e
-            }
-        }
-    }
-    return false
-}
-
-function toMsg(content) {
-    const regex = /<@!(\d+)>|<emoji:(\d+)>|([^<]+)/g;
-    let match;
-    const result = [];
-    while ((match = regex.exec(content)) !== null) {
-        if (match[1]) {
-            result.push({
-                type: 'at',
-                qq: match[1]
-            });
-        } else if (match[2]) {
-            result.push({
-                type: 'face',
-                id: parseInt(match[2])
-            });
-        } else if (match[3]) {
-            result.push({
-                type: 'text',
-                text: match[3]
-            });
-        }
-    }
-    return result;
-}

spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/layers/scale.py

@@ -1,11 +0,0 @@
-import torch
-from torch import nn
-
-
-class Scale(nn.Module):
-    def __init__(self, init_value=1.0):
-        super(Scale, self).__init__()
-        self.scale = nn.Parameter(torch.FloatTensor([init_value]))
-
-    def forward(self, input):
-        return input * self.scale

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/dateutil/zoneinfo/rebuild.py

@@ -1,75 +0,0 @@
-import logging
-import os
-import tempfile
-import shutil
-import json
-from subprocess import check_call, check_output
-from tarfile import TarFile
-
-from dateutil.zoneinfo import METADATA_FN, ZONEFILENAME
-
-
-def rebuild(filename, tag=None, format="gz", zonegroups=[], metadata=None):
-    """Rebuild the internal timezone info in dateutil/zoneinfo/zoneinfo*tar*
-
-    filename is the timezone tarball from ``ftp.iana.org/tz``.
-
-    """
-    tmpdir = tempfile.mkdtemp()
-    zonedir = os.path.join(tmpdir, "zoneinfo")
-    moduledir = os.path.dirname(__file__)
-    try:
-        with TarFile.open(filename) as tf:
-            for name in zonegroups:
-                tf.extract(name, tmpdir)
-            filepaths = [os.path.join(tmpdir, n) for n in zonegroups]
-
-            _run_zic(zonedir, filepaths)
-
-        # write metadata file
-        with open(os.path.join(zonedir, METADATA_FN), 'w') as f:
-            json.dump(metadata, f, indent=4, sort_keys=True)
-        target = os.path.join(moduledir, ZONEFILENAME)
-        with TarFile.open(target, "w:%s" % format) as tf:
-            for entry in os.listdir(zonedir):
-                entrypath = os.path.join(zonedir, entry)
-                tf.add(entrypath, entry)
-    finally:
-        shutil.rmtree(tmpdir)
-
-
-def _run_zic(zonedir, filepaths):
-    """Calls the ``zic`` compiler in a compatible way to get a "fat" binary.
-
-    Recent versions of ``zic`` default to ``-b slim``, while older versions
-    don't even have the ``-b`` option (but default to "fat" binaries). The
-    current version of dateutil does not support Version 2+ TZif files, which
-    causes problems when used in conjunction with "slim" binaries, so this
-    function is used to ensure that we always get a "fat" binary.
-    """
-
-    try:
-        help_text = check_output(["zic", "--help"])
-    except OSError as e:
-        _print_on_nosuchfile(e)
-        raise
-
-    if b"-b " in help_text:
-        bloat_args = ["-b", "fat"]
-    else:
-        bloat_args = []
-
-    check_call(["zic"] + bloat_args + ["-d", zonedir] + filepaths)
-
-
-def _print_on_nosuchfile(e):
-    """Print helpful troubleshooting message
-
-    e is an exception raised by subprocess.check_call()
-
-    """
-    if e.errno == 2:
-        logging.error(
-            "Could not find zic. Perhaps you need to install "
-            "libc-bin or some other package that provides it, "
-            "or it's not in your PATH?")

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/components/highlighted_text.py

@@ -1,205 +0,0 @@
-"""gr.HighlightedText() component."""
-
-from __future__ import annotations
-
-from typing import Callable, Literal
-
-from gradio_client.documentation import document, set_documentation_group
-from gradio_client.serializing import (
-    JSONSerializable,
-)
-
-from gradio.components.base import IOComponent, _Keywords
-from gradio.deprecation import warn_style_method_deprecation
-from gradio.events import (
-    Changeable,
-    EventListenerMethod,
-    Selectable,
-)
-
-set_documentation_group("component")
-
-
-@document()
-class HighlightedText(Changeable, Selectable, IOComponent, JSONSerializable):
-    """
-    Displays text that contains spans that are highlighted by category or numerical value.
-    Preprocessing: this component does *not* accept input.
-    Postprocessing: expects a {List[Tuple[str, float | str]]]} consisting of spans of text and their associated labels, or a {Dict} with two keys: (1) "text" whose value is the complete text, and "entities", which is a list of dictionaries, each of which have the keys: "entity" (consisting of the entity label), "start" (the character index where the label starts), and "end" (the character index where the label ends). Entities should not overlap.
-
-    Demos: diff_texts, text_analysis
-    Guides: named-entity-recognition
-    """
-
-    def __init__(
-        self,
-        value: list[tuple[str, str | float | None]] | dict | Callable | None = None,
-        *,
-        color_map: dict[str, str]
-        | None = None,  # Parameter moved to HighlightedText.style()
-        show_legend: bool = False,
-        combine_adjacent: bool = False,
-        adjacent_separator: str = "",
-        label: str | None = None,
-        every: float | None = None,
-        show_label: bool | None = None,
-        container: bool = True,
-        scale: int | None = None,
-        min_width: int = 160,
-        visible: bool = True,
-        elem_id: str | None = None,
-        elem_classes: list[str] | str | None = None,
-        **kwargs,
-    ):
-        """
-        Parameters:
-            value: Default value to show. If callable, the function will be called whenever the app loads to set the initial value of the component.
-            show_legend: whether to show span categories in a separate legend or inline.
-            combine_adjacent: If True, will merge the labels of adjacent tokens belonging to the same category.
-            adjacent_separator: Specifies the separator to be used between tokens if combine_adjacent is True.
-            label: component name in interface.
-            every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute.
-            show_label: if True, will display label.
-            container: If True, will place the component in a container - providing some extra padding around the border.
-            scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
-            min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
-            visible: If False, component will be hidden.
-            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
-            elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
-        """
-        self.color_map = color_map
-        self.show_legend = show_legend
-        self.combine_adjacent = combine_adjacent
-        self.adjacent_separator = adjacent_separator
-        self.select: EventListenerMethod
-        """
-        Event listener for when the user selects Highlighted text span.
-        Uses event data gradio.SelectData to carry `value` referring to selected [text, label] tuple, and `index` to refer to span index.
-        See EventData documentation on how to use this event data.
-        """
-        IOComponent.__init__(
-            self,
-            label=label,
-            every=every,
-            show_label=show_label,
-            container=container,
-            scale=scale,
-            min_width=min_width,
-            visible=visible,
-            elem_id=elem_id,
-            elem_classes=elem_classes,
-            value=value,
-            **kwargs,
-        )
-
-    def get_config(self):
-        return {
-            "color_map": self.color_map,
-            "show_legend": self.show_legend,
-            "value": self.value,
-            "selectable": self.selectable,
-            **IOComponent.get_config(self),
-        }
-
-    @staticmethod
-    def update(
-        value: list[tuple[str, str | float | None]]
-        | dict
-        | Literal[_Keywords.NO_VALUE]
-        | None = _Keywords.NO_VALUE,
-        color_map: dict[str, str] | None = None,
-        show_legend: bool | None = None,
-        label: str | None = None,
-        show_label: bool | None = None,
-        container: bool | None = None,
-        scale: int | None = None,
-        min_width: int | None = None,
-        visible: bool | None = None,
-    ):
-        updated_config = {
-            "color_map": color_map,
-            "show_legend": show_legend,
-            "label": label,
-            "show_label": show_label,
-            "container": container,
-            "scale": scale,
-            "min_width": min_width,
-            "visible": visible,
-            "value": value,
-            "__type__": "update",
-        }
-        return updated_config
-
-    def postprocess(
-        self, y: list[tuple[str, str | float | None]] | dict | None
-    ) -> list[tuple[str, str | float | None]] | None:
-        """
-        Parameters:
-            y: List of (word, category) tuples
-        Returns:
-            List of (word, category) tuples
-        """
-        if y is None:
-            return None
-        if isinstance(y, dict):
-            try:
-                text = y["text"]
-                entities = y["entities"]
-            except KeyError as ke:
-                raise ValueError(
-                    "Expected a dictionary with keys 'text' and 'entities' "
-                    "for the value of the HighlightedText component."
-                ) from ke
-            if len(entities) == 0:
-                y = [(text, None)]
-            else:
-                list_format = []
-                index = 0
-                entities = sorted(entities, key=lambda x: x["start"])
-                for entity in entities:
-                    list_format.append((text[index : entity["start"]], None))
-                    list_format.append(
-                        (text[entity["start"] : entity["end"]], entity["entity"])
-                    )
-                    index = entity["end"]
-                list_format.append((text[index:], None))
-                y = list_format
-        if self.combine_adjacent:
-            output = []
-            running_text, running_category = None, None
-            for text, category in y:
-                if running_text is None:
-                    running_text = text
-                    running_category = category
-                elif category == running_category:
-                    running_text += self.adjacent_separator + text
-                elif not text:
-                    # Skip fully empty item, these get added in processing
-                    # of dictionaries.
-                    pass
-                else:
-                    output.append((running_text, running_category))
-                    running_text = text
-                    running_category = category
-            if running_text is not None:
-                output.append((running_text, running_category))
-            return output
-        else:
-            return y
-
-    def style(
-        self,
-        *,
-        color_map: dict[str, str] | None = None,
-        container: bool | None = None,
-        **kwargs,
-    ):
-        """
-        This method is deprecated. Please set these arguments in the constructor instead.
-        """
-        warn_style_method_deprecation()
-        if container is not None:
-            self.container = container
-        if color_map is not None:
-            self.color_map = color_map
-        return self

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/interpretation.py

@@ -1,328 +0,0 @@
-"""Contains classes and methods related to interpretation for components in Gradio."""
-
-from __future__ import annotations
-
-import copy
-import math
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any
-
-import numpy as np
-from gradio_client import utils as client_utils
-
-from gradio import components
-
-if TYPE_CHECKING:  # Only import for type checking (is False at runtime).
-    from gradio import Interface
-
-
-class Interpretable(ABC):  # noqa: B024
-    def __init__(self) -> None:
-        self.set_interpret_parameters()
-
-    def set_interpret_parameters(self):  # noqa: B027
-        """
-        Set any parameters for interpretation. Properties can be set here to be
-        used in get_interpretation_neighbors and get_interpretation_scores.
-        """
-        pass
-
-    def get_interpretation_scores(
-        self, x: Any, neighbors: list[Any] | None, scores: list[float], **kwargs
-    ) -> list:
-        """
-        Arrange the output values from the neighbors into interpretation scores for the interface to render.
-        Parameters:
-            x: Input to interface
-            neighbors: Neighboring values to input x used for interpretation.
-            scores: Output value corresponding to each neighbor in neighbors
-        Returns:
-            Arrangement of interpretation scores for interfaces to render.
-        """
-        return scores
-
-
-class TokenInterpretable(Interpretable, ABC):
-    @abstractmethod
-    def tokenize(self, x: Any) -> tuple[list, list, None]:
-        """
-        Interprets an input data point x by splitting it into a list of tokens (e.g
-        a string into words or an image into super-pixels).
-        """
-        return [], [], None
-
-    @abstractmethod
-    def get_masked_inputs(self, tokens: list, binary_mask_matrix: list[list]) -> list:
-        return []
-
-
-class NeighborInterpretable(Interpretable, ABC):
-    @abstractmethod
-    def get_interpretation_neighbors(self, x: Any) -> tuple[list, dict]:
-        """
-        Generates values similar to input to be used to interpret the significance of the input in the final output.
-        Parameters:
-            x: Input to interface
-        Returns: (neighbor_values, interpret_kwargs, interpret_by_removal)
-            neighbor_values: Neighboring values to input x to compute for interpretation
-            interpret_kwargs: Keyword arguments to be passed to get_interpretation_scores
-        """
-        return [], {}
-
-
-async def run_interpret(interface: Interface, raw_input: list):
-    """
-    Runs the interpretation command for the machine learning model. Handles both the "default" out-of-the-box
-    interpretation for a certain set of UI component types, as well as the custom interpretation case.
-    Parameters:
-    raw_input: a list of raw inputs to apply the interpretation(s) on.
-    """
-    if isinstance(interface.interpretation, list):  # Either "default" or "shap"
-        processed_input = [
-            input_component.preprocess(raw_input[i])
-            for i, input_component in enumerate(interface.input_components)
-        ]
-        original_output = await interface.call_function(0, processed_input)
-        original_output = original_output["prediction"]
-
-        if len(interface.output_components) == 1:
-            original_output = [original_output]
-
-        scores, alternative_outputs = [], []
-
-        for i, (x, interp) in enumerate(zip(raw_input, interface.interpretation)):
-            if interp == "default":
-                input_component = interface.input_components[i]
-                neighbor_raw_input = list(raw_input)
-                if isinstance(input_component, TokenInterpretable):
-                    tokens, neighbor_values, masks = input_component.tokenize(x)
-                    interface_scores = []
-                    alternative_output = []
-                    for neighbor_input in neighbor_values:
-                        neighbor_raw_input[i] = neighbor_input
-                        processed_neighbor_input = [
-                            input_component.preprocess(neighbor_raw_input[i])
-                            for i, input_component in enumerate(
-                                interface.input_components
-                            )
-                        ]
-
-                        neighbor_output = await interface.call_function(
-                            0, processed_neighbor_input
-                        )
-                        neighbor_output = neighbor_output["prediction"]
-                        if len(interface.output_components) == 1:
-                            neighbor_output = [neighbor_output]
-                        processed_neighbor_output = [
-                            output_component.postprocess(neighbor_output[i])
-                            for i, output_component in enumerate(
-                                interface.output_components
-                            )
-                        ]
-
-                        alternative_output.append(processed_neighbor_output)
-                        interface_scores.append(
-                            quantify_difference_in_label(
-                                interface, original_output, neighbor_output
-                            )
-                        )
-                    alternative_outputs.append(alternative_output)
-                    scores.append(
-                        input_component.get_interpretation_scores(
-                            raw_input[i],
-                            neighbor_values,
-                            interface_scores,
-                            masks=masks,
-                            tokens=tokens,
-                        )
-                    )
-                elif isinstance(input_component, NeighborInterpretable):
-                    (
-                        neighbor_values,
-                        interpret_kwargs,
-                    ) = input_component.get_interpretation_neighbors(
-                        x
-                    )  # type: ignore
-                    interface_scores = []
-                    alternative_output = []
-                    for neighbor_input in neighbor_values:
-                        neighbor_raw_input[i] = neighbor_input
-                        processed_neighbor_input = [
-                            input_component.preprocess(neighbor_raw_input[i])
-                            for i, input_component in enumerate(
-                                interface.input_components
-                            )
-                        ]
-                        neighbor_output = await interface.call_function(
-                            0, processed_neighbor_input
-                        )
-                        neighbor_output = neighbor_output["prediction"]
-                        if len(interface.output_components) == 1:
-                            neighbor_output = [neighbor_output]
-                        processed_neighbor_output = [
-                            output_component.postprocess(neighbor_output[i])
-                            for i, output_component in enumerate(
-                                interface.output_components
-                            )
-                        ]
-
-                        alternative_output.append(processed_neighbor_output)
-                        interface_scores.append(
-                            quantify_difference_in_label(
-                                interface, original_output, neighbor_output
-                            )
-                        )
-                    alternative_outputs.append(alternative_output)
-                    interface_scores = [-score for score in interface_scores]
-                    scores.append(
-                        input_component.get_interpretation_scores(
-                            raw_input[i],
-                            neighbor_values,
-                            interface_scores,
-                            **interpret_kwargs,
-                        )
-                    )
-                else:
-                    raise ValueError(
-                        f"Component {input_component} does not support interpretation"
-                    )
-            elif interp == "shap" or interp == "shapley":
-                try:
-                    import shap  # type: ignore
-                except (ImportError, ModuleNotFoundError) as err:
-                    raise ValueError(
-                        "The package `shap` is required for this interpretation method. Try: `pip install shap`"
-                    ) from err
-                input_component = interface.input_components[i]
-                if not isinstance(input_component, TokenInterpretable):
-                    raise ValueError(
-                        f"Input component {input_component} does not support `shap` interpretation"
-                    )
-
-                tokens, _, masks = input_component.tokenize(x)
-
-                # construct a masked version of the input
-                def get_masked_prediction(binary_mask):
-                    assert isinstance(input_component, TokenInterpretable)
-                    masked_xs = input_component.get_masked_inputs(tokens, binary_mask)
-                    preds = []
-                    for masked_x in masked_xs:
-                        processed_masked_input = copy.deepcopy(processed_input)
-                        processed_masked_input[i] = input_component.preprocess(masked_x)
-                        new_output = client_utils.synchronize_async(
-                            interface.call_function, 0, processed_masked_input
-                        )
-                        new_output = new_output["prediction"]
-                        if len(interface.output_components) == 1:
-                            new_output = [new_output]
-                        pred = get_regression_or_classification_value(
-                            interface, original_output, new_output
-                        )
-                        preds.append(pred)
-                    return np.array(preds)
-
-                num_total_segments = len(tokens)
-                explainer = shap.KernelExplainer(
-                    get_masked_prediction, np.zeros((1, num_total_segments))
-                )
-                shap_values = explainer.shap_values(
-                    np.ones((1, num_total_segments)),
-                    nsamples=int(interface.num_shap * num_total_segments),
-                    silent=True,
-                )
-                assert shap_values is not None, "SHAP values could not be calculated"
-                scores.append(
-                    input_component.get_interpretation_scores(
-                        raw_input[i],
-                        None,
-                        shap_values[0].tolist(),
-                        masks=masks,
-                        tokens=tokens,
-                    )
-                )
-                alternative_outputs.append([])
-            elif interp is None:
-                scores.append(None)
-                alternative_outputs.append([])
-            else:
-                raise ValueError(f"Unknown interpretation method: {interp}")
-        return scores, alternative_outputs
-    elif interface.interpretation:  # custom interpretation function
-        processed_input = [
-            input_component.preprocess(raw_input[i])
-            for i, input_component in enumerate(interface.input_components)
-        ]
-        interpreter = interface.interpretation
-        interpretation = interpreter(*processed_input)
-        if len(raw_input) == 1:
-            interpretation = [interpretation]
-        return interpretation, []
-    else:
-        raise ValueError("No interpretation method specified.")
-
-
-def diff(original: Any, perturbed: Any) -> int | float:
-    try:  # try computing numerical difference
-        score = float(original) - float(perturbed)
-    except ValueError:  # otherwise, look at strict difference in label
-        score = int(original != perturbed)
-    return score
-
-
-def quantify_difference_in_label(
-    interface: Interface, original_output: list, perturbed_output: list
-) -> int | float:
-    output_component = interface.output_components[0]
-    post_original_output = output_component.postprocess(original_output[0])
-    post_perturbed_output = output_component.postprocess(perturbed_output[0])
-
-    if isinstance(output_component, components.Label):
-        original_label = post_original_output["label"]
-        perturbed_label = post_perturbed_output["label"]
-
-        # Handle different return types of Label interface
-        if "confidences" in post_original_output:
-            original_confidence = original_output[0][original_label]
-            perturbed_confidence = perturbed_output[0][original_label]
-            score = original_confidence - perturbed_confidence
-        else:
-            score = diff(original_label, perturbed_label)
-        return score
-
-    elif isinstance(output_component, components.Number):
-        score = diff(post_original_output, post_perturbed_output)
-        return score
-
-    else:
-        raise ValueError(
-            f"This interpretation method doesn't support the Output component: {output_component}"
-        )
-
-
-def get_regression_or_classification_value(
-    interface: Interface, original_output: list, perturbed_output: list
-) -> int | float:
-    """Used to combine regression/classification for Shap interpretation method."""
-    output_component = interface.output_components[0]
-    post_original_output = output_component.postprocess(original_output[0])
-    post_perturbed_output = output_component.postprocess(perturbed_output[0])
-
-    if isinstance(output_component, components.Label):
-        original_label = post_original_output["label"]
-        perturbed_label = post_perturbed_output["label"]
-
-        # Handle different return types of Label interface
-        if "confidences" in post_original_output:
-            if math.isnan(perturbed_output[0][original_label]):
-                return 0
-            return perturbed_output[0][original_label]
-        else:
-            score = diff(
-                perturbed_label, original_label
-            )  # Intentionally inverted order of arguments.
-        return score
-
-    else:
-        raise ValueError(
-            f"This interpretation method doesn't support the Output component: {output_component}"
-        )

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/httpcore/_backends/anyio.py

@@ -1,145 +0,0 @@
-import ssl
-import typing
-
-import anyio
-
-from .._exceptions import (
-    ConnectError,
-    ConnectTimeout,
-    ReadError,
-    ReadTimeout,
-    WriteError,
-    WriteTimeout,
-    map_exceptions,
-)
-from .._utils import is_socket_readable
-from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
-
-
-class AnyIOStream(AsyncNetworkStream):
-    def __init__(self, stream: anyio.abc.ByteStream) -> None:
-        self._stream = stream
-
-    async def read(
-        self, max_bytes: int, timeout: typing.Optional[float] = None
-    ) -> bytes:
-        exc_map = {
-            TimeoutError: ReadTimeout,
-            anyio.BrokenResourceError: ReadError,
-            anyio.ClosedResourceError: ReadError,
-        }
-        with map_exceptions(exc_map):
-            with anyio.fail_after(timeout):
-                try:
-                    return await self._stream.receive(max_bytes=max_bytes)
-                except anyio.EndOfStream:  # pragma: nocover
-                    return b""
-
-    async def write(
-        self, buffer: bytes, timeout: typing.Optional[float] = None
-    ) -> None:
-        if not buffer:
-            return
-
-        exc_map = {
-            TimeoutError: WriteTimeout,
-            anyio.BrokenResourceError: WriteError,
-            anyio.ClosedResourceError: WriteError,
-        }
-        with map_exceptions(exc_map):
-            with anyio.fail_after(timeout):
-                await self._stream.send(item=buffer)
-
-    async def aclose(self) -> None:
-        await self._stream.aclose()
-
-    async def start_tls(
-        self,
-        ssl_context: ssl.SSLContext,
-        server_hostname: typing.Optional[str] = None,
-        timeout: typing.Optional[float] = None,
-    ) -> AsyncNetworkStream:
-        exc_map = {
-            TimeoutError: ConnectTimeout,
-            anyio.BrokenResourceError: ConnectError,
-        }
-        with map_exceptions(exc_map):
-            try:
-                with anyio.fail_after(timeout):
-                    ssl_stream = await anyio.streams.tls.TLSStream.wrap(
-                        self._stream,
-                        ssl_context=ssl_context,
-                        hostname=server_hostname,
-                        standard_compatible=False,
-                        server_side=False,
-                    )
-            except Exception as exc:  # pragma: nocover
-                await self.aclose()
-                raise exc
-        return AnyIOStream(ssl_stream)
-
-    def get_extra_info(self, info: str) -> typing.Any:
-        if info == "ssl_object":
-            return self._stream.extra(anyio.streams.tls.TLSAttribute.ssl_object, None)
-        if info == "client_addr":
-            return self._stream.extra(anyio.abc.SocketAttribute.local_address, None)
-        if info == "server_addr":
-            return self._stream.extra(anyio.abc.SocketAttribute.remote_address, None)
-        if info == "socket":
-            return self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
-        if info == "is_readable":
-            sock = self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
-            return is_socket_readable(sock)
-        return None
-
-
-class AnyIOBackend(AsyncNetworkBackend):
-    async def connect_tcp(
-        self,
-        host: str,
-        port: int,
-        timeout: typing.Optional[float] = None,
-        local_address: typing.Optional[str] = None,
-        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
-    ) -> AsyncNetworkStream:
-        if socket_options is None:
-            socket_options = []  # pragma: no cover
-        exc_map = {
-            TimeoutError: ConnectTimeout,
-            OSError: ConnectError,
-            anyio.BrokenResourceError: ConnectError,
-        }
-        with map_exceptions(exc_map):
-            with anyio.fail_after(timeout):
-                stream: anyio.abc.ByteStream = await anyio.connect_tcp(
-                    remote_host=host,
-                    remote_port=port,
-                    local_host=local_address,
-                )
-                # By default TCP sockets opened in `asyncio` include TCP_NODELAY.
-                for option in socket_options:
-                    stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
-        return AnyIOStream(stream)
-
-    async def connect_unix_socket(
-        self,
-        path: str,
-        timeout: typing.Optional[float] = None,
-        socket_options: typing.Optional[typing.Iterable[SOCKET_OPTION]] = None,
-    ) -> AsyncNetworkStream:  # pragma: nocover
-        if socket_options is None:
-            socket_options = []
-        exc_map = {
-            TimeoutError: ConnectTimeout,
-            OSError: ConnectError,
-            anyio.BrokenResourceError: ConnectError,
-        }
-        with map_exceptions(exc_map):
-            with anyio.fail_after(timeout):
-                stream: anyio.abc.ByteStream = await anyio.connect_unix(path)
-                for option in socket_options:
-                    stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
-        return AnyIOStream(stream)
-
-    async def sleep(self, seconds: float) -> None:
-        await anyio.sleep(seconds)  # pragma: nocover

spaces/Dagfinn1962/Dreamlikeart-Anime-1.0/style.css

@@ -1,94 +0,0 @@
-#col-container {
-  background:rgb(9, 2, 27);
-  color:#FFFFFF;
-    width: 100%;
-    margin-left: auto;
-    margin-right: auto;
-}
-a {
-    color: inherit;
-    text-decoration: underline;
-}
-.gradio-container {
-  background:rgb(9, 2, 27);
-  color:#FFFFFF;
-    font-family: 'IBM Plex Sans', sans-serif;
-}
-.gr-button {
-    color: white;
-    border-color: #9d66e5;
-    background: #9e5bf6;
-}
-input[type='range'] {
-    accent-color: #9d66e5;
-}
-.dark input[type='range'] {
-    accent-color: #dfdfdf;
-}
-.container {
-  background:rgb(9, 2, 27);
-    width: 100%;
-    margin: auto;
-    padding-top: 1.5rem;
-  border-radius: 20px;
-}
-#gallery {
-    min-height: 22rem;
-    margin-bottom: 15px;
-    margin-left: auto;
-    margin-right: auto;
-    border-bottom-right-radius: .5rem !important;
-    border-bottom-left-radius: .5rem !important;
-}
-#gallery>div>.h-full {
-    min-height: 20rem;
-}
-.details:hover {
-    text-decoration: underline;
-}
-.gr-button {
-    white-space: nowrap;
-}
-.gr-button:focus {
-    border-color: rgb(147 197 253 / var(--tw-border-opacity));
-    outline: none;
-    box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000);
-    --tw-border-opacity: 1;
-    --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
-    --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color);
-    --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity));
-    --tw-ring-opacity: .5;
-}
-#advanced-options {
-    margin-bottom: 20px;
-}
-.footer {
-  background: #090956;
-  color:#FFFFFF;
-    margin-bottom: 45px;
-    margin-top: 35px;
-    text-align: center;
-    border-bottom: 1px solid #e5e5e5;
-}
-.footer>p {
-    color:#FFFFFF;
-    font-size: .8rem;
-    display: inline-block;
-    padding: 0 10px;
-    transform: translateY(10px);
-    background: white;
-}
-.dark .logo{ filter: invert(1); }
-.dark .footer {
-    border-color: #303030;
-}
-.dark .footer>p {
-    background: #0b0f19;
-}
-.acknowledgments h4{
-  color:#FFFFFF;
-    margin: 1.25em 0 .25em 0;
-    font-weight: bold;
-    font-size: 115%;
-}
-

spaces/Datasculptor/3D-Room-Layout-Estimation_LGT-Net/dataset/pano_s2d3d_mix_dataset.py

@@ -1,91 +0,0 @@
-"""
-@date: 2021/6/16
-@description:
-"""
-
-import os
-
-from dataset.pano_s2d3d_dataset import PanoS2D3DDataset
-from utils.logger import get_logger
-
-
-class PanoS2D3DMixDataset(PanoS2D3DDataset):
-    def __init__(self, root_dir, mode, shape=None, max_wall_num=0, aug=None, camera_height=1.6, logger=None,
-                 split_list=None, patch_num=256, keys=None, for_test_index=None, subset=None):
-        assert subset == 's2d3d' or subset == 'pano', 'error subset'
-        super().__init__(root_dir, None, shape, max_wall_num, aug, camera_height, logger,
-                         split_list, patch_num, keys, None, subset)
-        if logger is None:
-            logger = get_logger()
-        self.mode = mode
-        if mode == 'train':
-            if subset == 'pano':
-                s2d3d_train_data = PanoS2D3DDataset(root_dir, 'train', shape, max_wall_num, aug, camera_height, logger,
-                                                    split_list, patch_num, keys, None, 's2d3d').data
-                s2d3d_val_data = PanoS2D3DDataset(root_dir, 'val', shape, max_wall_num, aug, camera_height, logger,
-                                                  split_list, patch_num, keys, None, 's2d3d').data
-                s2d3d_test_data = PanoS2D3DDataset(root_dir, 'test', shape, max_wall_num, aug, camera_height, logger,
-                                                   split_list, patch_num, keys, None, 's2d3d').data
-                s2d3d_all_data = s2d3d_train_data + s2d3d_val_data + s2d3d_test_data
-
-                pano_train_data = PanoS2D3DDataset(root_dir, 'train', shape, max_wall_num, aug, camera_height, logger,
-                                                   split_list, patch_num, keys, None, 'pano').data
-                self.data = s2d3d_all_data + pano_train_data
-            elif subset == 's2d3d':
-                pano_train_data = PanoS2D3DDataset(root_dir, 'train', shape, max_wall_num, aug, camera_height, logger,
-                                                   split_list, patch_num, keys, None, 'pano').data
-                pano_val_data = PanoS2D3DDataset(root_dir, 'val', shape, max_wall_num, aug, camera_height, logger,
-                                                 split_list, patch_num, keys, None, 'pano').data
-                pano_test_data = PanoS2D3DDataset(root_dir, 'test', shape, max_wall_num, aug, camera_height, logger,
-                                                  split_list, patch_num, keys, None, 'pano').data
-                pano_all_data = pano_train_data + pano_val_data + pano_test_data
-
-                s2d3d_train_data = PanoS2D3DDataset(root_dir, 'train', shape, max_wall_num, aug, camera_height, logger,
-                                                    split_list, patch_num, keys, None, 's2d3d').data
-                self.data = pano_all_data + s2d3d_train_data
-        else:
-            self.data = PanoS2D3DDataset(root_dir, mode, shape, max_wall_num, aug, camera_height, logger,
-                                         split_list, patch_num, keys, None, subset).data
-
-        if for_test_index is not None:
-            self.data = self.data[:for_test_index]
-        logger.info(f"Build dataset mode: {self.mode}  valid: {len(self.data)}")
-
-
-if __name__ == '__main__':
-    import numpy as np
-    from PIL import Image
-
-    from tqdm import tqdm
-    from visualization.boundary import draw_boundaries
-    from visualization.floorplan import draw_floorplan
-    from utils.boundary import depth2boundaries
-    from utils.conversion import uv2xyz
-
-    modes = ['test', 'val', 'train']
-    for i in range(1):
-        for mode in modes:
-            print(mode)
-            mp3d_dataset = PanoS2D3DMixDataset(root_dir='../src/dataset/pano_s2d3d', mode=mode, aug={
-                # 'STRETCH': True,
-                # 'ROTATE': True,
-                # 'FLIP': True,
-                # 'GAMMA': True
-            }, subset='pano')
-            continue
-            save_dir = f'../src/dataset/pano_s2d3d/visualization1/{mode}'
-            if not os.path.isdir(save_dir):
-                os.makedirs(save_dir)
-
-            bar = tqdm(mp3d_dataset, ncols=100)
-            for data in bar:
-                bar.set_description(f"Processing {data['id']}")
-                boundary_list = depth2boundaries(data['ratio'], data['depth'], step=None)
-                pano_img = draw_boundaries(data['image'].transpose(1, 2, 0), boundary_list=boundary_list, show=False)
-                Image.fromarray((pano_img * 255).astype(np.uint8)).save(
-                    os.path.join(save_dir, f"{data['id']}_boundary.png"))
-
-                floorplan = draw_floorplan(uv2xyz(boundary_list[0])[..., ::2], show=False,
-                                           marker_color=None, center_color=0.8, show_radius=None)
-                Image.fromarray((floorplan.squeeze() * 255).astype(np.uint8)).save(
-                    os.path.join(save_dir, f"{data['id']}_floorplan.png"))

spaces/DemoLou/moe-tts/transforms.py

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

spaces/ECCV2022/bytetrack/yolox/data/data_augment.py

@@ -1,299 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding:utf-8 -*-
-# Copyright (c) Megvii, Inc. and its affiliates.
-"""
-Data augmentation functionality. Passed as callable transformations to
-Dataset classes.
-
-The data augmentation procedures were interpreted from @weiliu89's SSD paper
-http://arxiv.org/abs/1512.02325
-"""
-
-import cv2
-import numpy as np
-
-import torch
-
-from yolox.utils import xyxy2cxcywh
-
-import math
-import random
-
-
-def augment_hsv(img, hgain=0.015, sgain=0.7, vgain=0.4):
-    r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1  # random gains
-    hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV))
-    dtype = img.dtype  # uint8
-
-    x = np.arange(0, 256, dtype=np.int16)
-    lut_hue = ((x * r[0]) % 180).astype(dtype)
-    lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)
-    lut_val = np.clip(x * r[2], 0, 255).astype(dtype)
-
-    img_hsv = cv2.merge(
-        (cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val))
-    ).astype(dtype)
-    cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img)  # no return needed
-
-
-def box_candidates(box1, box2, wh_thr=2, ar_thr=20, area_thr=0.2):
-    # box1(4,n), box2(4,n)
-    # Compute candidate boxes which include follwing 5 things:
-    # box1 before augment, box2 after augment, wh_thr (pixels), aspect_ratio_thr, area_ratio
-    w1, h1 = box1[2] - box1[0], box1[3] - box1[1]
-    w2, h2 = box2[2] - box2[0], box2[3] - box2[1]
-    ar = np.maximum(w2 / (h2 + 1e-16), h2 / (w2 + 1e-16))  # aspect ratio
-    return (
-        (w2 > wh_thr)
-        & (h2 > wh_thr)
-        & (w2 * h2 / (w1 * h1 + 1e-16) > area_thr)
-        & (ar < ar_thr)
-    )  # candidates
-
-
-def random_perspective(
-    img,
-    targets=(),
-    degrees=10,
-    translate=0.1,
-    scale=0.1,
-    shear=10,
-    perspective=0.0,
-    border=(0, 0),
-):
-    # targets = [cls, xyxy]
-    height = img.shape[0] + border[0] * 2  # shape(h,w,c)
-    width = img.shape[1] + border[1] * 2
-
-    # Center
-    C = np.eye(3)
-    C[0, 2] = -img.shape[1] / 2  # x translation (pixels)
-    C[1, 2] = -img.shape[0] / 2  # y translation (pixels)
-
-    # Rotation and Scale
-    R = np.eye(3)
-    a = random.uniform(-degrees, degrees)
-    # a += random.choice([-180, -90, 0, 90])  # add 90deg rotations to small rotations
-    s = random.uniform(scale[0], scale[1])
-    # s = 2 ** random.uniform(-scale, scale)
-    R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s)
-
-    # Shear
-    S = np.eye(3)
-    S[0, 1] = math.tan(random.uniform(-shear, shear) * math.pi / 180)  # x shear (deg)
-    S[1, 0] = math.tan(random.uniform(-shear, shear) * math.pi / 180)  # y shear (deg)
-
-    # Translation
-    T = np.eye(3)
-    T[0, 2] = (
-        random.uniform(0.5 - translate, 0.5 + translate) * width
-    )  # x translation (pixels)
-    T[1, 2] = (
-        random.uniform(0.5 - translate, 0.5 + translate) * height
-    )  # y translation (pixels)
-
-    # Combined rotation matrix
-    M = T @ S @ R @ C  # order of operations (right to left) is IMPORTANT
-
-    ###########################
-    # For Aug out of Mosaic
-    # s = 1.
-    # M = np.eye(3)
-    ###########################
-
-    if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any():  # image changed
-        if perspective:
-            img = cv2.warpPerspective(
-                img, M, dsize=(width, height), borderValue=(114, 114, 114)
-            )
-        else:  # affine
-            img = cv2.warpAffine(
-                img, M[:2], dsize=(width, height), borderValue=(114, 114, 114)
-            )
-
-    # Transform label coordinates
-    n = len(targets)
-    if n:
-        # warp points
-        xy = np.ones((n * 4, 3))
-        xy[:, :2] = targets[:, [0, 1, 2, 3, 0, 3, 2, 1]].reshape(
-            n * 4, 2
-        )  # x1y1, x2y2, x1y2, x2y1
-        xy = xy @ M.T  # transform
-        if perspective:
-            xy = (xy[:, :2] / xy[:, 2:3]).reshape(n, 8)  # rescale
-        else:  # affine
-            xy = xy[:, :2].reshape(n, 8)
-
-        # create new boxes
-        x = xy[:, [0, 2, 4, 6]]
-        y = xy[:, [1, 3, 5, 7]]
-        xy = np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, n).T
-
-        # clip boxes
-        #xy[:, [0, 2]] = xy[:, [0, 2]].clip(0, width)
-        #xy[:, [1, 3]] = xy[:, [1, 3]].clip(0, height)
-
-        # filter candidates
-        i = box_candidates(box1=targets[:, :4].T * s, box2=xy.T)
-        targets = targets[i]
-        targets[:, :4] = xy[i]
-        
-        targets = targets[targets[:, 0] < width]
-        targets = targets[targets[:, 2] > 0]
-        targets = targets[targets[:, 1] < height]
-        targets = targets[targets[:, 3] > 0]
-        
-    return img, targets
-
-
-def _distort(image):
-    def _convert(image, alpha=1, beta=0):
-        tmp = image.astype(float) * alpha + beta
-        tmp[tmp < 0] = 0
-        tmp[tmp > 255] = 255
-        image[:] = tmp
-
-    image = image.copy()
-
-    if random.randrange(2):
-        _convert(image, beta=random.uniform(-32, 32))
-
-    if random.randrange(2):
-        _convert(image, alpha=random.uniform(0.5, 1.5))
-
-    image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
-
-    if random.randrange(2):
-        tmp = image[:, :, 0].astype(int) + random.randint(-18, 18)
-        tmp %= 180
-        image[:, :, 0] = tmp
-
-    if random.randrange(2):
-        _convert(image[:, :, 1], alpha=random.uniform(0.5, 1.5))
-
-    image = cv2.cvtColor(image, cv2.COLOR_HSV2BGR)
-
-    return image
-
-
-def _mirror(image, boxes):
-    _, width, _ = image.shape
-    if random.randrange(2):
-        image = image[:, ::-1]
-        boxes = boxes.copy()
-        boxes[:, 0::2] = width - boxes[:, 2::-2]
-    return image, boxes
-
-
-def preproc(image, input_size, mean, std, swap=(2, 0, 1)):
-    if len(image.shape) == 3:
-        padded_img = np.ones((input_size[0], input_size[1], 3)) * 114.0
-    else:
-        padded_img = np.ones(input_size) * 114.0
-    img = np.array(image)
-    r = min(input_size[0] / img.shape[0], input_size[1] / img.shape[1])
-    resized_img = cv2.resize(
-        img,
-        (int(img.shape[1] * r), int(img.shape[0] * r)),
-        interpolation=cv2.INTER_LINEAR,
-    ).astype(np.float32)
-    padded_img[: int(img.shape[0] * r), : int(img.shape[1] * r)] = resized_img
-
-    padded_img = padded_img[:, :, ::-1]
-    padded_img /= 255.0
-    if mean is not None:
-        padded_img -= mean
-    if std is not None:
-        padded_img /= std
-    padded_img = padded_img.transpose(swap)
-    padded_img = np.ascontiguousarray(padded_img, dtype=np.float32)
-    return padded_img, r
-
-
-class TrainTransform:
-    def __init__(self, p=0.5, rgb_means=None, std=None, max_labels=100):
-        self.means = rgb_means
-        self.std = std
-        self.p = p
-        self.max_labels = max_labels
-
-    def __call__(self, image, targets, input_dim):
-        boxes = targets[:, :4].copy()
-        labels = targets[:, 4].copy()
-        ids = targets[:, 5].copy()
-        if len(boxes) == 0:
-            targets = np.zeros((self.max_labels, 6), dtype=np.float32)
-            image, r_o = preproc(image, input_dim, self.means, self.std)
-            image = np.ascontiguousarray(image, dtype=np.float32)
-            return image, targets
-
-        image_o = image.copy()
-        targets_o = targets.copy()
-        height_o, width_o, _ = image_o.shape
-        boxes_o = targets_o[:, :4]
-        labels_o = targets_o[:, 4]
-        ids_o = targets_o[:, 5]
-        # bbox_o: [xyxy] to [c_x,c_y,w,h]
-        boxes_o = xyxy2cxcywh(boxes_o)
-
-        image_t = _distort(image)
-        image_t, boxes = _mirror(image_t, boxes)
-        height, width, _ = image_t.shape
-        image_t, r_ = preproc(image_t, input_dim, self.means, self.std)
-        # boxes [xyxy] 2 [cx,cy,w,h]
-        boxes = xyxy2cxcywh(boxes)
-        boxes *= r_
-
-        mask_b = np.minimum(boxes[:, 2], boxes[:, 3]) > 1
-        boxes_t = boxes[mask_b]
-        labels_t = labels[mask_b]
-        ids_t = ids[mask_b]
-
-        if len(boxes_t) == 0:
-            image_t, r_o = preproc(image_o, input_dim, self.means, self.std)
-            boxes_o *= r_o
-            boxes_t = boxes_o
-            labels_t = labels_o
-            ids_t = ids_o
-
-        labels_t = np.expand_dims(labels_t, 1)
-        ids_t = np.expand_dims(ids_t, 1)
-
-        targets_t = np.hstack((labels_t, boxes_t, ids_t))
-        padded_labels = np.zeros((self.max_labels, 6))
-        padded_labels[range(len(targets_t))[: self.max_labels]] = targets_t[
-            : self.max_labels
-        ]
-        padded_labels = np.ascontiguousarray(padded_labels, dtype=np.float32)
-        image_t = np.ascontiguousarray(image_t, dtype=np.float32)
-        return image_t, padded_labels
-
-
-class ValTransform:
-    """
-    Defines the transformations that should be applied to test PIL image
-    for input into the network
-
-    dimension -> tensorize -> color adj
-
-    Arguments:
-        resize (int): input dimension to SSD
-        rgb_means ((int,int,int)): average RGB of the dataset
-            (104,117,123)
-        swap ((int,int,int)): final order of channels
-
-    Returns:
-        transform (transform) : callable transform to be applied to test/val
-        data
-    """
-
-    def __init__(self, rgb_means=None, std=None, swap=(2, 0, 1)):
-        self.means = rgb_means
-        self.swap = swap
-        self.std = std
-
-    # assume input is cv2 img for now
-    def __call__(self, img, res, input_size):
-        img, _ = preproc(img, input_size, self.means, self.std, self.swap)
-        return img, np.zeros((1, 5))