Update parquet files (step 65 of 121)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Descargarsigmakeyfullcrackmega Los beneficios de usar SigmaKey la herramienta segura y confiable para el servicio de MTK.md

@@ -1,171 +0,0 @@
-
-<h1>Descargar SigmaKey Full Crack Mega: A Complete Guide</h1>
-<p>If you are looking for a professional and powerful tool to flash, unlock, and repair your mobile devices, you might have heard of SigmaKey. SigmaKey is a software that works with a dongle and allows you to service various types of cell phones, especially Huawei, MTK, Qualcomm, HiSilicon, and Spreadtrum devices. In this article, we will show you how to download SigmaKey full crack mega, a cracked version of the software that does not require a dongle or activation. We will also explain how to use SigmaKey full crack mega to perform different operations on your devices.</p>
-<h2>What is SigmaKey?</h2>
-<p>SigmaKey is a software that was developed by GSM Server Team, a group of experts in mobile unlocking and flashing. SigmaKey works with a hardware dongle that connects to your PC via USB port and provides security and authentication for the software. SigmaKey allows you to perform various operations on your mobile devices, such as:</p>
-<h2>descargarsigmakeyfullcrackmega</h2><br /><p><b><b>Download File</b> &#128504;&#128504;&#128504; <a href="https://byltly.com/2uKvm4">https://byltly.com/2uKvm4</a></b></p><br /><br />
-<ul>
-<li>Direct unlock</li>
-<li>Read unlock codes</li>
-<li>Repair IMEI</li>
-<li>Remove FRP</li>
-<li>Remove Huawei ID</li>
-<li>Unlock bootloader</li>
-<li>Flash firmware</li>
-<li>Backup and restore</li>
-<li>Root and unroot</li>
-<li>And more</li>
-</ul>
-<h3>Features and benefits of SigmaKey</h3>
-<p>SigmaKey has many features and benefits that make it one of the best tools for mobile servicing. Some of them are:</p>
-<ul>
-<li>It supports a wide range of devices from different brands and models.</li>
-<li>It supports various chipsets, such as MTK, Qualcomm, HiSilicon, Spreadtrum, etc.</li>
-<li>It has a user-friendly interface that is easy to navigate and operate.</li>
-<li>It has a fast and reliable performance that saves time and resources.</li>
-<li>It has a lifetime license that does not require annual payments.</li>
-<li>It has regular updates that add new features and support new devices.</li>
-<li>It has a customer support team that provides assistance and guidance.</li>
-</ul>
-<h3>Supported devices and platforms</h3>
-<p>SigmaKey supports thousands of devices from various brands, such as Huawei, Motorola, ZTE, Lenovo, Alcatel, Sony, LG, Samsung, Xiaomi, Oppo, Vivo, etc. You can check the full list of supported devices on the official website of SigmaKey. SigmaKey also supports Windows OS versions such as Win XP/Vista/7/Server 2008 for both 32-bit and 64-bit architecture.</p>
-<h2>How to download SigmaKey full crack mega?</h2>
-<p>If you want to use SigmaKey without buying a dongle or activating it online, you can download SigmaKey full crack mega. This is a cracked version of the software that bypasses the security and authentication of the dongle. However, you should be aware that downloading and using SigmaKey full crack mega is illegal and risky. You might face some problems such as:</p>
-<ul>
-<li>Virus or malware infection on your PC or device.</li>
-<li>Data loss or corruption on your PC or device.</li>
-<li>Dongle detection or blocking by the software.</li>
-<li>Lack of updates or support from the developers.</li>
-<li>Lawsuit or penalty from the developers or authorities.</li>
-</ul>
-<p>If you still want to download SigmaKey full crack mega at your own risk, you should follow these steps:</p>
-<p>descargar sigmakey full crack mega gratis<br />
-descargar sigmakey full crack mega 2021<br />
-descargar sigmakey full crack mega sin box<br />
-descargar sigmakey full crack mega huawei<br />
-descargar sigmakey full crack mega android<br />
-descargar sigmakey full crack mega windows 10<br />
-descargar sigmakey full crack mega ultima version<br />
-descargar sigmakey full crack mega para pc<br />
-descargar sigmakey full crack mega sin dongle<br />
-descargar sigmakey full crack mega mediafire<br />
-descargar sigmakey full crack mega 64 bits<br />
-descargar sigmakey full crack mega 32 bits<br />
-descargar sigmakey full crack mega sin virus<br />
-descargar sigmakey full crack mega mtk<br />
-descargar sigmakey full crack mega qualcomm<br />
-descargar sigmakey full crack mega español<br />
-descargar sigmakey full crack mega portable<br />
-descargar sigmakey full crack mega tutorial<br />
-descargar sigmakey full crack mega link directo<br />
-descargar sigmakey full crack mega reparar imei<br />
-descargar sigmakey full crack mega frp<br />
-descargar sigmakey full crack mega bootloader<br />
-descargar sigmakey full crack mega firmware<br />
-descargar sigmakey full crack mega update.app<br />
-descargar sigmakey full crack mega kirin<br />
-descargar sigmakey full crack mega hisilicon<br />
-descargar sigmakey full crack mega spreadtrum<br />
-descargar sigmakey full crack mega mediatek<br />
-descargar sigmakey full crack mega alcatel<br />
-descargar sigmakey full crack mega motorola<br />
-descargar sigmakey full crack mega lg<br />
-descargar sigmakey full crack mega zte<br />
-descargar sigmakey full crack mega lenovo<br />
-descargar sigmakey full crack mega sony<br />
-descargar sigmakey full crack mega vtelca<br />
-descargar sigmakey full crack mega lanix<br />
-descargar sigmakey full crack mega blu<br />
-descargar sigmakey full crack mega azumi<br />
-descargar sigmakey full crack mega verykool<br />
-descargar sigmakey full crack mega avvio<br />
-descargar sigmakey full crack mega bitel<br />
-descargar sigmakey full crack mega bmobile<br />
-descargar sigakeyfullcrackmega.exe (not recommended)</p>
- <h3>Requirements and precautions</h3>
- <ul>
- <li>A PC with Windows OS installed.</li>
- <li>A USB cable to connect your device to your PC.</li>
- <li>A backup of your device data in case of any damage or loss.</li>
- <li>A reliable internet connection to download the files.</li>
- <li>A antivirus software to scan the files for any virus or malware.</li>
- <li>A disablement of any firewall or antivirus software that might interfere with the installation process.</li>
- </ul>
- <h3>Steps to download and install SigmaKey full crack mega</h3>
- <ol>
- <li>Go to this link <a href="https://www.getdroidtips.com/download-sigmakey-huawei-crack/" target="_blank">https://www.getdroidtips.com/download-sigmakey-huawei-crack/</a> and click on the download button at the bottom of the page.</li>
- <li>You will be redirected to another page where you have to complete some surveys or offers to get the download link. Follow the instructions on the screen and complete the tasks.</li>
- <li>Once you get the download link, click on it and save the file on your PC. The file name is Sigmakey_Huawei_Edition_Crack_Version_2.40.02.zip and it has a size of about 100 MB.</li>
- <li>Extract the zip file using WinRAR or any other extraction tool. You will get a folder named Sigmakey_Huawei_Edition_Crack_Version_2.40.02 with several files inside it.</li>
- <li>Open the folder and run the file named Setup.exe as administrator. Follow the installation wizard and accept the terms and conditions. Choose a destination folder for the software and click on install.</li>
- <li>Wait for the installation process to finish. Do not disconnect your device or close the program during this process.</li>
- <li>After the installation is done, do not run the software yet. Go back to the folder where you extracted the zip file and open another folder named Loader_Sigma_Key_Huawei_Edition_Crack_Version_2.40.02.</li>
- <li>In this folder, you will find two files named Loader.exe and Patch.exe. Copy both files and paste them into the destination folder where you installed the software. Replace any existing files if prompted.</li>
- <li>Now run the file named Loader.exe as administrator. This will launch the software with full crack features enabled.</li>
- </ol>
- <h3>Troubleshooting tips</h3>
- <p>If you encounter any problems while downloading or installing SigmaKey full crack mega, you can try these tips:</p>
- <ul>
- <li>Make sure you have enough space on your PC hard drive for the files.</li>
- <li>Make sure you have a stable internet connection while downloading or installing the files.</li>
- <li>Make sure you disable any firewall or antivirus software that might block or delete the files.</li>
- <li>Make sure you scan the files for any virus or malware before opening them.</li>
- <li>Make sure you run the files as administrator and follow the instructions carefully.</li>
- <li>If you get an error message saying "Dongle not found" or "Dongle not connected", try changing your USB port or cable.</li>
- </ul>
- <h2>How to use SigmaKey full crack mega?</h2>
- <p>Once you have successfully downloaded and installed SigmaKey full crack mega, you can start using it to service your mobile devices. Here are some examples of how to use SigmaKey full crack mega for different operations:</p>
- <h3>Unlocking Huawei devices with SigmaKey</h3>
- <ol>
- <li>Connect your Huawei device to your PC via USB cable in fastboot mode. To enter fastboot mode, power off your device and press volume down + power buttons simultaneously until you see a fastboot logo on your screen.</li>
- <li>Launch SigmaKey full crack mega on your PC and select Huawei tab from the top menu bar.</li>
- <li>Select ADB Interface from Port Selection drop-down menu on top left corner of the screen.</li>
- <li>Select Fastboot Mode from Service Mode drop-down menu on top right corner of screen.</li>
- <li>Select Unlock Bootloader option from Service Operations section on bottom left corner of screen.</li>
- <li>The software will read your device information and generate an unlock code for your bootloader. Write down this code somewhere safe as you will need it later.</li>
- to enter the unlock code on your device. Follow the instructions on your device screen and enter the unlock code when prompted.</li>
- <li>Your device bootloader will be unlocked and your device will reboot automatically. You can disconnect your device from your PC.</li>
- </ol>
- <h3>Flashing and repairing MTK cell phones with SigmaKey</h3>
- <ol>
- <li>Connect your MTK device to your PC via USB cable in flash mode. To enter flash mode, power off your device and press volume up + power buttons simultaneously until you see a flash logo on your screen.</li>
- <li>Launch SigmaKey full crack mega on your PC and select MTK tab from the top menu bar.</li>
- <li>Select USB Mode from Port Selection drop-down menu on top left corner of the screen.</li>
- <li>Select Flash Mode from Service Mode drop-down menu on top right corner of screen.</li>
- <li>Select Flash Firmware option from Service Operations section on bottom left corner of screen.</li>
- <li>The software will ask you to select a firmware file for your device. You can download firmware files from various online sources or use the ones provided by SigmaKey. Click on Browse button and locate the firmware file on your PC.</li>
- <li>The software will verify the firmware file and show you some information about it. Make sure the firmware file matches your device model and version. Click on Write Firmware button to start flashing process.</li>
- <li>The software will flash the firmware file to your device and show you a progress bar. Do not disconnect your device or close the program during this process.</li>
- <li>After the flashing process is done, the software will show you a success message and your device will reboot automatically. You can disconnect your device from your PC.</li>
- </ol>
- <h3>Other operations with SigmaKey</h3>
- <p>SigmaKey full crack mega can also perform other operations on your devices, such as:</p>
- <ul>
- <li>Read and write IMEI</li>
-<li>Remove FRP lock</li>
-<li>Remove Huawei ID</li>
-<li>Backup and restore data</li>
-<li>Root and unroot devices</li>
-<li>And more</li>
-</ul>
- <p>To perform these operations, you need to select the appropriate tab, port, mode, and option from the software interface. You can also refer to the user manual or customer guide for more details and instructions.</p>
- <h2>Conclusion</h2>
- <p>In this article, we have shown you how to download SigmaKey full crack mega, a cracked version of the software that allows you to flash, unlock, and repair your mobile devices without a dongle or activation. We have also explained how to use SigmaKey full crack mega for different operations on Huawei and MTK devices. However, we have also warned you about the risks and consequences of using SigmaKey full crack mega, as it is illegal and unsafe. We recommend you to use the original SigmaKey software with a dongle and activation for a better and safer experience.</p>
- <h3>Summary of the article</h3>
- <p>SigmaKey is a professional and powerful tool for mobile servicing that works with a dongle and activation. SigmaKey full crack mega is a cracked version of the software that does not require a dongle or activation. SigmaKey full crack mega allows you to perform various operations on your devices, such as unlocking, flashing, repairing, etc. However, SigmaKey full crack mega is illegal and risky to use, as it might cause virus infection, data loss, dongle detection, lack of updates, lawsuit, etc. Therefore, it is better to use the original SigmaKey software with a dongle and activation for a safer and better experience.</p>
- <h3>FAQs</h3>
- <ol>
-<li>What is SigmaKey?</li>
-<p>SigmaKey is a software that works with a dongle and allows you to service various types of cell phones, especially Huawei, MTK, Qualcomm, HiSilicon, and Spreadtrum devices.</p>
-<li>What is SigmaKey full crack mega?</li>
-<p>SigmaKey full crack mega is a cracked version of the software that does not require a dongle or activation. It bypasses the security and authentication of the dongle.</p>
-<li>How to download SigmaKey full crack mega?</li>
-<p>You can download SigmaKey full crack mega from this link <a href="https://www.getdroidtips.com/download-sigmakey-huawei-crack/" target="_blank">https://www.getdroidtips.com/download-sigmakey-huawei-crack/</a>. You have to complete some surveys or offers to get the download link. Then you have to install the software and copy the loader and patch files into the installation folder.</p>
-<li>How to use SigmaKey full crack mega?</li>
-<p>You can use SigmaKey full crack mega to perform various operations on your devices, such as unlocking, flashing, repairing, etc. You have to select the appropriate tab, port, mode, and option from the software interface. You can also refer to the user manual or customer guide for more details and instructions.</p>
-<li>What are the risks of using SigmaKey full crack mega?</li>
-<p>Using SigmaKey full crack mega is illegal and risky. You might face some problems such as virus infection, data loss, dongle detection, lack of updates, lawsuit, etc. Therefore, it is better to use the original SigmaKey software with a dongle and activation for a safer and better experience.</p>
-</ol>
- </p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Become a Deadly Assassin in Sniper Killer 3D The Best Offline Sniper Game.md

@@ -1,103 +0,0 @@
-
-<h1>Sniper Killer 3D: The Ultimate Shooting Game</h1>
-<p>If you are looking for a shooting game that will test your skills as a sniper, look no further than Sniper Killer 3D. This game is the ultimate sniper adventure that will immerse you in high-intensity missions and action-packed scenarios. Whether you want to play offline or online, Sniper Killer 3D has something for everyone. Here is everything you need to know about this amazing game.</p>
-<h2>sniper killer 3d</h2><br /><p><b><b>DOWNLOAD</b> --->>> <a href="https://urlin.us/2uSUWO">https://urlin.us/2uSUWO</a></b></p><br /><br />
- <h2>What is Sniper Killer 3D?</h2>
-<p>Sniper Killer 3D is a shooting game where you play as a sniper who must eliminate high-profile targets and criminals. You will travel to different locations around the world, taking on various challenges and objectives. You will also have access to a huge arsenal of sniper rifles, assault rifles, and other guns that you can upgrade and customize. Sniper Killer 3D is a game that combines realism, variety, and fun in one package.</p>
- <h3>A thrilling and realistic sniper game</h3>
-<p>One of the best features of Sniper Killer 3D is its realistic physics and ballistics. You will have to take into account factors such as wind, distance, gravity, and movement when aiming and shooting your target. You will also have to deal with different weather conditions, such as rain, fog, snow, and night. You will feel like a real sniper as you pull the trigger and watch your bullet hit the mark.</p>
- <h3>A variety of weapons and missions</h3>
-<p>Sniper Killer 3D offers you more than 180 authentic weapons to choose from. You can unlock different sniper rifles, each with its own characteristics and advantages. You can also upgrade your weapons with scopes, silencers, magazines, and other attachments. You will need to use the right weapon for the right mission, as some targets may require more power, accuracy, or stealth than others.</p>
-<p>The game also has hundreds of thrilling missions that will keep you entertained for hours. You will have to eliminate terrorists, kidnappers, drug lords, assassins, and other enemies. You will also have to protect innocent civilians, rescue hostages, defuse bombs, and more. Each mission has its own objectives and rewards that you can use to buy new weapons or upgrade your existing ones.</p>
- <h3>A free and offline gameplay</h3>
-<p>Another great feature of Sniper Killer 3D is that it is free to play. You can download the game from the Google Play Store or play it on your web browser without spending a dime. The game also has an offline mode that allows you to play without an internet connection or data. You can enjoy the game anytime and anywhere you want.</p>
- <h2>How to play Sniper Killer 3D?</h2>
-<p>Sniper Killer 3D is easy to play but hard to master. Here are some tips on how to play the game:</p>
-<p>sniper killer 3d gun shooting games<br />
-sniper 3d wildlife studios<br />
-sniper 3d piercing bullet<br />
-sniper 3d stout assault rifle<br />
-sniper 3d offline mode<br />
-sniper 3d free to play<br />
-sniper 3d action adventure<br />
-sniper 3d realistic ballistics<br />
-sniper 3d variety of guns<br />
-sniper 3d diverse locations<br />
-sniper killer 3d download<br />
-sniper killer 3d mod apk<br />
-sniper killer 3d cheats<br />
-sniper killer 3d hack<br />
-sniper killer 3d unlimited money<br />
-sniper killer 3d review<br />
-sniper killer 3d gameplay<br />
-sniper killer 3d trailer<br />
-sniper killer 3d tips and tricks<br />
-sniper killer 3d best weapons<br />
-sniper killer 3d online multiplayer<br />
-sniper killer 3d pvp mode<br />
-sniper killer 3d special bullets<br />
-sniper killer 3d elite shooter<br />
-sniper killer 3d high-profile targets<br />
-sniper killer 3d missions and challenges<br />
-sniper killer 3d fun games for free<br />
-sniper killer 3d android app<br />
-sniper killer 3d ios app<br />
-sniper killer 3d pc game<br />
-sniper killer 3d mac game<br />
-sniper killer 3d windows game<br />
-sniper killer 3d linux game<br />
-sniper killer 3d steam game<br />
-sniper killer 3d epic games store game<br />
-sniper killer 3d google play store game<br />
-sniper killer 3d app store game<br />
-sniper killer 3d amazon appstore game<br />
-sniper killer 3d microsoft store game<br />
-sniper killer 3d data privacy and security <br />
-sniper killer 3d ratings and reviews <br />
-sniper killer 3d customer support <br />
-sniper killer 3d updates and news <br />
-sniper killer 3d blog and community <br />
-sniper killer 3d social media accounts <br />
-sniper killer 3d youtube channel <br />
-sniper killer 3d twitch channel <br />
-sniper killer 3d discord server <br />
-sniper killer 3d reddit forum <br />
-sniper killer 3d wiki and guide </p>
- <h3>Choose your sniper rifle and scope</h3>
-<p>Before each mission, you will have to select your weapon and scope. You can browse through the available weapons and see their stats, such as damage, range, stability, fire rate, and capacity. You can also see the available scopes and their zoom levels. Choose the weapon and scope that suit your mission and preference.</p>
- <h3>Aim and shoot your target</h3>
-<p>Once you start the mission, you will have to locate your target using your scope. You can use the mouse scroll or the right-click button to zoom in or out. You can also drag the left-click button to move your aim. You will see a red dot on your target, which indicates the bullet trajectory. You will have to adjust your aim according to the wind, distance, and movement of your target. You can use the wind indicator and the range finder to help you. When you are ready, press the space bar or the left-click button to shoot.</p>
- <h3>Complete the objectives and earn rewards</h3>
-<p>After you shoot your target, you will see a slow-motion replay of your shot. You will also see if you completed the mission objectives, such as killing the target, avoiding collateral damage, or achieving a headshot. You will earn coins and diamonds based on your performance. You can use these rewards to buy new weapons or upgrade your existing ones.</p>
- <h2>Why play Sniper Killer 3D?</h2>
-<p>Sniper Killer 3D is not just a game, it is an experience. Here are some reasons why you should play this game:</p>
- <h3>Improve your shooting skills and accuracy</h3>
-<p>Sniper Killer 3D is a game that will challenge your shooting skills and accuracy. You will have to be precise and patient as you aim and shoot your target. You will also have to be strategic and tactical as you choose your weapon and scope. You will learn how to handle different situations and scenarios as a sniper. You will become a better shooter as you play this game.</p>
- <h3>Enjoy stunning 3D graphics and animations</h3>
-<p>Sniper Killer 3D is a game that will impress you with its stunning 3D graphics and animations. You will see realistic environments, such as cities, mountains, deserts, and islands. You will also see lifelike characters, such as your targets, civilians, and enemies. You will feel the impact of your shots as you see blood splatter, bullet holes, and explosions. You will be amazed by the quality and detail of this game.</p>
- <h3>Challenge yourself with different levels of difficulty</h3>
-<p>Sniper Killer 3D is a game that will test your limits with different levels of difficulty. You can choose from easy, normal, hard, or expert modes depending on your skill level. You will face more challenging targets, objectives, and conditions as you progress through the game. You will also have to deal with limited ammo, time, and health. You will have to prove yourself as a sniper killer in this game.</p>
- <h2>Where to download Sniper Killer 3D?</h2>
-<p>Sniper Killer 3D is a game that is available on multiple platforms. Here are some options on where to download this game:</p>
- <h3>Available on Google Play Store for Android devices</h3>
-<p>If you have an Android device, such as a smartphone or tablet, you can download Sniper Killer 3D from the Google Play Store for free. You can also enjoy the game without any ads or in-app purchases. You can access the game from this link: [Sniper Killer 3D].</p>
- <h3>Compatible with web browsers for desktop computers</h3>
-<p>If you have a desktop computer, such as a PC or Mac, you can play Sniper Killer 3D on your web browser for free. You can also enjoy the game without any downloads or installations. You can access the game from this link: [Sniper Killer 3D].</p>
- <h2>Conclusion</h2>
-<p>Sniper Killer 3D is a game that will give you an unforgettable shooting experience. It is a game that combines realism, variety, and fun in one package. It is a game that will improve your shooting skills and accuracy, enjoy stunning 3D graphics and animations, and challenge yourself with different levels of difficulty. It is a game that is free to play and available on multiple platforms. It is a game that you should not miss.</p>
-<p>If you are ready to become a sniper killer, download Sniper Killer 3D today and start your adventure!</p>
- <h4>Frequently Asked Questions</h4>
-<ul>
-<li><b>What are the minimum requirements to play Sniper Killer 3D?</b></li>
-<li>The minimum requirements to play Sniper Killer 3D are: Android 4.4 or higher for Android devices; Windows XP/Vista/7/8/10 or Mac OS X for desktop computers; Chrome, Firefox, Safari, or Edge for web browsers.</li>
-<li><b>How can I get more coins and diamonds in Sniper Killer 3D?</b></li>
-<li>You can get more coins and diamonds in Sniper Killer 3D by: completing missions and objectives; watching video ads; rating and reviewing the game; inviting your friends to play the game.</li>
-<li><b>How can I change the language of Sniper Killer 3D?</b></li>
-<li>You can change the language of Sniper Killer 3D by: going to the settings menu; selecting the language option; choosing from the available languages, such as English, Spanish, French, German, Russian, Chinese, and more.</li>
-<li><b>How can I contact the developers of Sniper Killer 3D?</b></li>
-<li>You can contact the developers of Sniper Killer 3D by: sending an email to [[email protected]]; visiting their website at [sniperkiller3d.com]; following them on social media platforms, such as Facebook, Twitter, Instagram, and YouTube.</li>
-<li><b>What are some tips and tricks to play Sniper Killer 3D?</b></li>
-<li>Some tips and tricks to play Sniper Killer 3D are: use the wind indicator and the range finder to adjust your aim; use the silencer and the night vision to increase your stealth; use the bullet time and the thermal vision to improve your accuracy; use the headshot and the explosive shot to deal more damage; use the zoom and the drag to find your target; use the space bar and the left-click button to shoot.</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/FIFA Chino APK disfruta de la emocin del ftbol con grficos increbles.md

@@ -1,154 +0,0 @@
-
-<h1>FIFA Mobile Chino APK Actualizado: Todo lo que necesitas saber</h1>
-<p>Si eres un fanático del fútbol y te gusta jugar a los juegos de EA Sports, seguramente habrás oído hablar de <strong>FIFA Mobile</strong>, el juego oficial para dispositivos móviles que te permite crear tu propio equipo, competir en diferentes modos y eventos, y disfrutar de la emoción del deporte rey. Pero, ¿sabías que existe una versión alternativa de este juego, llamada <strong>FIFA Mobile Chino APK</strong>, que tiene algunas características y opciones diferentes a la versión original?</p>
-<h2>fifa mobile chino apk actualizado</h2><br /><p><b><b>DOWNLOAD</b> &#9881; <a href="https://jinyurl.com/2uNS53">https://jinyurl.com/2uNS53</a></b></p><br /><br />
-<p>En este artículo, te vamos a contar todo lo que necesitas saber sobre FIFA Mobile Chino APK, qué es, cómo descargarlo e instalarlo, qué ventajas y desventajas tiene, cómo se compara con FIFA Mobile APK, qué opinan los usuarios que lo han probado, y algunas preguntas frecuentes que te pueden surgir. ¡Sigue leyendo y descubre si este juego es para ti!</p>
- <h2>¿Qué es FIFA Mobile Chino APK?</h2>
-<p>FIFA Mobile Chino APK es una versión modificada de FIFA Mobile, el juego oficial de EA Sports para dispositivos móviles Android e iOS. Esta versión está desarrollada por Tencent, una empresa china que tiene los derechos de distribución de FIFA en China. Por lo tanto, esta versión está pensada principalmente para el público chino, aunque también se puede jugar desde otros países.</p>
-<p>FIFA Mobile Chino APK tiene algunas características y opciones diferentes a la versión original de FIFA Mobile, como por ejemplo:</p>
-<h3>Características principales de FIFA Mobile Chino APK</h3>
-<ul>
-<li>Tiene una interfaz y un diseño más coloridos y animados, con más efectos visuales y sonoros.</li>
-<li>Tiene más modos de juego disponibles, como el modo carrera, el modo torneo, el modo entrenamiento, el modo desafío y el modo mundial.</li>
-<li>Tiene más opciones de personalización para tu equipo, como la posibilidad de elegir el escudo, el estadio, el balón, las equipaciones y los patrocinadores.</li>
-<li>Tiene más eventos y actividades especiales, como la Copa del Mundo, la Champions League, la Superliga China y otras competiciones regionales e internacionales.</li>
-<li>Tiene más jugadores y leyendas disponibles para fichar, incluyendo algunos exclusivos de esta versión, como los iconos eternos.</li>
-<li>Tiene un sistema de recompensas más generoso y variado, que te permite obtener monedas, puntos, sobres, jugadores y otros objetos.</li>
-<li>Tiene un mercado de transferencias más dinámico y competitivo, donde puedes comprar y vender jugadores con otros usuarios.</li>
-</ul>
-<h3>Cómo descargar e instalar FIFA Mobile Chino APK</h3>
-<p>Para descargar e instalar FIFA Mobile Chino APK en tu dispositivo Android, debes seguir estos pasos:</p>
-<ol>
-<li>Accede a un sitio web seguro y confiable que ofrezca el archivo APK de FIFA Mobile Chino. Por ejemplo, puedes usar este enlace: .</li>
-<li>Descarga el archivo APK en tu dispositivo. Puede que tengas que habilitar la opción de instalar aplicaciones de fuentes desconocidas en los ajustes de seguridad de tu dispositivo.</li>
-<li>Abre el archivo APK y sigue las instrucciones que aparecen en la pantalla para completar la instalación.</li>
-<li>Una vez instalado, abre el juego y espera a que se descarguen los datos adicionales necesarios para su funcionamiento.</li>
-<li>Disfruta de FIFA Mobile Chino APK en tu dispositivo Android.</li>
-</ol>
-<p>Para descargar e instalar FIFA Mobile Chino APK en tu dispositivo iOS, debes seguir estos pasos:</p>
-<ol>
-<li>Accede a un sitio web seguro y confiable que ofrezca el archivo IPA de FIFA Mobile Chino. Por ejemplo, puedes usar este enlace: .</li>
-<li>Descarga el archivo IPA en tu dispositivo. Puede que tengas que usar una aplicación de gestión de archivos como iFile o Filza para mover el archivo a la carpeta adecuada.</li>
-<li>Abre el archivo IPA y sigue las instrucciones que aparecen en la pantalla para completar la instalación.</li>
-<li>Una vez instalado, abre el juego y espera a que se descarguen los datos adicionales necesarios para su funcionamiento.</li>
-<li>Disfruta de FIFA Mobile Chino APK en tu dispositivo iOS.</li>
-</ol>
-<h3>Ventajas y desventajas de FIFA Mobile Chino APK</h3>
-<p>Como todo juego, FIFA Mobile Chino APK tiene sus pros y sus contras. Aquí te resumimos algunas de las ventajas y desventajas de este juego:</p>
-<h4>Ventajas de FIFA Mobile Chino APK</h4>
-<ul>
-<li>Tiene más contenido y opciones que la versión original de FIFA Mobile, lo que lo hace más divertido y variado.</li>
-<li>Tiene una mejor calidad gráfica y sonora, lo que lo hace más atractivo y realista.</li>
-<li>Tiene una mayor compatibilidad con diferentes dispositivos y sistemas operativos, lo que lo hace más accesible y fácil de usar.</li>
-<li>Tiene una comunidad más activa y participativa, lo que lo hace más social e interactivo.</li>
-</ul>
-<h4>Desventajas de FIFA Mobile Chino APK</h4>
-<ul>
-<li>Tiene un idioma diferente al español, lo que puede dificultar la comprensión y el disfrute del juego.</li>
-<li>Tiene un mayor riesgo de virus o malware, al no ser una versión oficial ni estar disponible en las tiendas oficiales de aplicaciones.</li>
-<li>Tiene un mayor consumo de recursos y datos, lo que puede afectar al rendimiento y la batería del dispositivo.</li>
-<li>Tiene un mayor nivel de dificultad y competencia, lo que puede frustrar o desanimar a algunos jugadores.</li>
-</ul>
- <h2>¿Qué diferencia hay entre FIFA Mobile Chino APK y FIFA Mobile APK?</h2>
-<p>Ahora que ya sabes qué es FIFA Mobile Chino APK, te preguntarás qué diferencia hay con FIFA Mobile APK, la versión original del juego. Pues bien, aunque ambos juegos comparten el mismo concepto y objetivo, hay algunas similitudes y diferencias entre ellos que te vamos a explicar a continuación:</p>
- <h3>Similitudes entre ambos juegos</h3>
-<ul>
-<li>Ambos juegos son desarrollados por EA Sports, la empresa líder en juegos deportivos.</li>
-<li>Ambos juegos te permiten crear tu propio equipo de fútbol, con jugadores reales y licenciados por la FIFA.</li>
-<li>Ambos juegos te ofrecen diferentes modos y eventos para jugar solo o con otros usuarios, como el modo temporada, el modo versus o el modo ataque.</li>
-<li>Ambos juegos te dan la oportunidad de mejorar tus habilidades y tu estrategia, mediante el entrenamiento, la formación y la táctica.</li>
-<li>Ambos juegos te brindan una experiencia inmersiva y emocionante, con gráficos detallados, animaciones fluidas y comentarios en vivo.</li>
-</ul>
- <h3>Diferencias entre ambos juegos</h3>
- <ul>
-<li>FIFA Mobile Chino APK tiene una interfaz y un diseño más coloridos y animados, mientras que FIFA Mobile APK tiene una interfaz y un diseño más sobrios y elegantes.</li>
-<li>FIFA Mobile Chino APK tiene más modos de juego disponibles, como el modo carrera, el modo torneo o el modo mundial, mientras que FIFA Mobile APK tiene menos modos de juego disponibles, como el modo campaña o el modo leyendas.</li> <li>FIFA Mobile Chino APK tiene más opciones de personalización para tu equipo, como la posibilidad de elegir el escudo, el estadio, el balón, las equipaciones y los patrocinadores, mientras que FIFA Mobile APK tiene menos opciones de personalización para tu equipo, como la posibilidad de elegir el nombre, el logo y los colores.</li>
-<li>FIFA Mobile Chino APK tiene más eventos y actividades especiales, como la Copa del Mundo, la Champions League, la Superliga China y otras competiciones regionales e internacionales, mientras que FIFA Mobile APK tiene menos eventos y actividades especiales, como la Copa América, la Eurocopa, la Premier League y otras ligas nacionales.</li>
-<li>FIFA Mobile Chino APK tiene más jugadores y leyendas disponibles para fichar, incluyendo algunos exclusivos de esta versión, como los iconos eternos, mientras que FIFA Mobile APK tiene menos jugadores y leyendas disponibles para fichar, incluyendo algunos exclusivos de esta versión, como los iconos prime.</li>
-<li>FIFA Mobile Chino APK tiene un sistema de recompensas más generoso y variado, que te permite obtener monedas, puntos, sobres, jugadores y otros objetos, mientras que FIFA Mobile APK tiene un sistema de recompensas más limitado y repetitivo, que te permite obtener monedas, puntos y sobres.</li>
-<li>FIFA Mobile Chino APK tiene un mercado de transferencias más dinámico y competitivo, donde puedes comprar y vender jugadores con otros usuarios, mientras que FIFA Mobile APK tiene un mercado de transferencias más estático y controlado, donde solo puedes comprar y vender jugadores con el sistema.</li>
-</ul>
- <h2>¿Qué opinan los usuarios de FIFA Mobile Chino APK?</h2>
-<p>Si te preguntas qué opinan los usuarios que han probado FIFA Mobile Chino APK, te podemos decir que hay opiniones de todo tipo. Algunos usuarios están muy satisfechos con este juego y lo prefieren a la versión original de FIFA Mobile, mientras que otros usuarios están muy decepcionados con este juego y lo consideran una copia barata de FIFA Mobile. Aquí te mostramos algunas de las reseñas positivas y negativas que hemos encontrado en internet:</p>
-<p>descargar fifa mobile chino apk<br />
-fifa mobile chino apk 2023<br />
-fifa mobile chino apk ultima version<br />
-fifa mobile chino apk mod<br />
-fifa mobile chino apk hack<br />
-fifa mobile chino apk mega<br />
-fifa mobile chino apk mediafire<br />
-fifa mobile chino apk sin licencia<br />
-fifa mobile chino apk android<br />
-fifa mobile chino apk gratis<br />
-fifa mobile chino apk full<br />
-fifa mobile chino apk offline<br />
-fifa mobile chino apk obb<br />
-fifa mobile chino apk datos<br />
-fifa mobile chino apk gameplay<br />
-fifa mobile chino apk descargar gratis<br />
-fifa mobile chino apk 2023 ultima version<br />
-fifa mobile chino apk 2023 mod<br />
-fifa mobile chino apk 2023 hack<br />
-fifa mobile chino apk 2023 mega<br />
-fifa mobile chino apk 2023 mediafire<br />
-fifa mobile chino apk 2023 sin licencia<br />
-fifa mobile chino apk 2023 android<br />
-fifa mobile chino apk 2023 gratis<br />
-fifa mobile chino apk 2023 full<br />
-fifa mobile chino apk 2023 offline<br />
-fifa mobile chino apk 2023 obb<br />
-fifa mobile chino apk 2023 datos<br />
-fifa mobile chino apk 2023 gameplay<br />
-fifa mobile chino apk 2023 descargar gratis<br />
-como descargar fifa mobile chino apk<br />
-como instalar fifa mobile chino apk<br />
-como jugar fifa mobile chino apk<br />
-como actualizar fifa mobile chino apk<br />
-como hackear fifa mobile chino apk<br />
-como tener monedas en fifa mobile chino apk<br />
-como tener jugadores en fifa mobile chino apk<br />
-como tener licencia en fifa mobile chino apk<br />
-como solucionar error en fifa mobile chino apk<br />
-como quitar publicidad en fifa mobile chino apk</p>
- <h3>Reseñas positivas de FIFA Mobile Chino APK</h3>
-<ul>
-<li>"Me encanta este juego. Tiene mucha más variedad y diversión que el FIFA Mobile normal. Los gráficos son increíbles y los modos de juego son muy entretenidos. Lo recomiendo mucho."</li>
-<li>"Es el mejor juego de fútbol para móviles que he jugado. Tiene todo lo que le falta al FIFA Mobile original. Más modos, más jugadores, más eventos, más recompensas. Es una pasada."</li>
-<li>"No entiendo por qué EA Sports no hace este juego para todo el mundo. Es mucho mejor que el FIFA Mobile que tenemos en Europa. Tiene más opciones y más calidad. Es una maravilla."</li>
-</ul>
- <h3>Reseñas negativas de FIFA Mobile Chino APK</h3>
-<ul>
-<li>"No me gusta nada este juego. Es una copia barata del FIFA Mobile original. Los gráficos son feos y los sonidos son molestos. Los modos de juego son aburridos y repetitivos. No lo recomiendo."</li>
-<li>"Es un juego muy malo. Tiene muchos errores y problemas. Se cierra solo o se queda colgado. Los controles son malos y la jugabilidad es pésima. No vale la pena."</li>
-<li>"No entiendo cómo hay gente que juega a esto. Es una basura. No tiene nada que ver con el FIFA Mobile original. No tiene licencias ni jugadores reales. Es una estafa."</li>
-</ul>
- <h2>Conclusión</h2>
-<p>En conclusión, podemos decir que FIFA Mobile Chino APK es una versión alternativa de FIFA Mobile, el juego oficial de EA Sports para dispositivos móviles. Esta versión está desarrollada por Tencent, una empresa china que tiene los derechos de distribución de FIFA en China.</p>
- <p>FIFA Mobile Chino APK tiene algunas características y opciones diferentes a la versión original de FIFA Mobile, como una interfaz más colorida, más modos de juego disponibles, más opciones de personalización para tu equipo, más eventos y actividades especiales, más jugadores y leyendas disponibles para fichar, un sistema de recompensas más generoso y variado, y un mercado de transferencias más dinámico y competitivo.</p>
- <p>FIFA Mobile Chino APK también tiene algunas vent ajas y desventajas, como un idioma diferente al español, un mayor riesgo de virus o malware, un mayor consumo de recursos y datos, y un mayor nivel de dificultad y competencia.</p>
- <p>FIFA Mobile Chino APK se puede descargar e instalar en dispositivos Android e iOS, siguiendo unos sencillos pasos que te hemos explicado en este artículo. Sin embargo, debes tener en cuenta que no se trata de una versión oficial ni está disponible en las tiendas oficiales de aplicaciones, por lo que debes tomar algunas precauciones al usarla.</p>
- <p>FIFA Mobile Chino APK se diferencia de FIFA Mobile APK, la versión original del juego, en algunos aspectos que también te hemos detallado en este artículo. Ambos juegos tienen sus similitudes y diferencias, y depende de tu gusto y preferencia el elegir uno u otro.</p>
- <h3>¿Por qué deberías probar FIFA Mobile Chino APK?</h3>
-<p>Si te gustan los juegos de fútbol y quieres probar algo diferente al FIFA Mobile original, puedes darle una oportunidad a FIFA Mobile Chino APK. Este juego te ofrece más contenido y opciones que la versión original, lo que lo hace más divertido y variado. Además, tiene una mejor calidad gráfica y sonora, lo que lo hace más atractivo y realista. También tiene una mayor compatibilidad con diferentes dispositivos y sistemas operativos, lo que lo hace más accesible y fácil de usar. Y por si fuera poco, tiene una comunidad más activa y participativa, lo que lo hace más social e interactivo.</p>
- <h3>¿Qué precauciones debes tomar al usar FIFA Mobile Chino APK?</h3>
-<p>Si decides probar FIFA Mobile Chino APK, debes tener en cuenta algunas precauciones para evitar problemas o inconvenientes. Algunas de estas precauciones son:</p>
-<ul>
-<li>Verifica la fuente de descarga del archivo APK o IPA, y asegúrate de que sea segura y confiable. Evita los sitios web sospechosos o fraudulentos que puedan contener virus o malware.</li>
-<li>Respeta las normas y condiciones de uso del juego, y no hagas trampas ni abuses de otros usuarios. De lo contrario, podrías ser baneado o sancionado por los administradores del juego.</li>
-<li>No compartas tus datos personales ni financieros con nadie dentro del juego, ni accedas a enlaces o promociones dudosas. Podrías ser víctima de estafas o robos de identidad.</li>
-<li>No gastes demasiado dinero real en el juego, ni te obsesiones con obtener los mejores jugadores o las mejores recompensas. Recuerda que se trata de un juego para divertirte y pasar el rato, no para competir o presumir.</li>
-</ul>
- <h2>Preguntas frecuentes sobre FIFA Mobile Chino APK</h2>
-<p>Para terminar este artículo, te vamos a responder algunas de las preguntas frecuentes que pueden surgirte sobre FIFA Mobile Chino APK. Esperamos que te sean útiles y te ayuden a resolver tus dudas.</p>
- <h4>¿FIFA Mobile Chino APK es gratis?</h4>
-<p>Sí, FIFA Mobile Chino APK es gratis. No tienes que pagar nada para descargarlo e instalarlo en tu dispositivo. Sin embargo, el juego tiene compras integradas que te permiten obtener monedas, puntos o sobres con dinero real. Estas compras son opcionales y no son necesarias para jugar.</p>
- <h4>¿FIFA Mobile Chino APK es seguro?</h4>
-<p>No podemos garantizar al 100% que FIFA Mobile Chino APK sea seguro. Al no ser una versión oficial ni estar disponible en las tiendas oficiales de aplicaciones, existe el riesgo de que el archivo APK o IPA contenga virus o malware que puedan dañar tu dispositivo o comprometer tu seguridad. Por eso, te recomendamos que verifiques la fuente de descarga del archivo y que uses un antivirus o un firewall para proteger tu dispositivo.</p>
- <h4>¿FIFA Mobile Chino APK está en español?</h4>
-<p>No, FIFA Mobile Chino APK no está en español. El idioma principal del juego es el chino mandarín, aunque también tiene algunos elementos en inglés. No hay opción para cambiar el idioma del juego al español u otro idioma. Por eso, si no entiendes el chino o el inglés, puede que tengas dificultades para jugar o disfrutar del juego.</p>
- <h4>¿FIFA Mobile Chino APK se puede jugar con otros usuarios?</h4>
-<p>Sí, FIFA Mobile Chino APK se puede jugar con otros usuarios. El juego tiene un modo multijugador que te permite enfrentarte a otros jugadores en partidos online, ya sea en el modo versus, el modo ataque o el modo torneo. También puedes unirte a una liga o un club para cooperar o competir con otros usuarios, y participar en eventos y actividades especiales que te dan la oportunidad de ganar recompensas y reconocimientos.</p>
- <h4>¿FIFA Mobile Chino APK se actualiza con frecuencia?</h4>
-<p>Sí, FIFA Mobile Chino APK se actualiza con frecuencia. Los desarrolladores del juego suelen lanzar nuevas versiones del archivo APK o IPA cada cierto tiempo, para añadir nuevas características, opciones, eventos, jugadores y correcciones de errores. Por eso, te recomendamos que estés atento a las novedades y que descargues la última versión disponible para disfrutar de la mejor experiencia de juego.</p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/schedulers/scheduling_unclip.py

@@ -1,303 +0,0 @@
-# Copyright 2022 Kakao Brain and 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 math
-from dataclasses import dataclass
-from typing import Optional, Tuple, Union
-
-import numpy as np
-import paddle
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from ..utils import BaseOutput
-from .scheduling_utils import SchedulerMixin
-
-
-@dataclass
-# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->UnCLIP
-class UnCLIPSchedulerOutput(BaseOutput):
-    """
-    Output class for the scheduler's step function output.
-
-    Args:
-        prev_sample (`paddle.Tensor` of shape `(batch_size, num_channels, height, width)` for images):
-            Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the
-            denoising loop.
-        pred_original_sample (`paddle.Tensor` of shape `(batch_size, num_channels, height, width)` for images):
-            The predicted denoised sample (x_{0}) based on the model output from the current timestep.
-            `pred_original_sample` can be used to preview progress or for guidance.
-    """
-
-    prev_sample: paddle.Tensor
-    pred_original_sample: Optional[paddle.Tensor] = None
-
-
-def betas_for_alpha_bar(num_diffusion_timesteps, max_beta=0.999):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
-    (1-beta) over time from t = [0,1].
-
-    Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
-    to that part of the diffusion process.
-
-
-    Args:
-        num_diffusion_timesteps (`int`): the number of betas to produce.
-        max_beta (`float`): the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-
-    Returns:
-        betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
-    """
-
-    def alpha_bar(time_step):
-        return math.cos((time_step + 0.008) / 1.008 * math.pi / 2) ** 2
-
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
-    return paddle.to_tensor(betas, dtype=paddle.float32)
-
-
-class UnCLIPScheduler(SchedulerMixin, ConfigMixin):
-    """
-    This is a modified DDPM Scheduler specifically for the karlo unCLIP model.
-
-    This scheduler has some minor variations in how it calculates the learned range variance and dynamically
-    re-calculates betas based off the timesteps it is skipping.
-
-    The scheduler also uses a slightly different step ratio when computing timesteps to use for inference.
-
-    See [`~DDPMScheduler`] for more information on DDPM scheduling
-
-    Args:
-        num_train_timesteps (`int`): number of diffusion steps used to train the model.
-        variance_type (`str`):
-            options to clip the variance used when adding noise to the denoised sample. Choose from `fixed_small_log`
-            or `learned_range`.
-        clip_sample (`bool`, default `True`):
-            option to clip predicted sample between `-clip_sample_range` and `clip_sample_range` for numerical
-            stability.
-        clip_sample_range (`float`, default `1.0`):
-            The range to clip the sample between. See `clip_sample`.
-        prediction_type (`str`, default `epsilon`, optional):
-            prediction type of the scheduler function, one of `epsilon` (predicting the noise of the diffusion process)
-            or `sample` (directly predicting the noisy sample`)
-    """
-
-    @register_to_config
-    def __init__(
-        self,
-        num_train_timesteps: int = 1000,
-        variance_type: str = "fixed_small_log",
-        clip_sample: bool = True,
-        clip_sample_range: Optional[float] = 1.0,
-        prediction_type: str = "epsilon",
-    ):
-        # beta scheduler is "squaredcos_cap_v2"
-        self.betas = betas_for_alpha_bar(num_train_timesteps)
-
-        self.alphas = 1.0 - self.betas
-        self.alphas_cumprod = paddle.cumprod(self.alphas, 0)
-        self.one = paddle.to_tensor(1.0)
-
-        # standard deviation of the initial noise distribution
-        self.init_noise_sigma = 1.0
-
-        # setable values
-        self.num_inference_steps = None
-        self.timesteps = paddle.to_tensor(np.arange(0, num_train_timesteps)[::-1].copy())
-
-        self.variance_type = variance_type
-
-    def scale_model_input(self, sample: paddle.Tensor, timestep: Optional[int] = None) -> paddle.Tensor:
-        """
-        Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
-        current timestep.
-
-        Args:
-            sample (`paddle.Tensor`): input sample
-            timestep (`int`, optional): current timestep
-
-        Returns:
-            `paddle.Tensor`: scaled input sample
-        """
-        return sample
-
-    def set_timesteps(self, num_inference_steps: int):
-        """
-        Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
-
-        Note that this scheduler uses a slightly different step ratio than the other diffusers schedulers. The
-        different step ratio is to mimic the original karlo implementation and does not affect the quality or accuracy
-        of the results.
-
-        Args:
-            num_inference_steps (`int`):
-                the number of diffusion steps used when generating samples with a pre-trained model.
-        """
-        self.num_inference_steps = num_inference_steps
-        step_ratio = (self.config.num_train_timesteps - 1) / (self.num_inference_steps - 1)
-        timesteps = (np.arange(0, num_inference_steps) * step_ratio).round()[::-1].copy().astype(np.int64)
-        self.timesteps = paddle.to_tensor(timesteps)
-
-    def _get_variance(self, t, prev_timestep=None, predicted_variance=None, variance_type=None):
-        if prev_timestep is None:
-            prev_timestep = t - 1
-
-        alpha_prod_t = self.alphas_cumprod[t]
-        alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one
-        beta_prod_t = 1 - alpha_prod_t
-        beta_prod_t_prev = 1 - alpha_prod_t_prev
-
-        if prev_timestep == t - 1:
-            beta = self.betas[t]
-        else:
-            beta = 1 - alpha_prod_t / alpha_prod_t_prev
-
-        # For t > 0, compute predicted variance βt (see formula (6) and (7) from https://arxiv.org/pdf/2006.11239.pdf)
-        # and sample from it to get previous sample
-        # x_{t-1} ~ N(pred_prev_sample, variance) == add variance to pred_sample
-        variance = beta_prod_t_prev / beta_prod_t * beta
-
-        if variance_type is None:
-            variance_type = self.config.variance_type
-
-        # hacks - were probably added for training stability
-        if variance_type == "fixed_small_log":
-            variance = paddle.log(paddle.clip(variance, min=1e-20))
-            variance = paddle.exp(0.5 * variance)
-        elif variance_type == "learned_range":
-            # NOTE difference with DDPM scheduler
-            min_log = variance.log()
-            max_log = beta.log()
-
-            frac = (predicted_variance + 1) / 2
-            variance = frac * max_log + (1 - frac) * min_log
-
-        return variance
-
-    def step(
-        self,
-        model_output: paddle.Tensor,
-        timestep: int,
-        sample: paddle.Tensor,
-        prev_timestep: Optional[int] = None,
-        generator=None,
-        return_dict: bool = True,
-    ) -> Union[UnCLIPSchedulerOutput, Tuple]:
-        """
-        Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
-        process from the learned model outputs (most often the predicted noise).
-
-        Args:
-            model_output (`paddle.Tensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            sample (`paddle.Tensor`):
-                current instance of sample being created by diffusion process.
-            prev_timestep (`int`, *optional*): The previous timestep to predict the previous sample at.
-                Used to dynamically compute beta. If not given, `t-1` is used and the pre-computed beta is used.
-            generator: random number generator.
-            return_dict (`bool`): option for returning tuple rather than UnCLIPSchedulerOutput class
-
-        Returns:
-            [`~schedulers.scheduling_utils.UnCLIPSchedulerOutput`] or `tuple`:
-            [`~schedulers.scheduling_utils.UnCLIPSchedulerOutput`] if `return_dict` is True, otherwise a `tuple`. When
-            returning a tuple, the first element is the sample tensor.
-
-        """
-
-        t = timestep
-
-        if model_output.shape[1] == sample.shape[1] * 2 and self.variance_type == "learned_range":
-            model_output, predicted_variance = model_output.split(
-                [sample.shape[1], model_output.shape[1] - sample.shape[1]], axis=1
-            )
-        else:
-            predicted_variance = None
-
-        # 1. compute alphas, betas
-        if prev_timestep is None:
-            prev_timestep = t - 1
-
-        alpha_prod_t = self.alphas_cumprod[t]
-        alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one
-        beta_prod_t = 1 - alpha_prod_t
-        beta_prod_t_prev = 1 - alpha_prod_t_prev
-
-        if prev_timestep == t - 1:
-            beta = self.betas[t]
-            alpha = self.alphas[t]
-        else:
-            beta = 1 - alpha_prod_t / alpha_prod_t_prev
-            alpha = 1 - beta
-
-        # 2. compute predicted original sample from predicted noise also called
-        # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
-        if self.config.prediction_type == "epsilon":
-            pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
-        elif self.config.prediction_type == "sample":
-            pred_original_sample = model_output
-        else:
-            raise ValueError(
-                f"prediction_type given as {self.config.prediction_type} must be one of `epsilon` or `sample`"
-                " for the UnCLIPScheduler."
-            )
-
-        # 3. Clip "predicted x_0"
-        if self.config.clip_sample:
-            pred_original_sample = paddle.clip(
-                pred_original_sample, -self.config.clip_sample_range, self.config.clip_sample_range
-            )
-
-        # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t
-        # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
-        pred_original_sample_coeff = (alpha_prod_t_prev ** (0.5) * beta) / beta_prod_t
-        current_sample_coeff = alpha ** (0.5) * beta_prod_t_prev / beta_prod_t
-
-        # 5. Compute predicted previous sample µ_t
-        # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
-        pred_prev_sample = pred_original_sample_coeff * pred_original_sample + current_sample_coeff * sample
-
-        # 6. Add noise
-        variance = 0
-        if t > 0:
-            variance_noise = paddle.randn(model_output.shape, generator=generator, dtype=model_output.dtype)
-
-            variance = self._get_variance(
-                t,
-                predicted_variance=predicted_variance,
-                prev_timestep=prev_timestep,
-            )
-
-            if self.variance_type == "fixed_small_log":
-                variance = variance
-            elif self.variance_type == "learned_range":
-                variance = (0.5 * variance).exp()
-            else:
-                raise ValueError(
-                    f"variance_type given as {self.variance_type} must be one of `fixed_small_log` or `learned_range`"
-                    " for the UnCLIPScheduler."
-                )
-
-            variance = variance * variance_noise
-
-        pred_prev_sample = pred_prev_sample + variance
-
-        if not return_dict:
-            return (pred_prev_sample,)
-
-        return UnCLIPSchedulerOutput(prev_sample=pred_prev_sample, pred_original_sample=pred_original_sample)

spaces/232labs/VToonify/vtoonify/model/stylegan/lpips/networks_basic.py

@@ -1,187 +0,0 @@
-
-from __future__ import absolute_import
-
-import sys
-import torch
-import torch.nn as nn
-import torch.nn.init as init
-from torch.autograd import Variable
-import numpy as np
-from pdb import set_trace as st
-from skimage import color
-from IPython import embed
-from model.stylegan.lpips import pretrained_networks as pn
-
-import model.stylegan.lpips as util
-
-def spatial_average(in_tens, keepdim=True):
-    return in_tens.mean([2,3],keepdim=keepdim)
-
-def upsample(in_tens, out_H=64): # assumes scale factor is same for H and W
-    in_H = in_tens.shape[2]
-    scale_factor = 1.*out_H/in_H
-
-    return nn.Upsample(scale_factor=scale_factor, mode='bilinear', align_corners=False)(in_tens)
-
-# Learned perceptual metric
-class PNetLin(nn.Module):
-    def __init__(self, pnet_type='vgg', pnet_rand=False, pnet_tune=False, use_dropout=True, spatial=False, version='0.1', lpips=True):
-        super(PNetLin, self).__init__()
-
-        self.pnet_type = pnet_type
-        self.pnet_tune = pnet_tune
-        self.pnet_rand = pnet_rand
-        self.spatial = spatial
-        self.lpips = lpips
-        self.version = version
-        self.scaling_layer = ScalingLayer()
-
-        if(self.pnet_type in ['vgg','vgg16']):
-            net_type = pn.vgg16
-            self.chns = [64,128,256,512,512]
-        elif(self.pnet_type=='alex'):
-            net_type = pn.alexnet
-            self.chns = [64,192,384,256,256]
-        elif(self.pnet_type=='squeeze'):
-            net_type = pn.squeezenet
-            self.chns = [64,128,256,384,384,512,512]
-        self.L = len(self.chns)
-
-        self.net = net_type(pretrained=not self.pnet_rand, requires_grad=self.pnet_tune)
-
-        if(lpips):
-            self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout)
-            self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout)
-            self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout)
-            self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout)
-            self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout)
-            self.lins = [self.lin0,self.lin1,self.lin2,self.lin3,self.lin4]
-            if(self.pnet_type=='squeeze'): # 7 layers for squeezenet
-                self.lin5 = NetLinLayer(self.chns[5], use_dropout=use_dropout)
-                self.lin6 = NetLinLayer(self.chns[6], use_dropout=use_dropout)
-                self.lins+=[self.lin5,self.lin6]
-
-    def forward(self, in0, in1, retPerLayer=False):
-        # v0.0 - original release had a bug, where input was not scaled
-        in0_input, in1_input = (self.scaling_layer(in0), self.scaling_layer(in1)) if self.version=='0.1' else (in0, in1)
-        outs0, outs1 = self.net.forward(in0_input), self.net.forward(in1_input)
-        feats0, feats1, diffs = {}, {}, {}
-
-        for kk in range(self.L):
-            feats0[kk], feats1[kk] = util.normalize_tensor(outs0[kk]), util.normalize_tensor(outs1[kk])
-            diffs[kk] = (feats0[kk]-feats1[kk])**2
-
-        if(self.lpips):
-            if(self.spatial):
-                res = [upsample(self.lins[kk].model(diffs[kk]), out_H=in0.shape[2]) for kk in range(self.L)]
-            else:
-                res = [spatial_average(self.lins[kk].model(diffs[kk]), keepdim=True) for kk in range(self.L)]
-        else:
-            if(self.spatial):
-                res = [upsample(diffs[kk].sum(dim=1,keepdim=True), out_H=in0.shape[2]) for kk in range(self.L)]
-            else:
-                res = [spatial_average(diffs[kk].sum(dim=1,keepdim=True), keepdim=True) for kk in range(self.L)]
-
-        val = res[0]
-        for l in range(1,self.L):
-            val += res[l]
-        
-        if(retPerLayer):
-            return (val, res)
-        else:
-            return val
-
-class ScalingLayer(nn.Module):
-    def __init__(self):
-        super(ScalingLayer, self).__init__()
-        self.register_buffer('shift', torch.Tensor([-.030,-.088,-.188])[None,:,None,None])
-        self.register_buffer('scale', torch.Tensor([.458,.448,.450])[None,:,None,None])
-
-    def forward(self, inp):
-        return (inp - self.shift) / self.scale
-
-
-class NetLinLayer(nn.Module):
-    ''' A single linear layer which does a 1x1 conv '''
-    def __init__(self, chn_in, chn_out=1, use_dropout=False):
-        super(NetLinLayer, self).__init__()
-
-        layers = [nn.Dropout(),] if(use_dropout) else []
-        layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1, padding=0, bias=False),]
-        self.model = nn.Sequential(*layers)
-
-
-class Dist2LogitLayer(nn.Module):
-    ''' takes 2 distances, puts through fc layers, spits out value between [0,1] (if use_sigmoid is True) '''
-    def __init__(self, chn_mid=32, use_sigmoid=True):
-        super(Dist2LogitLayer, self).__init__()
-
-        layers = [nn.Conv2d(5, chn_mid, 1, stride=1, padding=0, bias=True),]
-        layers += [nn.LeakyReLU(0.2,True),]
-        layers += [nn.Conv2d(chn_mid, chn_mid, 1, stride=1, padding=0, bias=True),]
-        layers += [nn.LeakyReLU(0.2,True),]
-        layers += [nn.Conv2d(chn_mid, 1, 1, stride=1, padding=0, bias=True),]
-        if(use_sigmoid):
-            layers += [nn.Sigmoid(),]
-        self.model = nn.Sequential(*layers)
-
-    def forward(self,d0,d1,eps=0.1):
-        return self.model.forward(torch.cat((d0,d1,d0-d1,d0/(d1+eps),d1/(d0+eps)),dim=1))
-
-class BCERankingLoss(nn.Module):
-    def __init__(self, chn_mid=32):
-        super(BCERankingLoss, self).__init__()
-        self.net = Dist2LogitLayer(chn_mid=chn_mid)
-        # self.parameters = list(self.net.parameters())
-        self.loss = torch.nn.BCELoss()
-
-    def forward(self, d0, d1, judge):
-        per = (judge+1.)/2.
-        self.logit = self.net.forward(d0,d1)
-        return self.loss(self.logit, per)
-
-# L2, DSSIM metrics
-class FakeNet(nn.Module):
-    def __init__(self, use_gpu=True, colorspace='Lab'):
-        super(FakeNet, self).__init__()
-        self.use_gpu = use_gpu
-        self.colorspace=colorspace
-
-class L2(FakeNet):
-
-    def forward(self, in0, in1, retPerLayer=None):
-        assert(in0.size()[0]==1) # currently only supports batchSize 1
-
-        if(self.colorspace=='RGB'):
-            (N,C,X,Y) = in0.size()
-            value = torch.mean(torch.mean(torch.mean((in0-in1)**2,dim=1).view(N,1,X,Y),dim=2).view(N,1,1,Y),dim=3).view(N)
-            return value
-        elif(self.colorspace=='Lab'):
-            value = util.l2(util.tensor2np(util.tensor2tensorlab(in0.data,to_norm=False)), 
-                util.tensor2np(util.tensor2tensorlab(in1.data,to_norm=False)), range=100.).astype('float')
-            ret_var = Variable( torch.Tensor((value,) ) )
-            if(self.use_gpu):
-                ret_var = ret_var.cuda()
-            return ret_var
-
-class DSSIM(FakeNet):
-
-    def forward(self, in0, in1, retPerLayer=None):
-        assert(in0.size()[0]==1) # currently only supports batchSize 1
-
-        if(self.colorspace=='RGB'):
-            value = util.dssim(1.*util.tensor2im(in0.data), 1.*util.tensor2im(in1.data), range=255.).astype('float')
-        elif(self.colorspace=='Lab'):
-            value = util.dssim(util.tensor2np(util.tensor2tensorlab(in0.data,to_norm=False)), 
-                util.tensor2np(util.tensor2tensorlab(in1.data,to_norm=False)), range=100.).astype('float')
-        ret_var = Variable( torch.Tensor((value,) ) )
-        if(self.use_gpu):
-            ret_var = ret_var.cuda()
-        return ret_var
-
-def print_network(net):
-    num_params = 0
-    for param in net.parameters():
-        num_params += param.numel()
-    print('Network',net)
-    print('Total number of parameters: %d' % num_params)

spaces/A00001/bingothoo/src/components/chat-attachments.tsx

@@ -1,37 +0,0 @@
-import Image from 'next/image'
-import ClearIcon from '@/assets/images/clear.svg'
-import RefreshIcon from '@/assets/images/refresh.svg'
-import { FileItem } from '@/lib/bots/bing/types'
-import { cn } from '@/lib/utils'
-import { useBing } from '@/lib/hooks/use-bing'
-
-type ChatAttachmentsProps = Pick<ReturnType<typeof useBing>, 'attachmentList' | 'setAttachmentList' | 'uploadImage'>
-
-export function ChatAttachments({ attachmentList = [], setAttachmentList, uploadImage }: ChatAttachmentsProps) {
-  return attachmentList.length ? (
-    <div className="attachment-list">
-      {attachmentList.map(file => (
-        <div className="file-item" key={file.url}>
-          {file.status === 'loading' && (
-            <div className="loading">
-              <div className="bar" />
-            </div>)
-          }
-          {file.status !== 'error' && (
-            <div className="thumbnail">
-              <img draggable="false" src={file.url} />
-            </div>)
-          }
-          {file.status === 'error' && (
-            <div className="error">
-              <Image alt="refresh" src={RefreshIcon} width={18} onClick={() => uploadImage(file.url)} />
-            </div>
-          )}
-          <button className={cn('dismiss', { 'no-file': file.status === 'error' })} type="button">
-            <Image alt="clear" src={ClearIcon} width={16} onClick={() => setAttachmentList([])} />
-          </button>
-        </div>
-      ))}
-    </div>
-  ) : null
-}

spaces/AIConsultant/MusicGen/audiocraft/metrics/rvm.py

@@ -1,106 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import typing as tp
-import torch
-from torch import nn
-import torchaudio
-
-
-def db_to_scale(volume: tp.Union[float, torch.Tensor]):
-    return 10 ** (volume / 20)
-
-
-def scale_to_db(scale: torch.Tensor, min_volume: float = -120):
-    min_scale = db_to_scale(min_volume)
-    return 20 * torch.log10(scale.clamp(min=min_scale))
-
-
-class RelativeVolumeMel(nn.Module):
-    """Relative volume melspectrogram measure.
-
-    Computes a measure of distance over two mel spectrogram that is interpretable in terms
-    of decibels. Given `x_ref` and `x_est` two waveforms of shape `[*, T]`, it will
-    first renormalize both by the ground truth of `x_ref`.
-
-    Then it computes the mel spectrogram `z_ref` and `z_est` and compute volume of the difference
-    relative to the volume of `z_ref` for each time-frequency bin. It further adds some limits, e.g.
-    clamping the values between -25 and 25 dB (controlled by `min_relative_volume` and `max_relative_volume`)
-    with the goal of avoiding the loss being dominated by parts where the reference is almost silent.
-    Indeed, volumes in dB can take unbounded values both towards -oo and +oo, which can make the final
-    average metric harder to interpret. Besides, anything below -30 dB of attenuation would sound extremely
-    good (for a neural network output, although sound engineers typically aim for much lower attenuations).
-    Similarly, anything above +30 dB would just be completely missing the target, and there is no point
-    in measuring by exactly how much it missed it. -25, 25 is a more conservative range, but also more
-    in line with what neural nets currently can achieve.
-
-    For instance, a Relative Volume Mel (RVM) score of -10 dB means that on average, the delta between
-    the target and reference mel-spec is 10 dB lower than the reference mel-spec value.
-
-    The metric can be aggregated over a given frequency band in order have different insights for
-    different region of the spectrum. `num_aggregated_bands` controls the number of bands.
-
-    ..Warning:: While this function is optimized for interpretability, nothing was done to ensure it
-        is numerically stable when computing its gradient. We thus advise against using it as a training loss.
-
-    Args:
-        sample_rate (int): Sample rate of the input audio.
-        n_mels (int): Number of mel bands to use.
-        n_fft (int): Number of frequency bins for the STFT.
-        hop_length (int): Hop length of the STFT and the mel-spectrogram.
-        min_relative_volume (float): The error `z_ref - z_est` volume is given relative to
-            the volume of `z_ref`. If error is smaller than -25 dB of `z_ref`, then it is clamped.
-        max_relative_volume (float): Same as `min_relative_volume` but clamping if the error is larger than that.
-        max_initial_gain (float): When rescaling the audio at the very beginning, we will limit the gain
-            to that amount, to avoid rescaling near silence. Given in dB.
-        min_activity_volume (float): When computing the reference level from `z_ref`, will clamp low volume
-            bins to that amount. This is effectively our "zero" level for the reference mel-spectrogram,
-            and anything below that will be considered equally.
-        num_aggregated_bands (int): Number of bands to keep when computing the average RVM value.
-            For instance, a value of 3 would give 3 scores, roughly for low, mid and high freqs.
-    """
-    def __init__(self, sample_rate: int = 24000, n_mels: int = 80, n_fft: int = 512,
-                 hop_length: int = 128, min_relative_volume: float = -25,
-                 max_relative_volume: float = 25, max_initial_gain: float = 25,
-                 min_activity_volume: float = -25,
-                 num_aggregated_bands: int = 4) -> None:
-        super().__init__()
-        self.melspec = torchaudio.transforms.MelSpectrogram(
-            n_mels=n_mels, n_fft=n_fft, hop_length=hop_length,
-            normalized=True, sample_rate=sample_rate, power=2)
-        self.min_relative_volume = min_relative_volume
-        self.max_relative_volume = max_relative_volume
-        self.max_initial_gain = max_initial_gain
-        self.min_activity_volume = min_activity_volume
-        self.num_aggregated_bands = num_aggregated_bands
-
-    def forward(self, estimate: torch.Tensor, ground_truth: torch.Tensor) -> tp.Dict[str, torch.Tensor]:
-        """Compute RVM metric between estimate and reference samples.
-
-        Args:
-            estimate (torch.Tensor): Estimate sample.
-            ground_truth (torch.Tensor): Reference sample.
-
-        Returns:
-            dict[str, torch.Tensor]: Metrics with keys `rvm` for the overall average, and `rvm_{k}`
-            for the RVM over the k-th band (k=0..num_aggregated_bands - 1).
-        """
-        min_scale = db_to_scale(-self.max_initial_gain)
-        std = ground_truth.pow(2).mean().sqrt().clamp(min=min_scale)
-        z_gt = self.melspec(ground_truth / std).sqrt()
-        z_est = self.melspec(estimate / std).sqrt()
-
-        delta = z_gt - z_est
-        ref_db = scale_to_db(z_gt, self.min_activity_volume)
-        delta_db = scale_to_db(delta.abs(), min_volume=-120)
-        relative_db = (delta_db - ref_db).clamp(self.min_relative_volume, self.max_relative_volume)
-        dims = list(range(relative_db.dim()))
-        dims.remove(dims[-2])
-        losses_per_band = relative_db.mean(dim=dims)
-        aggregated = [chunk.mean() for chunk in losses_per_band.chunk(self.num_aggregated_bands, dim=0)]
-        metrics = {f'rvm_{index}': value for index, value in enumerate(aggregated)}
-        metrics['rvm'] = losses_per_band.mean()
-        return metrics

spaces/AIFILMS/StyleGANEX/models/stylegan2/op/readme.md

@@ -1,12 +0,0 @@
-Code from [rosinality-stylegan2-pytorch-cp](https://github.com/senior-sigan/rosinality-stylegan2-pytorch-cpu)
-
-Scripts to convert rosinality/stylegan2-pytorch to the CPU compatible format
-
-If you would like to use CPU for testing or have a problem regarding the cpp extention (fused and upfirdn2d), please make the following changes:
-
-Change `model.stylegan.op`  to `model.stylegan.op_cpu`
-https://github.com/williamyang1991/VToonify/blob/01b383efc00007f9b069585db41a7d31a77a8806/util.py#L14
-
-https://github.com/williamyang1991/VToonify/blob/01b383efc00007f9b069585db41a7d31a77a8806/model/simple_augment.py#L12
-
-https://github.com/williamyang1991/VToonify/blob/01b383efc00007f9b069585db41a7d31a77a8806/model/stylegan/model.py#L11

spaces/AIGC-Audio/AudioGPT/audio_detection/audio_infer/pytorch/models.py

@@ -1,951 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torchlibrosa.stft import Spectrogram, LogmelFilterBank
-from torchlibrosa.augmentation import SpecAugmentation
-
-from audio_infer.pytorch.pytorch_utils import do_mixup, interpolate, pad_framewise_output
-import os
-import sys
-import math
-import numpy as np
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn.parameter import Parameter
-from torchlibrosa.stft import Spectrogram, LogmelFilterBank
-from torchlibrosa.augmentation import SpecAugmentation
-from audio_infer.pytorch.pytorch_utils import do_mixup
-import torch.utils.checkpoint as checkpoint
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-import warnings
-from functools import partial
-#from mmdet.models.builder import BACKBONES
-from mmdet.utils import get_root_logger
-from mmcv.runner import load_checkpoint
-os.environ['TORCH_HOME'] = '../pretrained_models'
-from copy import deepcopy
-from timm.models.helpers import load_pretrained
-from torch.cuda.amp import autocast
-from collections import OrderedDict
-import io
-import re
-from mmcv.runner import _load_checkpoint, load_state_dict
-import mmcv.runner
-import copy
-import random
-from einops import rearrange
-from einops.layers.torch import Rearrange, Reduce
-from torch import nn, einsum
-
-
-def load_checkpoint(model,
-                    filename,
-                    map_location=None,
-                    strict=False,
-                    logger=None,
-                    revise_keys=[(r'^module\.', '')]):
-    """Load checkpoint from a file or URI.
-
-    Args:
-        model (Module): Module to load checkpoint.
-        filename (str): Accept local filepath, URL, ``torchvision://xxx``,
-            ``open-mmlab://xxx``. Please refer to ``docs/model_zoo.md`` for
-            details.
-        map_location (str): Same as :func:`torch.load`.
-        strict (bool): Whether to allow different params for the model and
-            checkpoint.
-        logger (:mod:`logging.Logger` or None): The logger for error message.
-        revise_keys (list): A list of customized keywords to modify the
-            state_dict in checkpoint. Each item is a (pattern, replacement)
-            pair of the regular expression operations. Default: strip
-            the prefix 'module.' by [(r'^module\\.', '')].
-
-    Returns:
-        dict or OrderedDict: The loaded checkpoint.
-    """
-
-    checkpoint = _load_checkpoint(filename, map_location, logger)
-    new_proj = torch.nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(4, 4), padding=(2, 2))
-    new_proj.weight = torch.nn.Parameter(torch.sum(checkpoint['patch_embed1.proj.weight'], dim=1).unsqueeze(1))
-    checkpoint['patch_embed1.proj.weight'] = new_proj.weight
-    # OrderedDict is a subclass of dict
-    if not isinstance(checkpoint, dict):
-        raise RuntimeError(
-            f'No state_dict found in checkpoint file {filename}')
-    # get state_dict from checkpoint
-    if 'state_dict' in checkpoint:
-        state_dict = checkpoint['state_dict']
-    else:
-        state_dict = checkpoint
-
-    # strip prefix of state_dict
-    metadata = getattr(state_dict, '_metadata', OrderedDict())
-    for p, r in revise_keys:
-        state_dict = OrderedDict(
-            {re.sub(p, r, k): v
-             for k, v in state_dict.items()})
-    state_dict = OrderedDict({k.replace('backbone.',''):v for k,v in state_dict.items()})
-    # Keep metadata in state_dict
-    state_dict._metadata = metadata
-
-    # load state_dict
-    load_state_dict(model, state_dict, strict, logger)
-    return checkpoint
-
-def init_layer(layer):
-    """Initialize a Linear or Convolutional layer. """
-    nn.init.xavier_uniform_(layer.weight)
- 
-    if hasattr(layer, 'bias'):
-        if layer.bias is not None:
-            layer.bias.data.fill_(0.)
-            
-    
-def init_bn(bn):
-    """Initialize a Batchnorm layer. """
-    bn.bias.data.fill_(0.)
-    bn.weight.data.fill_(1.)
-
-
-
-
-class TimeShift(nn.Module):
-    def __init__(self, mean, std):
-        super().__init__()
-        self.mean = mean
-        self.std = std
-
-    def forward(self, x):
-        if self.training:
-            shift = torch.empty(1).normal_(self.mean, self.std).int().item()
-            x = torch.roll(x, shift, dims=2)
-        return x
-
-class LinearSoftPool(nn.Module):
-    """LinearSoftPool
-    Linear softmax, takes logits and returns a probability, near to the actual maximum value.
-    Taken from the paper:
-        A Comparison of Five Multiple Instance Learning Pooling Functions for Sound Event Detection with Weak Labeling
-    https://arxiv.org/abs/1810.09050
-    """
-    def __init__(self, pooldim=1):
-        super().__init__()
-        self.pooldim = pooldim
-
-    def forward(self, logits, time_decision):
-        return (time_decision**2).sum(self.pooldim) / time_decision.sum(
-            self.pooldim)
-
-class PVT(nn.Module):
-    def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, 
-        fmax, classes_num):
-        
-        super(PVT, self).__init__()
-
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-        ref = 1.0
-        amin = 1e-10
-        top_db = None
-
-        # Spectrogram extractor
-        self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, 
-            win_length=window_size, window=window, center=center, pad_mode=pad_mode, 
-            freeze_parameters=True)
-
-        # Logmel feature extractor
-        self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, 
-            n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, 
-            freeze_parameters=True)
-
-        self.time_shift = TimeShift(0, 10)
-        # Spec augmenter
-        self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, 
-            freq_drop_width=8, freq_stripes_num=2)
- 
-        self.bn0 = nn.BatchNorm2d(64)
-        self.pvt_transformer = PyramidVisionTransformerV2(tdim=1001,
-                                fdim=64,
-                                patch_size=7,
-                                stride=4,
-                                in_chans=1,
-                                num_classes=classes_num,
-                                embed_dims=[64, 128, 320, 512],
-                                depths=[3, 4, 6, 3],
-                                num_heads=[1, 2, 5, 8],
-                                mlp_ratios=[8, 8, 4, 4],
-                                qkv_bias=True,
-                                qk_scale=None,
-                                drop_rate=0.0,
-                                drop_path_rate=0.1,
-                                sr_ratios=[8, 4, 2, 1],
-                                norm_layer=partial(nn.LayerNorm, eps=1e-6),
-                                num_stages=4,
-                                #pretrained='https://github.com/whai362/PVT/releases/download/v2/pvt_v2_b2.pth'
-                                )
-        #self.temp_pool = LinearSoftPool()  
-        self.avgpool = nn.AdaptiveAvgPool1d(1)    
-        self.fc_audioset = nn.Linear(512, classes_num, bias=True)
-
-        self.init_weights()
-
-    def init_weights(self):
-        init_bn(self.bn0)
-        init_layer(self.fc_audioset)
-
-    def forward(self, input, mixup_lambda=None):
-        """Input: (batch_size, times_steps, freq_bins)"""
-        
-        interpolate_ratio = 32
-
-        x = self.spectrogram_extractor(input)   # (batch_size, 1, time_steps, freq_bins)
-        x = self.logmel_extractor(x)    # (batch_size, 1, time_steps, mel_bins)
-        frames_num = x.shape[2]
-        x = x.transpose(1, 3)
-        x = self.bn0(x)
-        x = x.transpose(1, 3)
-        
-        if self.training:
-            x = self.time_shift(x)
-            x = self.spec_augmenter(x)
-
-        # Mixup on spectrogram
-        if self.training and mixup_lambda is not None:
-            x = do_mixup(x, mixup_lambda)
-        #print(x.shape)   #torch.Size([10, 1, 1001, 64])
-        x = self.pvt_transformer(x)
-        #print(x.shape)   #torch.Size([10, 800, 128])
-        x = torch.mean(x, dim=3)
-
-        x = x.transpose(1, 2).contiguous()
-        framewise_output = torch.sigmoid(self.fc_audioset(x))
-        #clipwise_output = torch.mean(framewise_output, dim=1)
-        #clipwise_output = self.temp_pool(x, framewise_output).clamp(1e-7, 1.).squeeze(1)
-        x = framewise_output.transpose(1, 2).contiguous()
-        x = self.avgpool(x)
-        clipwise_output = torch.flatten(x, 1)
-        #print(framewise_output.shape)    #torch.Size([10, 100, 17])
-        framewise_output = interpolate(framewise_output, interpolate_ratio)
-        #framewise_output = framewise_output[:,:1000,:]
-        #framewise_output = pad_framewise_output(framewise_output, frames_num)
-        output_dict = {'framewise_output': framewise_output, 
-            'clipwise_output': clipwise_output}
-            
-        return output_dict
-
-class PVT2(nn.Module):
-    def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, 
-        fmax, classes_num):
-        
-        super(PVT2, self).__init__()
-
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-        ref = 1.0
-        amin = 1e-10
-        top_db = None
-
-        # Spectrogram extractor
-        self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, 
-            win_length=window_size, window=window, center=center, pad_mode=pad_mode, 
-            freeze_parameters=True)
-
-        # Logmel feature extractor
-        self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, 
-            n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, 
-            freeze_parameters=True)
-
-        self.time_shift = TimeShift(0, 10)
-        # Spec augmenter
-        self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, 
-            freq_drop_width=8, freq_stripes_num=2)
- 
-        self.bn0 = nn.BatchNorm2d(64)
-        self.pvt_transformer = PyramidVisionTransformerV2(tdim=1001,
-                                fdim=64,
-                                patch_size=7,
-                                stride=4,
-                                in_chans=1,
-                                num_classes=classes_num,
-                                embed_dims=[64, 128, 320, 512],
-                                depths=[3, 4, 6, 3],
-                                num_heads=[1, 2, 5, 8],
-                                mlp_ratios=[8, 8, 4, 4],
-                                qkv_bias=True,
-                                qk_scale=None,
-                                drop_rate=0.0,
-                                drop_path_rate=0.1,
-                                sr_ratios=[8, 4, 2, 1],
-                                norm_layer=partial(nn.LayerNorm, eps=1e-6),
-                                num_stages=4,
-                                pretrained='https://github.com/whai362/PVT/releases/download/v2/pvt_v2_b2.pth'
-                                )
-        #self.temp_pool = LinearSoftPool()      
-        self.fc_audioset = nn.Linear(512, classes_num, bias=True)
-
-        self.init_weights()
-
-    def init_weights(self):
-        init_bn(self.bn0)
-        init_layer(self.fc_audioset)
-
-    def forward(self, input, mixup_lambda=None):
-        """Input: (batch_size, times_steps, freq_bins)"""
-        
-        interpolate_ratio = 32
-
-        x = self.spectrogram_extractor(input)   # (batch_size, 1, time_steps, freq_bins)
-        x = self.logmel_extractor(x)    # (batch_size, 1, time_steps, mel_bins)
-        frames_num = x.shape[2]
-        x = x.transpose(1, 3)
-        x = self.bn0(x)
-        x = x.transpose(1, 3)
-        
-        if self.training:
-            #x = self.time_shift(x)
-            x = self.spec_augmenter(x)
-
-        # Mixup on spectrogram
-        if self.training and mixup_lambda is not None:
-            x = do_mixup(x, mixup_lambda)
-        #print(x.shape)   #torch.Size([10, 1, 1001, 64])
-        x = self.pvt_transformer(x)
-        #print(x.shape)   #torch.Size([10, 800, 128])
-        x = torch.mean(x, dim=3)
-
-        x = x.transpose(1, 2).contiguous()
-        framewise_output = torch.sigmoid(self.fc_audioset(x))
-        clipwise_output = torch.mean(framewise_output, dim=1)
-        #clipwise_output = self.temp_pool(x, framewise_output).clamp(1e-7, 1.).squeeze(1)
-        #print(framewise_output.shape)    #torch.Size([10, 100, 17])
-        framewise_output = interpolate(framewise_output, interpolate_ratio)
-        #framewise_output = framewise_output[:,:1000,:]
-        #framewise_output = pad_framewise_output(framewise_output, frames_num)
-        output_dict = {'framewise_output': framewise_output, 
-            'clipwise_output': clipwise_output}
-            
-        return output_dict
-
-class PVT_2layer(nn.Module):
-    def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, 
-        fmax, classes_num):
-        
-        super(PVT_2layer, self).__init__()
-
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-        ref = 1.0
-        amin = 1e-10
-        top_db = None
-
-        # Spectrogram extractor
-        self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, 
-            win_length=window_size, window=window, center=center, pad_mode=pad_mode, 
-            freeze_parameters=True)
-
-        # Logmel feature extractor
-        self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, 
-            n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, 
-            freeze_parameters=True)
-
-        self.time_shift = TimeShift(0, 10)
-        # Spec augmenter
-        self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, 
-            freq_drop_width=8, freq_stripes_num=2)
- 
-        self.bn0 = nn.BatchNorm2d(64)
-        self.pvt_transformer = PyramidVisionTransformerV2(tdim=1001,
-                                fdim=64,
-                                patch_size=7,
-                                stride=4,
-                                in_chans=1,
-                                num_classes=classes_num,
-                                embed_dims=[64, 128],
-                                depths=[3, 4],
-                                num_heads=[1, 2],
-                                mlp_ratios=[8, 8],
-                                qkv_bias=True,
-                                qk_scale=None,
-                                drop_rate=0.0,
-                                drop_path_rate=0.1,
-                                sr_ratios=[8, 4],
-                                norm_layer=partial(nn.LayerNorm, eps=1e-6),
-                                num_stages=2,
-                                pretrained='https://github.com/whai362/PVT/releases/download/v2/pvt_v2_b2.pth'
-                                )
-        #self.temp_pool = LinearSoftPool()  
-        self.avgpool = nn.AdaptiveAvgPool1d(1)    
-        self.fc_audioset = nn.Linear(128, classes_num, bias=True)
-
-        self.init_weights()
-
-    def init_weights(self):
-        init_bn(self.bn0)
-        init_layer(self.fc_audioset)
-
-    def forward(self, input, mixup_lambda=None):
-        """Input: (batch_size, times_steps, freq_bins)"""
-        
-        interpolate_ratio = 8
-
-        x = self.spectrogram_extractor(input)   # (batch_size, 1, time_steps, freq_bins)
-        x = self.logmel_extractor(x)    # (batch_size, 1, time_steps, mel_bins)
-        frames_num = x.shape[2]
-        x = x.transpose(1, 3)
-        x = self.bn0(x)
-        x = x.transpose(1, 3)
-        
-        if self.training:
-            x = self.time_shift(x)
-            x = self.spec_augmenter(x)
-
-        # Mixup on spectrogram
-        if self.training and mixup_lambda is not None:
-            x = do_mixup(x, mixup_lambda)
-        #print(x.shape)   #torch.Size([10, 1, 1001, 64])
-        x = self.pvt_transformer(x)
-        #print(x.shape)   #torch.Size([10, 800, 128])
-        x = torch.mean(x, dim=3)
-
-        x = x.transpose(1, 2).contiguous()
-        framewise_output = torch.sigmoid(self.fc_audioset(x))
-        #clipwise_output = torch.mean(framewise_output, dim=1)
-        #clipwise_output = self.temp_pool(x, framewise_output).clamp(1e-7, 1.).squeeze(1)
-        x = framewise_output.transpose(1, 2).contiguous()
-        x = self.avgpool(x)
-        clipwise_output = torch.flatten(x, 1)
-        #print(framewise_output.shape)    #torch.Size([10, 100, 17])
-        framewise_output = interpolate(framewise_output, interpolate_ratio)
-        #framewise_output = framewise_output[:,:1000,:]
-        #framewise_output = pad_framewise_output(framewise_output, frames_num)
-        output_dict = {'framewise_output': framewise_output, 
-            'clipwise_output': clipwise_output}
-            
-        return output_dict
-
-class PVT_lr(nn.Module):
-    def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, 
-        fmax, classes_num):
-        
-        super(PVT_lr, self).__init__()
-
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-        ref = 1.0
-        amin = 1e-10
-        top_db = None
-
-        # Spectrogram extractor
-        self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, 
-            win_length=window_size, window=window, center=center, pad_mode=pad_mode, 
-            freeze_parameters=True)
-
-        # Logmel feature extractor
-        self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, 
-            n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, 
-            freeze_parameters=True)
-
-        self.time_shift = TimeShift(0, 10)
-        # Spec augmenter
-        self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, 
-            freq_drop_width=8, freq_stripes_num=2)
- 
-        self.bn0 = nn.BatchNorm2d(64)
-        self.pvt_transformer = PyramidVisionTransformerV2(tdim=1001,
-                                fdim=64,
-                                patch_size=7,
-                                stride=4,
-                                in_chans=1,
-                                num_classes=classes_num,
-                                embed_dims=[64, 128, 320, 512],
-                                depths=[3, 4, 6, 3],
-                                num_heads=[1, 2, 5, 8],
-                                mlp_ratios=[8, 8, 4, 4],
-                                qkv_bias=True,
-                                qk_scale=None,
-                                drop_rate=0.0,
-                                drop_path_rate=0.1,
-                                sr_ratios=[8, 4, 2, 1],
-                                norm_layer=partial(nn.LayerNorm, eps=1e-6),
-                                num_stages=4,
-                                pretrained='https://github.com/whai362/PVT/releases/download/v2/pvt_v2_b2.pth'
-                                )
-        self.temp_pool = LinearSoftPool()      
-        self.fc_audioset = nn.Linear(512, classes_num, bias=True)
-
-        self.init_weights()
-
-    def init_weights(self):
-        init_bn(self.bn0)
-        init_layer(self.fc_audioset)
-
-    def forward(self, input, mixup_lambda=None):
-        """Input: (batch_size, times_steps, freq_bins)"""
-        
-        interpolate_ratio = 32
-
-        x = self.spectrogram_extractor(input)   # (batch_size, 1, time_steps, freq_bins)
-        x = self.logmel_extractor(x)    # (batch_size, 1, time_steps, mel_bins)
-        frames_num = x.shape[2]
-        x = x.transpose(1, 3)
-        x = self.bn0(x)
-        x = x.transpose(1, 3)
-        
-        if self.training:
-            x = self.time_shift(x)
-            x = self.spec_augmenter(x)
-
-        # Mixup on spectrogram
-        if self.training and mixup_lambda is not None:
-            x = do_mixup(x, mixup_lambda)
-        #print(x.shape)   #torch.Size([10, 1, 1001, 64])
-        x = self.pvt_transformer(x)
-        #print(x.shape)   #torch.Size([10, 800, 128])
-        x = torch.mean(x, dim=3)
-
-        x = x.transpose(1, 2).contiguous()
-        framewise_output = torch.sigmoid(self.fc_audioset(x))
-        clipwise_output = self.temp_pool(x, framewise_output).clamp(1e-7, 1.).squeeze(1)
-        #print(framewise_output.shape)    #torch.Size([10, 100, 17])
-        framewise_output = interpolate(framewise_output, interpolate_ratio)
-        #framewise_output = framewise_output[:,:1000,:]
-        #framewise_output = pad_framewise_output(framewise_output, frames_num)
-        output_dict = {'framewise_output': framewise_output, 
-            'clipwise_output': clipwise_output}
-            
-        return output_dict
-
-
-class PVT_nopretrain(nn.Module):
-    def __init__(self, sample_rate, window_size, hop_size, mel_bins, fmin, 
-        fmax, classes_num):
-        
-        super(PVT_nopretrain, self).__init__()
-
-        window = 'hann'
-        center = True
-        pad_mode = 'reflect'
-        ref = 1.0
-        amin = 1e-10
-        top_db = None
-
-        # Spectrogram extractor
-        self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, 
-            win_length=window_size, window=window, center=center, pad_mode=pad_mode, 
-            freeze_parameters=True)
-
-        # Logmel feature extractor
-        self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, 
-            n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, 
-            freeze_parameters=True)
-
-        self.time_shift = TimeShift(0, 10)
-        # Spec augmenter
-        self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, 
-            freq_drop_width=8, freq_stripes_num=2)
- 
-        self.bn0 = nn.BatchNorm2d(64)
-        self.pvt_transformer = PyramidVisionTransformerV2(tdim=1001,
-                                fdim=64,
-                                patch_size=7,
-                                stride=4,
-                                in_chans=1,
-                                num_classes=classes_num,
-                                embed_dims=[64, 128, 320, 512],
-                                depths=[3, 4, 6, 3],
-                                num_heads=[1, 2, 5, 8],
-                                mlp_ratios=[8, 8, 4, 4],
-                                qkv_bias=True,
-                                qk_scale=None,
-                                drop_rate=0.0,
-                                drop_path_rate=0.1,
-                                sr_ratios=[8, 4, 2, 1],
-                                norm_layer=partial(nn.LayerNorm, eps=1e-6),
-                                num_stages=4,
-                                #pretrained='https://github.com/whai362/PVT/releases/download/v2/pvt_v2_b2.pth'
-                                )
-        self.temp_pool = LinearSoftPool()      
-        self.fc_audioset = nn.Linear(512, classes_num, bias=True)
-
-        self.init_weights()
-
-    def init_weights(self):
-        init_bn(self.bn0)
-        init_layer(self.fc_audioset)
-
-    def forward(self, input, mixup_lambda=None):
-        """Input: (batch_size, times_steps, freq_bins)"""
-        
-        interpolate_ratio = 32
-
-        x = self.spectrogram_extractor(input)   # (batch_size, 1, time_steps, freq_bins)
-        x = self.logmel_extractor(x)    # (batch_size, 1, time_steps, mel_bins)
-        frames_num = x.shape[2]
-        x = x.transpose(1, 3)
-        x = self.bn0(x)
-        x = x.transpose(1, 3)
-        
-        if self.training:
-            x = self.time_shift(x)
-            x = self.spec_augmenter(x)
-
-        # Mixup on spectrogram
-        if self.training and mixup_lambda is not None:
-            x = do_mixup(x, mixup_lambda)
-        #print(x.shape)   #torch.Size([10, 1, 1001, 64])
-        x = self.pvt_transformer(x)
-        #print(x.shape)   #torch.Size([10, 800, 128])
-        x = torch.mean(x, dim=3)
-
-        x = x.transpose(1, 2).contiguous()
-        framewise_output = torch.sigmoid(self.fc_audioset(x))
-        clipwise_output = self.temp_pool(x, framewise_output).clamp(1e-7, 1.).squeeze(1)
-        #print(framewise_output.shape)    #torch.Size([10, 100, 17])
-        framewise_output = interpolate(framewise_output, interpolate_ratio)
-        framewise_output = framewise_output[:,:1000,:]
-        #framewise_output = pad_framewise_output(framewise_output, frames_num)
-        output_dict = {'framewise_output': framewise_output, 
-            'clipwise_output': clipwise_output}
-            
-        return output_dict
-
-
-class Mlp(nn.Module):
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0., linear=False):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Linear(in_features, hidden_features)
-        self.dwconv = DWConv(hidden_features)
-        self.act = act_layer()
-        self.fc2 = nn.Linear(hidden_features, out_features)
-        self.drop = nn.Dropout(drop)
-        self.linear = linear
-        if self.linear:
-            self.relu = nn.ReLU()
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-        elif isinstance(m, nn.Conv2d):
-            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
-            fan_out //= m.groups
-            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
-            if m.bias is not None:
-                m.bias.data.zero_()
-
-    def forward(self, x, H, W):
-        x = self.fc1(x)
-        if self.linear:
-            x = self.relu(x)
-        x = self.dwconv(x, H, W)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-
-class Attention(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0., sr_ratio=1, linear=False):
-        super().__init__()
-        assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
-
-        self.dim = dim
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = qk_scale or head_dim ** -0.5
-
-        self.q = nn.Linear(dim, dim, bias=qkv_bias)
-        self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-        self.linear = linear
-        self.sr_ratio = sr_ratio
-        if not linear:
-            if sr_ratio > 1:
-                self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
-                self.norm = nn.LayerNorm(dim)
-        else:
-            self.pool = nn.AdaptiveAvgPool2d(7)
-            self.sr = nn.Conv2d(dim, dim, kernel_size=1, stride=1)
-            self.norm = nn.LayerNorm(dim)
-            self.act = nn.GELU()
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-        elif isinstance(m, nn.Conv2d):
-            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
-            fan_out //= m.groups
-            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
-            if m.bias is not None:
-                m.bias.data.zero_()
-
-    def forward(self, x, H, W):
-        B, N, C = x.shape
-        q = self.q(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
-
-        if not self.linear:
-            if self.sr_ratio > 1:
-                x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
-                x_ = self.sr(x_).reshape(B, C, -1).permute(0, 2, 1)
-                x_ = self.norm(x_)
-                kv = self.kv(x_).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-            else:
-                kv = self.kv(x).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        else:
-            x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
-            x_ = self.sr(self.pool(x_)).reshape(B, C, -1).permute(0, 2, 1)
-            x_ = self.norm(x_)
-            x_ = self.act(x_)
-            kv = self.kv(x_).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        k, v = kv[0], kv[1]
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-
-        return x
-
-
-class Pooling(nn.Module):
-    """
-    Implementation of pooling for PoolFormer
-    --pool_size: pooling size
-    """
-    def __init__(self, pool_size=3):
-        super().__init__()
-        self.pool = nn.AvgPool2d(
-            pool_size, stride=1, padding=pool_size//2, count_include_pad=False)
-
-    def forward(self, x):
-        return self.pool(x) - x
-
-class Block(nn.Module):
-
-    def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
-                 drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm, sr_ratio=1, linear=False):
-        super().__init__()
-        self.norm1 = norm_layer(dim)
-        self.attn = Attention(
-            dim,
-            num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale,
-            attn_drop=attn_drop, proj_drop=drop, sr_ratio=sr_ratio, linear=linear)
-        #self.norm3 = norm_layer(dim)
-        #self.token_mixer = Pooling(pool_size=3)
-        # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = norm_layer(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop, linear=linear)
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-        elif isinstance(m, nn.Conv2d):
-            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
-            fan_out //= m.groups
-            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
-            if m.bias is not None:
-                m.bias.data.zero_()
-
-    def forward(self, x, H, W):
-        x = x + self.drop_path(self.attn(self.norm1(x), H, W))
-        x = x + self.drop_path(self.mlp(self.norm2(x), H, W))
-        return x
-
-
-class OverlapPatchEmbed(nn.Module):
-    """ Image to Patch Embedding
-    """
-
-    def __init__(self, tdim, fdim, patch_size=7, stride=4, in_chans=3, embed_dim=768):
-        super().__init__()
-        img_size = (tdim, fdim)
-        patch_size = to_2tuple(patch_size)
-
-        self.img_size = img_size
-        self.patch_size = patch_size
-        self.H, self.W = img_size[0] // stride, img_size[1] // stride
-        self.num_patches = self.H * self.W
-        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=stride,
-                              padding=(patch_size[0] // 3, patch_size[1] // 3))
-        self.norm = nn.LayerNorm(embed_dim)
-
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-        elif isinstance(m, nn.Conv2d):
-            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
-            fan_out //= m.groups
-            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
-            if m.bias is not None:
-                m.bias.data.zero_()
-
-    def forward(self, x):
-        x = self.proj(x)
-        _, _, H, W = x.shape
-        x = x.flatten(2).transpose(1, 2)
-        x = self.norm(x)
-
-        return x, H, W
-
-
-class PyramidVisionTransformerV2(nn.Module):
-    def __init__(self, tdim=1001, fdim=64, patch_size=16, stride=4, in_chans=3, num_classes=1000, embed_dims=[64, 128, 256, 512],
-                 num_heads=[1, 2, 4, 8], mlp_ratios=[4, 4, 4, 4], qkv_bias=False, qk_scale=None, drop_rate=0.,
-                 attn_drop_rate=0., drop_path_rate=0.1, norm_layer=partial(nn.LayerNorm, eps=1e-6), depths=[3, 4, 6, 3],
-                 sr_ratios=[8, 4, 2, 1], num_stages=2, linear=False, pretrained=None):
-        super().__init__()
-        # self.num_classes = num_classes
-        self.depths = depths
-        self.num_stages = num_stages
-        self.linear = linear
-
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
-        cur = 0
-
-        for i in range(num_stages):
-            patch_embed = OverlapPatchEmbed(tdim=tdim if i == 0 else tdim // (2 ** (i + 1)),
-                                            fdim=fdim if i == 0 else tdim // (2 ** (i + 1)),
-                                            patch_size=7 if i == 0 else 3,
-                                            stride=stride if i == 0 else 2,
-                                            in_chans=in_chans if i == 0 else embed_dims[i - 1],
-                                            embed_dim=embed_dims[i])
-            block = nn.ModuleList([Block(
-                dim=embed_dims[i], num_heads=num_heads[i], mlp_ratio=mlp_ratios[i], qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[cur + j], norm_layer=norm_layer,
-                sr_ratio=sr_ratios[i], linear=linear)
-                for j in range(depths[i])])
-            norm = norm_layer(embed_dims[i])
-            cur += depths[i]
- 
-            setattr(self, f"patch_embed{i + 1}", patch_embed)
-            setattr(self, f"block{i + 1}", block)
-            setattr(self, f"norm{i + 1}", norm)
-        #self.n = nn.Linear(125, 250, bias=True)
-        # classification head
-        # self.head = nn.Linear(embed_dims[3], num_classes) if num_classes > 0 else nn.Identity()
-        self.apply(self._init_weights)
-        self.init_weights(pretrained)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-        elif isinstance(m, nn.Conv2d):
-            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
-            fan_out //= m.groups
-            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
-            if m.bias is not None:
-                m.bias.data.zero_()
-
-    def init_weights(self, pretrained=None):
-        if isinstance(pretrained, str):
-            logger = get_root_logger()
-            load_checkpoint(self, pretrained, map_location='cpu', strict=False, logger=logger)
-
-    def freeze_patch_emb(self):
-        self.patch_embed1.requires_grad = False
-
-    @torch.jit.ignore
-    def no_weight_decay(self):
-        return {'pos_embed1', 'pos_embed2', 'pos_embed3', 'pos_embed4', 'cls_token'}  # has pos_embed may be better
-
-    def get_classifier(self):
-        return self.head
-
-    def reset_classifier(self, num_classes, global_pool=''):
-        self.num_classes = num_classes
-        self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
-
-    def forward_features(self, x):
-        B = x.shape[0]
-
-        for i in range(self.num_stages):
-            patch_embed = getattr(self, f"patch_embed{i + 1}")
-            block = getattr(self, f"block{i + 1}")
-            norm = getattr(self, f"norm{i + 1}")
-            x, H, W = patch_embed(x)
-            #print(x.shape)
-            for blk in block:
-                x = blk(x, H, W)
-            #print(x.shape)
-            x = norm(x)
-            #if i != self.num_stages - 1:
-            x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2).contiguous()
-        #print(x.shape)
-        return x
-
-    def forward(self, x):
-        x = self.forward_features(x)
-        # x = self.head(x)
-
-        return x
-
-class DWConv(nn.Module):
-    def __init__(self, dim=768):
-        super(DWConv, self).__init__()
-        self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, bias=True, groups=dim)
-
-    def forward(self, x, H, W):
-        B, N, C = x.shape
-        x = x.transpose(1, 2).view(B, C, H, W)
-        x = self.dwconv(x)
-        x = x.flatten(2).transpose(1, 2)
-
-        return x
-
-
-def _conv_filter(state_dict, patch_size=16):
-    """ convert patch embedding weight from manual patchify + linear proj to conv"""
-    out_dict = {}
-    for k, v in state_dict.items():
-        if 'patch_embed.proj.weight' in k:
-            v = v.reshape((v.shape[0], 3, patch_size, patch_size))
-        out_dict[k] = v
-
-    return out_dict

spaces/AIGText/GlyphControl/ldm/models/diffusion/ddpm.py

@@ -1,1954 +0,0 @@
-"""
-wild mixture of
-https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
-https://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py
-https://github.com/CompVis/taming-transformers
--- merci
-"""
-
-import torch
-import torch.nn as nn
-import numpy as np
-import pytorch_lightning as pl
-from torch.optim.lr_scheduler import LambdaLR
-from einops import rearrange, repeat
-from contextlib import contextmanager, nullcontext
-from functools import partial
-import itertools
-from tqdm import tqdm
-from torchvision.utils import make_grid
-from pytorch_lightning.utilities.distributed import rank_zero_only
-from omegaconf import ListConfig
-
-from ldm.util import log_txt_as_img, exists, default, ismap, isimage, mean_flat, count_params, instantiate_from_config
-from ldm.modules.ema import LitEma
-from ldm.modules.distributions.distributions import normal_kl, DiagonalGaussianDistribution
-from ldm.models.autoencoder import IdentityFirstStage, AutoencoderKL
-from ldm.modules.diffusionmodules.util import make_beta_schedule, extract_into_tensor, noise_like
-from ldm.models.diffusion.ddim import DDIMSampler
-
-
-__conditioning_keys__ = {'concat': 'c_concat',
-                         'crossattn': 'c_crossattn',
-                         'adm': 'y'}
-
-
-def disabled_train(self, mode=True):
-    """Overwrite model.train with this function to make sure train/eval mode
-    does not change anymore."""
-    return self
-
-
-def uniform_on_device(r1, r2, shape, device):
-    return (r1 - r2) * torch.rand(*shape, device=device) + r2
-
-
-class DDPM(pl.LightningModule):
-    # classic DDPM with Gaussian diffusion, in image space
-    def __init__(self,
-                 unet_config,
-                 timesteps=1000,
-                 beta_schedule="linear",
-                 loss_type="l2",
-                 ckpt_path=None,
-                 ignore_keys=[],
-                 load_only_unet=False,
-                 monitor="val/loss",
-                 use_ema=True,
-                 first_stage_key="image",
-                 image_size=256,
-                 channels=3,
-                 log_every_t=100,
-                 clip_denoised=True,
-                 linear_start=1e-4,
-                 linear_end=2e-2,
-                 cosine_s=8e-3,
-                 given_betas=None,
-                 original_elbo_weight=0.,
-                 v_posterior=0.,  # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta
-                 l_simple_weight=1.,
-                 conditioning_key=None,
-                 parameterization="eps",  # all assuming fixed variance schedules
-                 scheduler_config=None,
-                 use_positional_encodings=False,
-                 learn_logvar=False,
-                 logvar_init=0.,
-                 make_it_fit=False,
-                 ucg_training=None,
-                 reset_ema=False,
-                 reset_num_ema_updates=False,
-                 keep_num_ema_updates=False,
-                 textemb_merge_config=None,
-                 merge_textemb = False,
-                 log_all_grad_norm = False,
-                 ):
-        super().__init__()
-        assert parameterization in ["eps", "x0", "v"], 'currently only supporting "eps" and "x0" and "v"'
-        self.parameterization = parameterization
-        print(f"{self.__class__.__name__}: Running in {self.parameterization}-prediction mode")
-        self.cond_stage_model = None
-        self.clip_denoised = clip_denoised
-        self.log_every_t = log_every_t
-        self.first_stage_key = first_stage_key
-        self.image_size = image_size  # try conv?
-        self.channels = channels
-        self.use_positional_encodings = use_positional_encodings
-        self.model = DiffusionWrapper(unet_config, conditioning_key, textemb_merge_config=textemb_merge_config, merge_textemb=merge_textemb)
-        count_params(self.model, verbose=True)
-        self.use_ema = use_ema
-        if self.use_ema:
-            self.model_ema = LitEma(self.model)
-            print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
-
-        self.use_scheduler = scheduler_config is not None
-        if self.use_scheduler:
-            self.scheduler_config = scheduler_config
-
-        self.v_posterior = v_posterior
-        self.original_elbo_weight = original_elbo_weight
-        self.l_simple_weight = l_simple_weight
-
-        if monitor is not None:
-            self.monitor = monitor
-        self.make_it_fit = make_it_fit
-        if reset_ema: assert exists(ckpt_path)
-        if ckpt_path is not None:
-            ema_num_updates = self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)
-            if reset_ema:
-                assert self.use_ema
-                print(f"Resetting ema to pure model weights. This is useful when restoring from an ema-only checkpoint.")
-                self.model_ema = LitEma(self.model, init_num_updates= ema_num_updates if keep_num_ema_updates else 0)
-        if reset_num_ema_updates:
-            print(" +++++++++++ WARNING: RESETTING NUM_EMA UPDATES TO ZERO +++++++++++ ")
-            assert self.use_ema
-            self.model_ema.reset_num_updates()
-
-        self.register_schedule(given_betas=given_betas, beta_schedule=beta_schedule, timesteps=timesteps,
-                               linear_start=linear_start, linear_end=linear_end, cosine_s=cosine_s)
-
-        self.loss_type = loss_type
-
-        self.learn_logvar = learn_logvar
-        self.logvar = torch.full(fill_value=logvar_init, size=(self.num_timesteps,))
-        if self.learn_logvar:
-            self.logvar = nn.Parameter(self.logvar, requires_grad=True)
-        # else:
-        #     self.register_buffer('logvar', self.logvar)    
-
-        self.ucg_training = ucg_training or dict()
-        if self.ucg_training:
-            self.ucg_prng = np.random.RandomState()
-        self.log_all_grad_norm = log_all_grad_norm
-
-    def register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000,
-                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
-        if exists(given_betas):
-            betas = given_betas
-        else:
-            betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end,
-                                       cosine_s=cosine_s)
-        alphas = 1. - betas
-        alphas_cumprod = np.cumprod(alphas, axis=0)
-        alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1])
-
-        timesteps, = betas.shape
-        self.num_timesteps = int(timesteps)
-        self.linear_start = linear_start
-        self.linear_end = linear_end
-        assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep'
-
-        to_torch = partial(torch.tensor, dtype=torch.float32)
-
-        self.register_buffer('betas', to_torch(betas))
-        self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
-        self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev))
-
-        # calculations for diffusion q(x_t | x_{t-1}) and others
-        self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod)))
-        self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod)))
-        self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod)))
-        self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod)))
-        self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1)))
-
-        # calculations for posterior q(x_{t-1} | x_t, x_0) following IDDPM
-        posterior_variance = (1 - self.v_posterior) * betas * (1. - alphas_cumprod_prev) / (
-                1. - alphas_cumprod) + self.v_posterior * betas
-        # above: equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t)
-        self.register_buffer('posterior_variance', to_torch(posterior_variance))
-        # below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain
-        self.register_buffer('posterior_log_variance_clipped', to_torch(np.log(np.maximum(posterior_variance, 1e-20))))
-        self.register_buffer('posterior_mean_coef1', to_torch(
-            betas * np.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod)))
-        self.register_buffer('posterior_mean_coef2', to_torch(
-            (1. - alphas_cumprod_prev) * np.sqrt(alphas) / (1. - alphas_cumprod)))
-        # weights before the simple loss
-        if self.parameterization == "eps":
-            lvlb_weights = self.betas ** 2 / (
-                    2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod))
-        elif self.parameterization == "x0":
-            lvlb_weights = 0.5 * np.sqrt(torch.Tensor(alphas_cumprod)) / (2. * 1 - torch.Tensor(alphas_cumprod))
-        elif self.parameterization == "v":
-            lvlb_weights = torch.ones_like(self.betas ** 2 / (
-                    2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod)))
-        else:
-            raise NotImplementedError("mu not supported")
-        lvlb_weights[0] = lvlb_weights[1] #?
-        self.register_buffer('lvlb_weights', lvlb_weights, persistent=False)
-        assert not torch.isnan(self.lvlb_weights).all()
-
-    @contextmanager
-    def ema_scope(self, context=None):
-        if self.use_ema:
-            self.model_ema.store(self.model.parameters())
-            self.model_ema.copy_to(self.model)
-            if context is not None:
-                print(f"{context}: Switched to EMA weights")
-        try:
-            yield None
-        finally:
-            if self.use_ema:
-                self.model_ema.restore(self.model.parameters())
-                if context is not None:
-                    print(f"{context}: Restored training weights")
-
-    @torch.no_grad()
-    def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
-        sd = torch.load(path, map_location="cpu")
-        if "state_dict" in list(sd.keys()):
-            sd = sd["state_dict"]
-        keys = list(sd.keys())
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-        if self.make_it_fit:
-            n_params = len([name for name, _ in
-                            itertools.chain(self.named_parameters(),
-                                            self.named_buffers())])
-            for name, param in tqdm(
-                    itertools.chain(self.named_parameters(),
-                                    self.named_buffers()),
-                    desc="Fitting old weights to new weights",
-                    total=n_params
-            ):
-                if not name in sd:
-                    continue
-                old_shape = sd[name].shape
-                new_shape = param.shape
-                assert len(old_shape) == len(new_shape)
-                if len(new_shape) > 2:
-                    # we only modify first two axes
-                    assert new_shape[2:] == old_shape[2:]
-                # assumes first axis corresponds to output dim
-                if not new_shape == old_shape:
-                    new_param = param.clone()
-                    old_param = sd[name]
-                    if len(new_shape) == 1:
-                        for i in range(new_param.shape[0]):
-                            new_param[i] = old_param[i % old_shape[0]]
-                    elif len(new_shape) >= 2:
-                        for i in range(new_param.shape[0]):
-                            for j in range(new_param.shape[1]):
-                                new_param[i, j] = old_param[i % old_shape[0], j % old_shape[1]]
-
-                        n_used_old = torch.ones(old_shape[1])
-                        for j in range(new_param.shape[1]):
-                            n_used_old[j % old_shape[1]] += 1
-                        n_used_new = torch.zeros(new_shape[1])
-                        for j in range(new_param.shape[1]):
-                            n_used_new[j] = n_used_old[j % old_shape[1]]
-
-                        n_used_new = n_used_new[None, :]
-                        while len(n_used_new.shape) < len(new_shape):
-                            n_used_new = n_used_new.unsqueeze(-1)
-                        new_param /= n_used_new
-
-                    sd[name] = new_param
-
-        # missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(
-        #     sd, strict=False)
-        if not only_model:
-            missing, unexpected = self.load_state_dict(sd, strict=False)  
-        elif path.endswith(".bin"):
-            missing, unexpected = self.model.diffusion_model.load_state_dict(sd, strict=False)
-        elif path.endswith(".ckpt"):
-            missing, unexpected = self.model.load_state_dict(sd, strict=False)
-
-        print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
-        if len(missing) > 0:
-            print(f"Missing Keys:\n {missing}")
-        if len(unexpected) > 0:
-            print(f"\nUnexpected Keys:\n {unexpected}")
-        
-        if "model_ema.num_updates" in sd and "model_ema.num_updates" not in unexpected:
-            return sd["model_ema.num_updates"].item()
-        else: 
-            return 0
-    # q(x_t | x_0)
-    def q_mean_variance(self, x_start, t):
-        """
-        Get the distribution q(x_t | x_0).
-        :param x_start: the [N x C x ...] tensor of noiseless inputs.
-        :param t: the number of diffusion steps (minus 1). Here, 0 means one step.
-        :return: A tuple (mean, variance, log_variance), all of x_start's shape.
-        """
-        mean = (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start)
-        variance = extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape)
-        log_variance = extract_into_tensor(self.log_one_minus_alphas_cumprod, t, x_start.shape)
-        return mean, variance, log_variance
-
-    def predict_start_from_noise(self, x_t, t, noise):
-        return (
-                extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t -
-                extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise
-        )
-
-    def predict_start_from_z_and_v(self, x_t, t, v):
-        # self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod)))
-        # self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod)))
-        return (
-                extract_into_tensor(self.sqrt_alphas_cumprod, t, x_t.shape) * x_t -
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_t.shape) * v
-        )
-
-    def predict_eps_from_z_and_v(self, x_t, t, v):
-        return (
-                extract_into_tensor(self.sqrt_alphas_cumprod, t, x_t.shape) * v +
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_t.shape) * x_t
-        )
-    # q(x_(t-1) | x_t, x_0)
-    def q_posterior(self, x_start, x_t, t):
-        posterior_mean = (
-                extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start +
-                extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t
-        )
-        posterior_variance = extract_into_tensor(self.posterior_variance, t, x_t.shape)
-        posterior_log_variance_clipped = extract_into_tensor(self.posterior_log_variance_clipped, t, x_t.shape)
-        return posterior_mean, posterior_variance, posterior_log_variance_clipped
-    # p(x_(t-1) | x_t)
-    def p_mean_variance(self, x, t, clip_denoised: bool):
-        model_out = self.model(x, t)
-        if self.parameterization == "eps":
-            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
-        elif self.parameterization == "x0":
-            x_recon = model_out
-        if clip_denoised: # static thresholding
-            x_recon.clamp_(-1., 1.)
-
-        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
-        return model_mean, posterior_variance, posterior_log_variance
-    # one sampling step ancestral sampling 
-    @torch.no_grad()
-    def p_sample(self, x, t, clip_denoised=True, repeat_noise=False):
-        b, *_, device = *x.shape, x.device
-        model_mean, _, model_log_variance = self.p_mean_variance(x=x, t=t, clip_denoised=clip_denoised)
-        noise = noise_like(x.shape, device, repeat_noise)
-        # no noise when t == 0
-        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
-        return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
-    # sampling loop
-    @torch.no_grad()
-    def p_sample_loop(self, shape, return_intermediates=False):
-        device = self.betas.device
-        b = shape[0]
-        img = torch.randn(shape, device=device)
-        intermediates = [img]
-        for i in tqdm(reversed(range(0, self.num_timesteps)), desc='Sampling t', total=self.num_timesteps):
-            img = self.p_sample(img, torch.full((b,), i, device=device, dtype=torch.long),
-                                clip_denoised=self.clip_denoised)
-            if i % self.log_every_t == 0 or i == self.num_timesteps - 1:
-                intermediates.append(img)
-        if return_intermediates:
-            return img, intermediates
-        return img
-
-    @torch.no_grad()
-    def sample(self, batch_size=16, return_intermediates=False):
-        image_size = self.image_size
-        channels = self.channels
-        return self.p_sample_loop((batch_size, channels, image_size, image_size),
-                                  return_intermediates=return_intermediates)
-    # sampling from q(x_t | x_0)
-    def q_sample(self, x_start, t, noise=None):
-        noise = default(noise, lambda: torch.randn_like(x_start))
-        return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start +
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise)
-    # get v from x and noise
-    def get_v(self, x, noise, t):
-        return (
-                extract_into_tensor(self.sqrt_alphas_cumprod, t, x.shape) * noise -
-                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x.shape) * x
-        )
-    # loss type
-    def get_loss(self, pred, target, mean=True):
-        if self.loss_type == 'l1':
-            loss = (target - pred).abs()
-            if mean:
-                loss = loss.mean()
-        elif self.loss_type == 'l2':
-            if mean:
-                loss = torch.nn.functional.mse_loss(target, pred)
-            else:
-                loss = torch.nn.functional.mse_loss(target, pred, reduction='none')
-        else:
-            raise NotImplementedError("unknown loss type '{loss_type}'")
-
-        return loss
-    # training loss
-    def p_losses(self, x_start, t, noise=None):
-        noise = default(noise, lambda: torch.randn_like(x_start))
-        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
-        model_out = self.model(x_noisy, t)
-
-        loss_dict = {}
-        if self.parameterization == "eps":
-            target = noise
-        elif self.parameterization == "x0":
-            target = x_start
-        elif self.parameterization == "v":
-            target = self.get_v(x_start, noise, t)
-        else:
-            raise NotImplementedError(f"Paramterization {self.parameterization} not yet supported")
-        # L_simple
-        loss = self.get_loss(model_out, target, mean=False).mean(dim=[1, 2, 3])
-        log_prefix = 'train' if self.training else 'val'
-
-        loss_dict.update({f'{log_prefix}/loss_simple': loss.mean()})
-        loss_simple = loss.mean() * self.l_simple_weight
-        # L_vlb
-        loss_vlb = (self.lvlb_weights[t] * loss).mean()
-        loss_dict.update({f'{log_prefix}/loss_vlb': loss_vlb})
-        # L_simple + lambda * L_vlb following IDDPM
-        loss = loss_simple + self.original_elbo_weight * loss_vlb
-
-        loss_dict.update({f'{log_prefix}/loss': loss})
-
-        return loss, loss_dict
-    # using during training
-    def forward(self, x, *args, **kwargs):
-        # b, c, h, w, device, img_size, = *x.shape, x.device, self.image_size
-        # assert h == img_size and w == img_size, f'height and width of image must be {img_size}'
-        t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
-        return self.p_losses(x, t, *args, **kwargs)
-
-    def get_input(self, batch, k):
-        x = batch[k]
-        if len(x.shape) == 3:
-            x = x[..., None]
-        x = rearrange(x, 'b h w c -> b c h w')
-        x = x.to(memory_format=torch.contiguous_format).float()
-        # if self.trainer.precision == 16:
-        #     x = x.type(torch.float16)
-        return x
-
-    def shared_step(self, batch):
-        x = self.get_input(batch, self.first_stage_key)
-        loss, loss_dict = self(x)
-        return loss, loss_dict
-    # main training step
-    # def training_step(self, batch, batch_idx):
-    # change
-    def training_step(self, batch, batch_idx, optimizer_idx=0):
-        for k in self.ucg_training:
-            p = self.ucg_training[k]["p"]
-            val = self.ucg_training[k]["val"]
-            if val is None:
-                val = ""
-            for i in range(len(batch[k])):
-                if self.ucg_prng.choice(2, p=[1 - p, p]):
-                    batch[k][i] = val
-
-        loss, loss_dict = self.shared_step(batch)
-
-        self.log_dict(loss_dict, prog_bar=True,
-                      logger=True, on_step=True, on_epoch=True)
-        # if self.global_step == 19:
-        #     aa = 1
-        self.log("global_step", self.global_step,
-                 prog_bar=True, logger=True, on_step=True, on_epoch=False)
-        ac_loss_str = self.trainer.progress_bar_dict["loss"]
-        ac_loss = eval(ac_loss_str) if ac_loss_str!= "nan" else 0
-        log_prefix = 'train' if self.training else 'val'
-        self.log("{}/loss_accumulated".format(log_prefix), 
-            ac_loss,
-            prog_bar=False, logger=True, on_step=True, on_epoch=False
-        )
-        # if ac_loss > 0.012:
-        #     assert self.cond_stage_key
-        #     print(batch[self.cond_stage_key][:15])
-        if self.use_scheduler:
-            lr = self.optimizers().param_groups[0]['lr']
-            self.log('lr_abs', lr, prog_bar=True, logger=True, on_step=True, on_epoch=False)
-
-        return loss
-
-    @torch.no_grad()
-    def validation_step(self, batch, batch_idx):
-        _, loss_dict_no_ema = self.shared_step(batch)
-        with self.ema_scope():
-            _, loss_dict_ema = self.shared_step(batch)
-            loss_dict_ema = {key + '_ema': loss_dict_ema[key] for key in loss_dict_ema}
-        self.log_dict(loss_dict_no_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
-        self.log_dict(loss_dict_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
-    # ema
-    def on_train_batch_end(self, *args, **kwargs):
-        if self.use_ema:
-            self.model_ema(self.model)
-        if self.log_all_grad_norm:
-            gradnorm_list = []
-            for name, p in self.named_parameters():
-                if p.requires_grad:
-                    grad_norm_v = p.grad.detach().norm().item()
-                    gradnorm_list.append(grad_norm_v)
-                    if "textemb_merge_model" in name:
-                        self.log("all_gradients/{}_norm".format(name),
-                        gradnorm_list[-1],
-                        prog_bar=False, logger=True, on_step=True, on_epoch=False
-                        )
-                    if grad_norm_v > 0.1:
-                        print("the norm of gradient w.r.t {} > 0.1: {:.2f}".format
-                              (
-                            name, grad_norm_v
-                              ))
-
-            self.log("all_gradients/grad_norm_mean", 
-                np.mean(gradnorm_list), 
-                prog_bar=False, logger=True, on_step=True, on_epoch=False
-            )
-            self.log("all_gradients/grad_norm_max", 
-                np.max(gradnorm_list), 
-                prog_bar=False, logger=True, on_step=True, on_epoch=False
-            )
-            self.log("all_gradients/grad_norm_min", 
-                np.min(gradnorm_list), 
-                prog_bar=False, logger=True, on_step=True, on_epoch=False
-            ) 
-            self.log("all_gradients/param_num", 
-                len(gradnorm_list), 
-                prog_bar=False, logger=True, on_step=True, on_epoch=False
-            )
-    def _get_rows_from_list(self, samples):
-        n_imgs_per_row = len(samples)
-        denoise_grid = rearrange(samples, 'n b c h w -> b n c h w')
-        denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
-        denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
-        return denoise_grid
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=2, sample=True, return_keys=None, **kwargs):
-        log = dict()
-        x = self.get_input(batch, self.first_stage_key)
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        x = x.to(self.device)[:N]
-        log["inputs"] = x
-
-        # get diffusion row
-        diffusion_row = list()
-        x_start = x[:n_row]
-
-        for t in range(self.num_timesteps):
-            if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                t = t.to(self.device).long()
-                noise = torch.randn_like(x_start)
-                x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
-                diffusion_row.append(x_noisy)
-
-        log["diffusion_row"] = self._get_rows_from_list(diffusion_row)
-
-        if sample:
-            # get denoise row
-            with self.ema_scope("Plotting"):
-                samples, denoise_row = self.sample(batch_size=N, return_intermediates=True)
-
-            log["samples"] = samples
-            log["denoise_row"] = self._get_rows_from_list(denoise_row)
-
-        if return_keys:
-            if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
-                return log
-            else:
-                return {key: log[key] for key in return_keys}
-        return log
-    # configure optimizers AdamW
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        params = list(self.model.parameters())
-        if self.learn_logvar:
-            params = params + [self.logvar]
-        opt = torch.optim.AdamW(params, lr=lr)
-        return opt
-
-# main class: LDM - first stage, DDPM, conditions
-class LatentDiffusion(DDPM):
-    """main class"""
-
-    def __init__(self,
-                 first_stage_config,
-                 cond_stage_config,
-                #  textemb_merge_config = None,
-                 num_timesteps_cond=None,
-                 cond_stage_key="image",
-                 cond_stage_trainable=False,
-                 concat_mode=True,
-                 cond_stage_forward=None,
-                 conditioning_key=None,
-                 scale_factor=1.0,
-                 scale_by_std=False,
-                 force_null_conditioning=False,
-                 *args, **kwargs):
-        self.force_null_conditioning = force_null_conditioning
-        self.num_timesteps_cond = default(num_timesteps_cond, 1)
-        self.scale_by_std = scale_by_std
-        assert self.num_timesteps_cond <= kwargs['timesteps']
-        # for backwards compatibility after implementation of DiffusionWrapper
-        if conditioning_key is None:
-            conditioning_key = 'concat' if concat_mode else 'crossattn'
-        if cond_stage_config == '__is_unconditional__' and not self.force_null_conditioning:
-            conditioning_key = None
-        ckpt_path = kwargs.pop("ckpt_path", None)
-        reset_ema = kwargs.pop("reset_ema", False)
-        only_model= kwargs.pop("only_model", False)
-        reset_num_ema_updates = kwargs.pop("reset_num_ema_updates", False)
-        keep_num_ema_updates = kwargs.pop("keep_num_ema_updates", False)
-        ignore_keys = kwargs.pop("ignore_keys", [])
-        super().__init__(conditioning_key=conditioning_key, *args, **kwargs)
-        self.concat_mode = concat_mode
-        self.cond_stage_trainable = cond_stage_trainable
-        self.cond_stage_key = cond_stage_key
-        try:
-            self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1
-        except:
-            self.num_downs = 0
-        if not scale_by_std: #?
-            self.scale_factor = scale_factor
-        else:
-            self.register_buffer('scale_factor', torch.tensor(scale_factor))
-        print("instantiate first stage model")
-        self.instantiate_first_stage(first_stage_config)
-        print("instantiate cond stage model")
-        self.instantiate_cond_stage(cond_stage_config)
-        self.cond_stage_forward = cond_stage_forward
-        self.clip_denoised = False
-        self.bbox_tokenizer = None
-
-        self.restarted_from_ckpt = False
-        if ckpt_path is not None:
-            ema_num_updates = self.init_from_ckpt(ckpt_path, ignore_keys, only_model=only_model)
-            self.restarted_from_ckpt = True
-            if reset_ema:
-                assert self.use_ema
-                print(
-                    f"Resetting ema to pure model weights. This is useful when restoring from an ema-only checkpoint.")
-                self.model_ema = LitEma(self.model, init_num_updates= ema_num_updates if keep_num_ema_updates else 0)
-        if reset_num_ema_updates:
-            print(" +++++++++++ WARNING: RESETTING NUM_EMA UPDATES TO ZERO +++++++++++ ")
-            assert self.use_ema
-            self.model_ema.reset_num_updates()
-
-    def make_cond_schedule(self, ):
-        self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long)
-        ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long()
-        self.cond_ids[:self.num_timesteps_cond] = ids
-    # calculate scale factor for the first batch 
-    @rank_zero_only
-    @torch.no_grad()
-    def on_train_batch_start(self, batch, batch_idx, dataloader_idx):
-        # only for very first batch
-        if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt:
-            assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously'
-            # set rescale weight to 1./std of encodings
-            print("### USING STD-RESCALING ###")
-            x = super().get_input(batch, self.first_stage_key)
-            x = x.to(self.device)
-            encoder_posterior = self.encode_first_stage(x)
-            z = self.get_first_stage_encoding(encoder_posterior).detach()
-            del self.scale_factor
-            self.register_buffer('scale_factor', 1. / z.flatten().std())
-            print(f"setting self.scale_factor to {self.scale_factor}")
-            print("### USING STD-RESCALING ###")
-        if (
-            # not self.disabled and 
-            self.global_step == 0 and
-            self.current_epoch == 0 and batch_idx == 0 
-            # and self.log_first_step
-            ):
-            imagecallback = None
-            for callback in self.trainer.callbacks:
-                if "ImageLogger" in str(callback):
-                    imagecallback = callback
-                    break
-            if imagecallback is not None and not imagecallback.disabled and imagecallback.log_first_step:
-                is_train = self.training
-                if is_train:
-                    self.eval()
-                with torch.no_grad():
-                    # images = pl_module.log_images(batch, split=split, **self.log_images_kwargs)
-                    images = self.log_images(batch, **imagecallback.log_images_kwargs)
-                import os, torchvision
-                from PIL import Image
-                root = os.path.join(self.logger.save_dir, "images", "init")
-                for k in images:
-                    N = min(images[k].shape[0], imagecallback.max_images)
-                    images[k] = images[k][:N]
-                    if isinstance(images[k], torch.Tensor):
-                        images[k] = images[k].detach().cpu()
-                        if imagecallback.clamp:
-                            images[k] = torch.clamp(images[k], -1., 1.)
-                    grid = torchvision.utils.make_grid(images[k], nrow=4)
-                    if imagecallback.rescale:
-                        grid = (grid + 1.0) / 2.0  # -1,1 -> 0,1; c,h,w
-                    grid = grid.transpose(0, 1).transpose(1, 2).squeeze(-1)
-                    grid = grid.numpy()
-                    grid = (grid * 255).astype(np.uint8)
-                    filename = "{}_gs-{:06}_e-{:06}_b-{:06}.png".format(
-                        k,
-                        self.global_step,
-                        self.current_epoch,
-                        batch_idx)
-                    path = os.path.join(root, filename)
-                    os.makedirs(os.path.split(path)[0], exist_ok=True)
-                    Image.fromarray(grid).save(path)
-                    del grid
-                del images
-                print("log images before training")
-                # imagecallback.log_local(self.logger.save_dir, "init", images,
-                #                self.global_step, self.current_epoch, batch_idx, self, 
-                #                wandb_log = False)
-                if is_train:
-                    self.train()
-
-            # if imagecallback is not None and not imagecallback.disabled and imagecallback.log_first_step:
-            #    imagecallback.log_img(self, batch, batch_idx, split="init")
-    # rewrite 
-    def register_schedule(self,
-                          given_betas=None, beta_schedule="linear", timesteps=1000,
-                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
-        super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s)
-
-        self.shorten_cond_schedule = self.num_timesteps_cond > 1
-        if self.shorten_cond_schedule: # drop the option ?
-            self.make_cond_schedule()
-
-    def instantiate_first_stage(self, config): # not train 
-        model = instantiate_from_config(config)
-        self.first_stage_model = model.eval()
-        self.first_stage_model.train = disabled_train
-        for param in self.first_stage_model.parameters():
-            param.requires_grad = False
-    
-    # def instantiate_textemb_merge_model(self, config):
-    #     model = instantiate_from_config(config)
-    #     if not model.trainable:
-    #         self.textemb_merge_model = model.eval()
-    #         self.textemb_merge_model.train = disabled_train
-    #         for param in self.textemb_merge_model.parameters():
-    #             param.requires_grad = False  
-    #     else:
-    #         self.textemb_merge_model = model
-
-
-    def instantiate_cond_stage(self, config):
-        if not self.cond_stage_trainable:
-            if config == "__is_first_stage__":
-                print("Using first stage also as cond stage.")
-                self.cond_stage_model = self.first_stage_model
-            elif config == "__is_unconditional__":
-                print(f"Training {self.__class__.__name__} as an unconditional model.")
-                self.cond_stage_model = None
-                # self.be_unconditional = True
-            else:
-                model = instantiate_from_config(config)
-                self.cond_stage_model = model.eval()
-                self.cond_stage_model.train = disabled_train
-                for param in self.cond_stage_model.parameters():
-                    param.requires_grad = False
-        else:
-            assert config != '__is_first_stage__'
-            assert config != '__is_unconditional__'
-            model = instantiate_from_config(config)
-            self.cond_stage_model = model
-
-    def _get_denoise_row_from_list(self, samples, desc='', force_no_decoder_quantization=False):
-        denoise_row = []
-        for zd in tqdm(samples, desc=desc):
-            denoise_row.append(self.decode_first_stage(zd.to(self.device),
-                                                       force_not_quantize=force_no_decoder_quantization))
-        n_imgs_per_row = len(denoise_row)
-        denoise_row = torch.stack(denoise_row)  # n_log_step, n_row, C, H, W
-        denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w')
-        denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
-        denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
-        return denoise_grid
-    # first stage encoding
-    def get_first_stage_encoding(self, encoder_posterior):
-        if isinstance(encoder_posterior, DiagonalGaussianDistribution):
-            z = encoder_posterior.sample()
-        elif isinstance(encoder_posterior, torch.Tensor):
-            z = encoder_posterior
-        else:
-            raise NotImplementedError(f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented")
-        return self.scale_factor * z # rescale z before the diffusion process
-    # encode the condition
-    def get_learned_conditioning(self, c):
-        if self.cond_stage_forward is None:
-            if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode):
-                c = self.cond_stage_model.encode(c)
-                if isinstance(c, DiagonalGaussianDistribution):
-                    c = c.mode()
-            else:
-                c = self.cond_stage_model(c)
-        else:
-            assert hasattr(self.cond_stage_model, self.cond_stage_forward)
-            c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)
-        return c
-
-    def meshgrid(self, h, w):
-        y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1)
-        x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1)
-
-        arr = torch.cat([y, x], dim=-1)
-        return arr
-
-    def delta_border(self, h, w):
-        """
-        :param h: height
-        :param w: width
-        :return: normalized distance to image border,
-         wtith min distance = 0 at border and max dist = 0.5 at image center
-        """
-        lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2)
-        arr = self.meshgrid(h, w) / lower_right_corner
-        dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0]
-        dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0]
-        edge_dist = torch.min(torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0]
-        return edge_dist
-
-    def get_weighting(self, h, w, Ly, Lx, device):
-        weighting = self.delta_border(h, w)
-        weighting = torch.clip(weighting, self.split_input_params["clip_min_weight"],
-                               self.split_input_params["clip_max_weight"], )
-        weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device)
-
-        if self.split_input_params["tie_braker"]:
-            L_weighting = self.delta_border(Ly, Lx)
-            L_weighting = torch.clip(L_weighting,
-                                     self.split_input_params["clip_min_tie_weight"],
-                                     self.split_input_params["clip_max_tie_weight"])
-
-            L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device)
-            weighting = weighting * L_weighting
-        return weighting
-
-    def get_fold_unfold(self, x, kernel_size, stride, uf=1, df=1):  # todo load once not every time, shorten code
-        """
-        :param x: img of size (bs, c, h, w)
-        :return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1])
-        """
-        bs, nc, h, w = x.shape
-
-        # number of crops in image
-        Ly = (h - kernel_size[0]) // stride[0] + 1
-        Lx = (w - kernel_size[1]) // stride[1] + 1
-
-        if uf == 1 and df == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params)
-
-            weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h, w)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx))
-
-        elif uf > 1 and df == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold_params2 = dict(kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf),
-                                dilation=1, padding=0,
-                                stride=(stride[0] * uf, stride[1] * uf))
-            fold = torch.nn.Fold(output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2)
-
-            weighting = self.get_weighting(kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h * uf, w * uf)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx))
-
-        elif df > 1 and uf == 1:
-            fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
-            unfold = torch.nn.Unfold(**fold_params)
-
-            fold_params2 = dict(kernel_size=(kernel_size[0] // df, kernel_size[0] // df),
-                                dilation=1, padding=0,
-                                stride=(stride[0] // df, stride[1] // df))
-            fold = torch.nn.Fold(output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2)
-
-            weighting = self.get_weighting(kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device).to(x.dtype)
-            normalization = fold(weighting).view(1, 1, h // df, w // df)  # normalizes the overlap
-            weighting = weighting.view((1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx))
-
-        else:
-            raise NotImplementedError
-
-        return fold, unfold, normalization, weighting
-    # rewrite get input for training DM
-    @torch.no_grad()
-    def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False,
-                  cond_key=None, return_original_cond=False, bs=None, return_x=False):
-        x = super().get_input(batch, k)
-        if bs is not None:
-            x = x[:bs]
-        x = x.to(self.device)
-        # get scaled latent vector z for training
-        encoder_posterior = self.encode_first_stage(x)
-        z = self.get_first_stage_encoding(encoder_posterior).detach()
-
-        if self.model.conditioning_key is not None and not self.force_null_conditioning:
-            if cond_key is None:
-                cond_key = self.cond_stage_key
-            if cond_key != self.first_stage_key:
-                if cond_key in ['caption', 'coordinates_bbox', "txt"]:
-                    xc = batch[cond_key]
-                elif cond_key in ['class_label', 'cls']:
-                    xc = batch
-                else:
-                    xc = super().get_input(batch, cond_key).to(self.device)
-            else:
-                xc = x
-            if not self.cond_stage_trainable or force_c_encode:
-                if isinstance(xc, dict) or isinstance(xc, list):
-                    c = self.get_learned_conditioning(xc)
-                else:
-                    c = self.get_learned_conditioning(xc.to(self.device))
-            else:
-                c = xc
-            if bs is not None:
-                c = c[:bs]
-
-            if self.use_positional_encodings:
-                pos_x, pos_y = self.compute_latent_shifts(batch)
-                ckey = __conditioning_keys__[self.model.conditioning_key]
-                c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y}
-
-        else:
-            c = None
-            xc = None
-            if self.use_positional_encodings:
-                pos_x, pos_y = self.compute_latent_shifts(batch)
-                c = {'pos_x': pos_x, 'pos_y': pos_y}
-        # latent z + condition c
-        out = [z, c]
-        if return_first_stage_outputs:
-            xrec = self.decode_first_stage(z)
-            out.extend([x, xrec])
-        if return_x:
-            out.extend([x])
-        if return_original_cond:
-            out.append(xc)
-        return out
-    # from latent vector to x
-    @torch.no_grad()
-    def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):
-        if predict_cids:
-            if z.dim() == 4:
-                z = torch.argmax(z.exp(), dim=1).long()
-            z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)
-            z = rearrange(z, 'b h w c -> b c h w').contiguous()
-
-        z = 1. / self.scale_factor * z
-        return self.first_stage_model.decode(z)
-    # from x to latent vector (not scaled)
-    @torch.no_grad()
-    def encode_first_stage(self, x):
-        return self.first_stage_model.encode(x)
-   
-    def shared_step(self, batch, **kwargs):
-        x, c = self.get_input(batch, self.first_stage_key) #,return_first_stage_outputs=True)
-        # print("the shape of the batch data: {} | x[0,0,0,0]: {}".format(x.shape, x[0,0,0,0]))
-        loss = self(x, c)
-        return loss
-
-    def forward(self, x, c, *args, **kwargs):
-        t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
-        if self.model.conditioning_key is not None:
-            assert c is not None
-            if self.cond_stage_trainable:
-                c = self.get_learned_conditioning(c)
-            if self.shorten_cond_schedule:  # TODO: drop this option
-                tc = self.cond_ids[t].to(self.device)
-                c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))
-        return self.p_losses(x, c, t, *args, **kwargs)
-    # diffusion model
-    def apply_model(self, x_noisy, t, cond, return_ids=False):
-        if isinstance(cond, dict):
-            # hybrid case, cond is expected to be a dict
-            pass
-        else:
-            if not isinstance(cond, list):
-                cond = [cond]  # text: cross attention
-            key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'
-            cond = {key: cond}
-
-        x_recon = self.model(x_noisy, t, **cond)
-
-        if isinstance(x_recon, tuple) and not return_ids:
-            return x_recon[0]
-        else:
-            return x_recon
-    # predict e from x_t and predicted x_start
-    def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
-        return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \
-               extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
-    # KL between q(x_t | x) with N(0, I)
-    def _prior_bpd(self, x_start):
-        """
-        Get the prior KL term for the variational lower-bound, measured in
-        bits-per-dim.
-        This term can't be optimized, as it only depends on the encoder.
-        :param x_start: the [N x C x ...] tensor of inputs.
-        :return: a batch of [N] KL values (in bits), one per batch element.
-        """
-        batch_size = x_start.shape[0]
-        t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)
-        qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
-        kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0)
-        return mean_flat(kl_prior) / np.log(2.0)
-    # rewrite: add the condition / add logvar to L_simple
-    def p_losses(self, x_start, cond, t, noise=None):
-        noise = default(noise, lambda: torch.randn_like(x_start))
-        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
-        model_output = self.apply_model(x_noisy, t, cond)
-
-        loss_dict = {}
-        prefix = 'train' if self.training else 'val'
-
-        if self.parameterization == "x0":
-            target = x_start
-        elif self.parameterization == "eps":
-            target = noise
-        elif self.parameterization == "v":
-            target = self.get_v(x_start, noise, t)
-        else:
-            raise NotImplementedError()
-
-        loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3])
-        # if True in np.isnan(loss_simple.detach().cpu().numpy()):
-        #     aa = 1
-        loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()})
-        # log_var 
-        logvar_t = self.logvar[t].to(self.device)
-        loss = loss_simple / torch.exp(logvar_t) + logvar_t
-        # loss = loss_simple / torch.exp(self.logvar) + self.logvar
-        if self.learn_logvar:
-            loss_dict.update({f'{prefix}/loss_gamma': loss.mean()})
-            loss_dict.update({'logvar': self.logvar.data.mean()})
-
-        loss = self.l_simple_weight * loss.mean()
-
-        loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3))
-        loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()
-        loss_dict.update({f'{prefix}/loss_vlb': loss_vlb})
-        loss += (self.original_elbo_weight * loss_vlb)
-        loss_dict.update({f'{prefix}/loss': loss})
-
-        return loss, loss_dict
-    # rewrite: p(x_t-1 | x_t) add condition
-    def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False,
-                        return_x0=False, score_corrector=None, corrector_kwargs=None):
-        t_in = t
-        model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)
-
-        if score_corrector is not None:
-            assert self.parameterization == "eps"
-            model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)
-
-        if return_codebook_ids:
-            model_out, logits = model_out
-
-        if self.parameterization == "eps":
-            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
-        elif self.parameterization == "x0":
-            x_recon = model_out
-        else:
-            raise NotImplementedError()
-
-        if clip_denoised:
-            x_recon.clamp_(-1., 1.)
-        if quantize_denoised:
-            x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)
-        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
-        if return_codebook_ids:
-            return model_mean, posterior_variance, posterior_log_variance, logits
-        elif return_x0:
-            return model_mean, posterior_variance, posterior_log_variance, x_recon
-        else:
-            return model_mean, posterior_variance, posterior_log_variance
-
-    @torch.no_grad()
-    def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False,
-                 return_codebook_ids=False, quantize_denoised=False, return_x0=False,
-                 temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None):
-        b, *_, device = *x.shape, x.device
-        outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised,
-                                       return_codebook_ids=return_codebook_ids,
-                                       quantize_denoised=quantize_denoised,
-                                       return_x0=return_x0,
-                                       score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
-        if return_codebook_ids:
-            raise DeprecationWarning("Support dropped.")
-            model_mean, _, model_log_variance, logits = outputs
-        elif return_x0:
-            model_mean, _, model_log_variance, x0 = outputs
-        else:
-            model_mean, _, model_log_variance = outputs
-
-        noise = noise_like(x.shape, device, repeat_noise) * temperature
-        if noise_dropout > 0.:
-            noise = torch.nn.functional.dropout(noise, p=noise_dropout)
-        # no noise when t == 0
-        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
-
-        if return_codebook_ids:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1)
-        if return_x0:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0
-        else:
-            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
-
-    @torch.no_grad()
-    def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False,
-                              img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0.,
-                              score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None,
-                              log_every_t=None):
-        if not log_every_t:
-            log_every_t = self.log_every_t
-        timesteps = self.num_timesteps
-        if batch_size is not None:
-            b = batch_size if batch_size is not None else shape[0]
-            shape = [batch_size] + list(shape)
-        else:
-            b = batch_size = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=self.device)
-        else:
-            img = x_T
-        intermediates = []
-        if cond is not None:
-            if isinstance(cond, dict):
-                cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
-                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
-            else:
-                cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
-
-        if start_T is not None:
-            timesteps = min(timesteps, start_T)
-        iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation',
-                        total=timesteps) if verbose else reversed(
-            range(0, timesteps))
-        if type(temperature) == float:
-            temperature = [temperature] * timesteps
-
-        for i in iterator:
-            ts = torch.full((b,), i, device=self.device, dtype=torch.long)
-            if self.shorten_cond_schedule:
-                assert self.model.conditioning_key != 'hybrid'
-                tc = self.cond_ids[ts].to(cond.device)
-                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
-
-            img, x0_partial = self.p_sample(img, cond, ts,
-                                            clip_denoised=self.clip_denoised,
-                                            quantize_denoised=quantize_denoised, return_x0=True,
-                                            temperature=temperature[i], noise_dropout=noise_dropout,
-                                            score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
-            if mask is not None:
-                assert x0 is not None
-                img_orig = self.q_sample(x0, ts)
-                img = img_orig * mask + (1. - mask) * img
-
-            if i % log_every_t == 0 or i == timesteps - 1:
-                intermediates.append(x0_partial)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
-        return img, intermediates
-
-    @torch.no_grad()
-    def p_sample_loop(self, cond, shape, return_intermediates=False,
-                      x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False,
-                      mask=None, x0=None, img_callback=None, start_T=None,
-                      log_every_t=None):
-
-        if not log_every_t:
-            log_every_t = self.log_every_t
-        device = self.betas.device
-        b = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=device)
-        else:
-            img = x_T
-
-        intermediates = [img]
-        if timesteps is None:
-            timesteps = self.num_timesteps
-
-        if start_T is not None:
-            timesteps = min(timesteps, start_T)
-        iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(
-            range(0, timesteps))
-
-        if mask is not None:
-            assert x0 is not None
-            assert x0.shape[2:3] == mask.shape[2:3]  # spatial size has to match
-
-        for i in iterator:
-            ts = torch.full((b,), i, device=device, dtype=torch.long)
-            if self.shorten_cond_schedule:
-                assert self.model.conditioning_key != 'hybrid'
-                tc = self.cond_ids[ts].to(cond.device)
-                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
-
-            img = self.p_sample(img, cond, ts,
-                                clip_denoised=self.clip_denoised,
-                                quantize_denoised=quantize_denoised)
-            if mask is not None:
-                img_orig = self.q_sample(x0, ts)
-                img = img_orig * mask + (1. - mask) * img
-
-            if i % log_every_t == 0 or i == timesteps - 1:
-                intermediates.append(img)
-            if callback: callback(i)
-            if img_callback: img_callback(img, i)
-
-        if return_intermediates:
-            return img, intermediates
-        return img
-
-    @torch.no_grad()
-    def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,
-               verbose=True, timesteps=None, quantize_denoised=False,
-               mask=None, x0=None, shape=None, **kwargs):
-        if shape is None:
-            shape = (batch_size, self.channels, self.image_size, self.image_size)
-        if cond is not None:
-            if isinstance(cond, dict):
-                cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
-                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
-            else:
-                cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
-        return self.p_sample_loop(cond,
-                                  shape,
-                                  return_intermediates=return_intermediates, x_T=x_T,
-                                  verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,
-                                  mask=mask, x0=x0)
-
-    @torch.no_grad()
-    def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs):
-        if ddim:
-            ddim_sampler = DDIMSampler(self)
-            shape = (self.channels, self.image_size, self.image_size)
-            samples, intermediates = ddim_sampler.sample(ddim_steps, batch_size,
-                                                         shape, cond, verbose=False, **kwargs)
-
-        else:
-            samples, intermediates = self.sample(cond=cond, batch_size=batch_size,
-                                                 return_intermediates=True, **kwargs)
-
-        return samples, intermediates
-
-    @torch.no_grad()
-    def get_unconditional_conditioning(self, batch_size, null_label=None):
-        if null_label is not None:
-            xc = null_label
-            if isinstance(xc, ListConfig):
-                xc = list(xc)
-            if isinstance(xc, dict) or isinstance(xc, list):
-                c = self.get_learned_conditioning(xc)
-            else:
-                if hasattr(xc, "to"):
-                    xc = xc.to(self.device)
-                c = self.get_learned_conditioning(xc)
-        else:
-            if self.cond_stage_key in ["class_label", "cls"]:
-                xc = self.cond_stage_model.get_unconditional_conditioning(batch_size, device=self.device)
-                return self.get_learned_conditioning(xc)
-            else:
-                raise NotImplementedError("todo")
-        if isinstance(c, list):  # in case the encoder gives us a list
-            for i in range(len(c)):
-                c[i] = repeat(c[i], '1 ... -> b ...', b=batch_size).to(self.device)
-        else:
-            c = repeat(c, '1 ... -> b ...', b=batch_size).to(self.device)
-        return c
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=50, ddim_eta=0., return_keys=None,
-                   quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,
-                   plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None,
-                   use_ema_scope=True,
-                   **kwargs):
-        ema_scope = self.ema_scope if use_ema_scope else nullcontext
-        use_ddim = ddim_steps is not None
-
-        log = dict()
-        z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,
-                                           return_first_stage_outputs=True,
-                                           force_c_encode=True,
-                                           return_original_cond=True,
-                                           bs=N)
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        log["inputs"] = x
-        log["reconstruction"] = xrec
-        if self.model.conditioning_key is not None:
-            if hasattr(self.cond_stage_model, "decode"):
-                xc = self.cond_stage_model.decode(c)
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ["caption", "txt"]:
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25)
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ['class_label', "cls"]:
-                try:
-                    xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2] // 25)
-                    log['conditioning'] = xc
-                except KeyError:
-                    # probably no "human_label" in batch
-                    pass
-            elif isimage(xc):
-                log["conditioning"] = xc
-            if ismap(xc):
-                log["original_conditioning"] = self.to_rgb(xc)
-
-        if plot_diffusion_rows:
-            # get diffusion row
-            diffusion_row = list()
-            z_start = z[:n_row]
-            for t in range(self.num_timesteps):
-                if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                    t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                    t = t.to(self.device).long()
-                    noise = torch.randn_like(z_start)
-                    z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
-                    diffusion_row.append(self.decode_first_stage(z_noisy))
-
-            diffusion_row = torch.stack(diffusion_row)  # n_log_step, n_row, C, H, W
-            diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
-            diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
-            diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
-            log["diffusion_row"] = diffusion_grid
-
-        if sample:
-            # get denoise row
-            with ema_scope("Sampling"):
-                samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,
-                                                         ddim_steps=ddim_steps, eta=ddim_eta)
-                # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
-            x_samples = self.decode_first_stage(samples)
-            log["samples"] = x_samples
-            if plot_denoise_rows:
-                denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
-                log["denoise_row"] = denoise_grid
-
-            if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance(
-                    self.first_stage_model, IdentityFirstStage):
-                # also display when quantizing x0 while sampling
-                with ema_scope("Plotting Quantized Denoised"):
-                    samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,
-                                                             ddim_steps=ddim_steps, eta=ddim_eta,
-                                                             quantize_denoised=True)
-                    # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True,
-                    #                                      quantize_denoised=True)
-                x_samples = self.decode_first_stage(samples.to(self.device))
-                log["samples_x0_quantized"] = x_samples
-
-        if unconditional_guidance_scale > 1.0:
-            uc = self.get_unconditional_conditioning(N, unconditional_guidance_label)
-            if self.model.conditioning_key == "crossattn-adm":
-                uc = {"c_crossattn": [uc], "c_adm": c["c_adm"]}
-            with ema_scope("Sampling with classifier-free guidance"):
-                samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,
-                                                 ddim_steps=ddim_steps, eta=ddim_eta,
-                                                 unconditional_guidance_scale=unconditional_guidance_scale,
-                                                 unconditional_conditioning=uc,
-                                                 )
-                x_samples_cfg = self.decode_first_stage(samples_cfg)
-                log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg
-
-        if inpaint:
-            # make a simple center square
-            b, h, w = z.shape[0], z.shape[2], z.shape[3]
-            mask = torch.ones(N, h, w).to(self.device)
-            # zeros will be filled in
-            mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0.
-            mask = mask[:, None, ...]
-            with ema_scope("Plotting Inpaint"):
-                samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, eta=ddim_eta,
-                                             ddim_steps=ddim_steps, x0=z[:N], mask=mask)
-            x_samples = self.decode_first_stage(samples.to(self.device))
-            log["samples_inpainting"] = x_samples
-            log["mask"] = mask
-
-            # outpaint
-            mask = 1. - mask
-            with ema_scope("Plotting Outpaint"):
-                samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, eta=ddim_eta,
-                                             ddim_steps=ddim_steps, x0=z[:N], mask=mask)
-            x_samples = self.decode_first_stage(samples.to(self.device))
-            log["samples_outpainting"] = x_samples
-
-        if plot_progressive_rows:
-            with ema_scope("Plotting Progressives"):
-                img, progressives = self.progressive_denoising(c,
-                                                               shape=(self.channels, self.image_size, self.image_size),
-                                                               batch_size=N)
-            prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation")
-            log["progressive_row"] = prog_row
-
-        if return_keys:
-            if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
-                return log
-            else:
-                return {key: log[key] for key in return_keys}
-        return log
-
-    def configure_optimizers(self):
-        lr = self.learning_rate
-        params = list(self.model.parameters())
-        if self.cond_stage_trainable:
-            print(f"{self.__class__.__name__}: Also optimizing conditioner params!")
-            params = params + list(self.cond_stage_model.parameters())
-        if self.learn_logvar:
-            print('Diffusion model optimizing logvar')
-            params.append(self.logvar)
-        opt = torch.optim.AdamW(params, lr=lr)
-        if self.use_scheduler:
-            assert 'target' in self.scheduler_config
-            scheduler = instantiate_from_config(self.scheduler_config)
-
-            print("Setting up LambdaLR scheduler...")
-            scheduler = [
-                {
-                    'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule),
-                    'interval': 'step',
-                    'frequency': 1
-                }]
-            return [opt], scheduler
-        return opt
-
-    @torch.no_grad()
-    def to_rgb(self, x):
-        x = x.float()
-        if not hasattr(self, "colorize"):
-            self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x)
-        x = nn.functional.conv2d(x, weight=self.colorize)
-        x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.
-        return x
-
-
-class DiffusionWrapper(pl.LightningModule):
-    def __init__(self, diff_model_config, conditioning_key, textemb_merge_config=None, merge_textemb = False):
-        super().__init__()
-        self.merge_textemb = merge_textemb
-        if self.merge_textemb and textemb_merge_config is not None:
-            # cond_model_name = str(cond_stage_config.target)
-            # if "clip" in cond_model_name.lower() and "t5" in cond_model_name.lower():
-            self.instantiate_textemb_merge_model(textemb_merge_config)
-            # self.merge_textemb = True
-        else:
-            self.merge_textemb = False
-        self.sequential_cross_attn = diff_model_config.pop("sequential_crossattn", False)
-        self.diffusion_model = instantiate_from_config(diff_model_config)
-        self.conditioning_key = conditioning_key
-        assert self.conditioning_key in [None, 'concat', 'crossattn', 'hybrid', 'adm', 'hybrid-adm', 'crossattn-adm']
-    
-    def instantiate_textemb_merge_model(self, config):
-        model = instantiate_from_config(config)
-        if not model.trainable:
-            self.textemb_merge_model = model.eval()
-            self.textemb_merge_model.train = disabled_train
-            for param in self.textemb_merge_model.parameters():
-                param.requires_grad = False  
-        else:
-            self.textemb_merge_model = model
-
-    def forward(self, x, t, c_concat: list = None, c_crossattn: list = None, c_adm=None):
-        if self.conditioning_key is None:
-            out = self.diffusion_model(x, t)
-        elif self.conditioning_key == 'concat':
-            xc = torch.cat([x] + c_concat, dim=1)
-            out = self.diffusion_model(xc, t)
-        elif self.conditioning_key == 'crossattn':
-            if self.merge_textemb and len(c_crossattn) >= 2:
-                merge_c = self.textemb_merge_model(c_crossattn[0], c_crossattn[1])
-                c_crossattn = [merge_c]
-            if not self.sequential_cross_attn:
-                cc = torch.cat(c_crossattn, 1)
-            else:
-                cc = c_crossattn
-            out = self.diffusion_model(x, t, context=cc)
-        elif self.conditioning_key == 'hybrid':
-            xc = torch.cat([x] + c_concat, dim=1)
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(xc, t, context=cc)
-        elif self.conditioning_key == 'hybrid-adm':
-            assert c_adm is not None
-            xc = torch.cat([x] + c_concat, dim=1)
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(xc, t, context=cc, y=c_adm)
-        elif self.conditioning_key == 'crossattn-adm':
-            assert c_adm is not None
-            cc = torch.cat(c_crossattn, 1)
-            out = self.diffusion_model(x, t, context=cc, y=c_adm)
-        elif self.conditioning_key == 'adm':
-            cc = c_crossattn[0]
-            out = self.diffusion_model(x, t, y=cc)
-        else:
-            raise NotImplementedError()
-
-        return out
-
-
-class LatentUpscaleDiffusion(LatentDiffusion):
-    def __init__(self, *args, low_scale_config, low_scale_key="LR", noise_level_key=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        # assumes that neither the cond_stage nor the low_scale_model contain trainable params
-        assert not self.cond_stage_trainable
-        self.instantiate_low_stage(low_scale_config)
-        self.low_scale_key = low_scale_key
-        self.noise_level_key = noise_level_key
-
-    def instantiate_low_stage(self, config):
-        model = instantiate_from_config(config)
-        self.low_scale_model = model.eval()
-        self.low_scale_model.train = disabled_train
-        for param in self.low_scale_model.parameters():
-            param.requires_grad = False
-
-    @torch.no_grad()
-    def get_input(self, batch, k, cond_key=None, bs=None, log_mode=False):
-        if not log_mode:
-            z, c = super().get_input(batch, k, force_c_encode=True, bs=bs)
-        else:
-            z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True,
-                                                  force_c_encode=True, return_original_cond=True, bs=bs)
-        x_low = batch[self.low_scale_key][:bs]
-        x_low = rearrange(x_low, 'b h w c -> b c h w')
-        x_low = x_low.to(memory_format=torch.contiguous_format).float()
-        zx, noise_level = self.low_scale_model(x_low)
-        if self.noise_level_key is not None:
-            # get noise level from batch instead, e.g. when extracting a custom noise level for bsr
-            raise NotImplementedError('TODO')
-
-        all_conds = {"c_concat": [zx], "c_crossattn": [c], "c_adm": noise_level}
-        if log_mode:
-            # TODO: maybe disable if too expensive
-            x_low_rec = self.low_scale_model.decode(zx)
-            return z, all_conds, x, xrec, xc, x_low, x_low_rec, noise_level
-        return z, all_conds
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
-                   plot_denoise_rows=False, plot_progressive_rows=True, plot_diffusion_rows=True,
-                   unconditional_guidance_scale=1., unconditional_guidance_label=None, use_ema_scope=True,
-                   **kwargs):
-        ema_scope = self.ema_scope if use_ema_scope else nullcontext
-        use_ddim = ddim_steps is not None
-
-        log = dict()
-        z, c, x, xrec, xc, x_low, x_low_rec, noise_level = self.get_input(batch, self.first_stage_key, bs=N,
-                                                                          log_mode=True)
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        log["inputs"] = x
-        log["reconstruction"] = xrec
-        log["x_lr"] = x_low
-        log[f"x_lr_rec_@noise_levels{'-'.join(map(lambda x: str(x), list(noise_level.cpu().numpy())))}"] = x_low_rec
-        if self.model.conditioning_key is not None:
-            if hasattr(self.cond_stage_model, "decode"):
-                xc = self.cond_stage_model.decode(c)
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ["caption", "txt"]:
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25)
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ['class_label', 'cls']:
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2] // 25)
-                log['conditioning'] = xc
-            elif isimage(xc):
-                log["conditioning"] = xc
-            if ismap(xc):
-                log["original_conditioning"] = self.to_rgb(xc)
-
-        if plot_diffusion_rows:
-            # get diffusion row
-            diffusion_row = list()
-            z_start = z[:n_row]
-            for t in range(self.num_timesteps):
-                if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                    t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                    t = t.to(self.device).long()
-                    noise = torch.randn_like(z_start)
-                    z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
-                    diffusion_row.append(self.decode_first_stage(z_noisy))
-
-            diffusion_row = torch.stack(diffusion_row)  # n_log_step, n_row, C, H, W
-            diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
-            diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
-            diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
-            log["diffusion_row"] = diffusion_grid
-
-        if sample:
-            # get denoise row
-            with ema_scope("Sampling"):
-                samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,
-                                                         ddim_steps=ddim_steps, eta=ddim_eta)
-                # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
-            x_samples = self.decode_first_stage(samples)
-            log["samples"] = x_samples
-            if plot_denoise_rows:
-                denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
-                log["denoise_row"] = denoise_grid
-
-        if unconditional_guidance_scale > 1.0:
-            uc_tmp = self.get_unconditional_conditioning(N, unconditional_guidance_label)
-            # TODO explore better "unconditional" choices for the other keys
-            # maybe guide away from empty text label and highest noise level and maximally degraded zx?
-            uc = dict()
-            for k in c:
-                if k == "c_crossattn":
-                    assert isinstance(c[k], list) and len(c[k]) == 1
-                    uc[k] = [uc_tmp]
-                elif k == "c_adm":  # todo: only run with text-based guidance?
-                    assert isinstance(c[k], torch.Tensor)
-                    #uc[k] = torch.ones_like(c[k]) * self.low_scale_model.max_noise_level
-                    uc[k] = c[k]
-                elif isinstance(c[k], list):
-                    uc[k] = [c[k][i] for i in range(len(c[k]))]
-                else:
-                    uc[k] = c[k]
-
-            with ema_scope("Sampling with classifier-free guidance"):
-                samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,
-                                                 ddim_steps=ddim_steps, eta=ddim_eta,
-                                                 unconditional_guidance_scale=unconditional_guidance_scale,
-                                                 unconditional_conditioning=uc,
-                                                 )
-                x_samples_cfg = self.decode_first_stage(samples_cfg)
-                log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg
-
-        if plot_progressive_rows:
-            with ema_scope("Plotting Progressives"):
-                img, progressives = self.progressive_denoising(c,
-                                                               shape=(self.channels, self.image_size, self.image_size),
-                                                               batch_size=N)
-            prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation")
-            log["progressive_row"] = prog_row
-
-        return log
-
-
-class LatentFinetuneDiffusion(LatentDiffusion):
-    """
-         Basis for different finetunas, such as inpainting or depth2image
-         To disable finetuning mode, set finetune_keys to None
-    """
-
-    def __init__(self,
-                 concat_keys: tuple,
-                 finetune_keys=("model.diffusion_model.input_blocks.0.0.weight",
-                                "model_ema.diffusion_modelinput_blocks00weight"
-                                ),
-                 keep_finetune_dims=4,
-                 # if model was trained without concat mode before and we would like to keep these channels
-                 c_concat_log_start=None,  # to log reconstruction of c_concat codes
-                 c_concat_log_end=None,
-                 *args, **kwargs
-                 ):
-        ckpt_path = kwargs.pop("ckpt_path", None)
-        ignore_keys = kwargs.pop("ignore_keys", list())
-        super().__init__(*args, **kwargs)
-        self.finetune_keys = finetune_keys
-        self.concat_keys = concat_keys
-        self.keep_dims = keep_finetune_dims
-        self.c_concat_log_start = c_concat_log_start
-        self.c_concat_log_end = c_concat_log_end
-        if exists(self.finetune_keys): assert exists(ckpt_path), 'can only finetune from a given checkpoint'
-        if exists(ckpt_path):
-            self.init_from_ckpt(ckpt_path, ignore_keys)
-
-    def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
-        sd = torch.load(path, map_location="cpu")
-        if "state_dict" in list(sd.keys()):
-            sd = sd["state_dict"]
-        keys = list(sd.keys())
-        for k in keys:
-            for ik in ignore_keys:
-                if k.startswith(ik):
-                    print("Deleting key {} from state_dict.".format(k))
-                    del sd[k]
-
-            # make it explicit, finetune by including extra input channels
-            if exists(self.finetune_keys) and k in self.finetune_keys:
-                new_entry = None
-                for name, param in self.named_parameters():
-                    if name in self.finetune_keys:
-                        print(
-                            f"modifying key '{name}' and keeping its original {self.keep_dims} (channels) dimensions only")
-                        new_entry = torch.zeros_like(param)  # zero init
-                assert exists(new_entry), 'did not find matching parameter to modify'
-                new_entry[:, :self.keep_dims, ...] = sd[k]
-                sd[k] = new_entry
-
-        missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(
-            sd, strict=False)
-        print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
-        if len(missing) > 0:
-            print(f"Missing Keys: {missing}")
-        if len(unexpected) > 0:
-            print(f"Unexpected Keys: {unexpected}")
-
-    @torch.no_grad()
-    def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
-                   quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,
-                   plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None,
-                   use_ema_scope=True,
-                   **kwargs):
-        ema_scope = self.ema_scope if use_ema_scope else nullcontext
-        use_ddim = ddim_steps is not None
-
-        log = dict()
-        z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key, bs=N, return_first_stage_outputs=True)
-        c_cat, c = c["c_concat"][0], c["c_crossattn"][0]
-        N = min(x.shape[0], N)
-        n_row = min(x.shape[0], n_row)
-        log["inputs"] = x
-        log["reconstruction"] = xrec
-        if self.model.conditioning_key is not None:
-            if hasattr(self.cond_stage_model, "decode"):
-                xc = self.cond_stage_model.decode(c)
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ["caption", "txt"]:
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25)
-                log["conditioning"] = xc
-            elif self.cond_stage_key in ['class_label', 'cls']:
-                xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2] // 25)
-                log['conditioning'] = xc
-            elif isimage(xc):
-                log["conditioning"] = xc
-            if ismap(xc):
-                log["original_conditioning"] = self.to_rgb(xc)
-
-        if not (self.c_concat_log_start is None and self.c_concat_log_end is None):
-            log["c_concat_decoded"] = self.decode_first_stage(c_cat[:, self.c_concat_log_start:self.c_concat_log_end])
-
-        if plot_diffusion_rows:
-            # get diffusion row
-            diffusion_row = list()
-            z_start = z[:n_row]
-            for t in range(self.num_timesteps):
-                if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
-                    t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
-                    t = t.to(self.device).long()
-                    noise = torch.randn_like(z_start)
-                    z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
-                    diffusion_row.append(self.decode_first_stage(z_noisy))
-
-            diffusion_row = torch.stack(diffusion_row)  # n_log_step, n_row, C, H, W
-            diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
-            diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
-            diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
-            log["diffusion_row"] = diffusion_grid
-
-        if sample:
-            # get denoise row
-            with ema_scope("Sampling"):
-                samples, z_denoise_row = self.sample_log(cond={"c_concat": [c_cat], "c_crossattn": [c]},
-                                                         batch_size=N, ddim=use_ddim,
-                                                         ddim_steps=ddim_steps, eta=ddim_eta)
-                # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
-            x_samples = self.decode_first_stage(samples)
-            log["samples"] = x_samples
-            if plot_denoise_rows:
-                denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
-                log["denoise_row"] = denoise_grid
-
-        if unconditional_guidance_scale > 1.0:
-            uc_cross = self.get_unconditional_conditioning(N, unconditional_guidance_label)
-            uc_cat = c_cat
-            uc_full = {"c_concat": [uc_cat], "c_crossattn": [uc_cross]}
-            with ema_scope("Sampling with classifier-free guidance"):
-                samples_cfg, _ = self.sample_log(cond={"c_concat": [c_cat], "c_crossattn": [c]},
-                                                 batch_size=N, ddim=use_ddim,
-                                                 ddim_steps=ddim_steps, eta=ddim_eta,
-                                                 unconditional_guidance_scale=unconditional_guidance_scale,
-                                                 unconditional_conditioning=uc_full,
-                                                 )
-                x_samples_cfg = self.decode_first_stage(samples_cfg)
-                log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg
-
-        return log
-
-
-class LatentInpaintDiffusion(LatentFinetuneDiffusion):
-    """
-    can either run as pure inpainting model (only concat mode) or with mixed conditionings,
-    e.g. mask as concat and text via cross-attn.
-    To disable finetuning mode, set finetune_keys to None
-     """
-
-    def __init__(self,
-                 concat_keys=("mask", "masked_image"),
-                 masked_image_key="masked_image",
-                 *args, **kwargs
-                 ):
-        super().__init__(concat_keys, *args, **kwargs)
-        self.masked_image_key = masked_image_key
-        assert self.masked_image_key in concat_keys
-
-    @torch.no_grad()
-    def get_input(self, batch, k, cond_key=None, bs=None, return_first_stage_outputs=False):
-        # note: restricted to non-trainable encoders currently
-        assert not self.cond_stage_trainable, 'trainable cond stages not yet supported for inpainting'
-        z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True,
-                                              force_c_encode=True, return_original_cond=True, bs=bs)
-
-        assert exists(self.concat_keys)
-        c_cat = list()
-        for ck in self.concat_keys:
-            cc = rearrange(batch[ck], 'b h w c -> b c h w').to(memory_format=torch.contiguous_format).float()
-            if bs is not None:
-                cc = cc[:bs]
-                cc = cc.to(self.device)
-            bchw = z.shape
-            if ck != self.masked_image_key:
-                cc = torch.nn.functional.interpolate(cc, size=bchw[-2:])
-            else:
-                cc = self.get_first_stage_encoding(self.encode_first_stage(cc))
-            c_cat.append(cc)
-        c_cat = torch.cat(c_cat, dim=1)
-        all_conds = {"c_concat": [c_cat], "c_crossattn": [c]}
-        if return_first_stage_outputs:
-            return z, all_conds, x, xrec, xc
-        return z, all_conds
-
-    @torch.no_grad()
-    def log_images(self, *args, **kwargs):
-        log = super(LatentInpaintDiffusion, self).log_images(*args, **kwargs)
-        log["masked_image"] = rearrange(args[0]["masked_image"],
-                                        'b h w c -> b c h w').to(memory_format=torch.contiguous_format).float()
-        return log
-
-
-class LatentDepth2ImageDiffusion(LatentFinetuneDiffusion):
-    """
-    condition on monocular depth estimation
-    """
-
-    def __init__(self, depth_stage_config, concat_keys=("midas_in",), *args, **kwargs):
-        super().__init__(concat_keys=concat_keys, *args, **kwargs)
-        self.depth_model = instantiate_from_config(depth_stage_config)
-        self.depth_stage_key = concat_keys[0]
-
-    @torch.no_grad()
-    def get_input(self, batch, k, cond_key=None, bs=None, return_first_stage_outputs=False):
-        # note: restricted to non-trainable encoders currently
-        assert not self.cond_stage_trainable, 'trainable cond stages not yet supported for depth2img'
-        z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True,
-                                              force_c_encode=True, return_original_cond=True, bs=bs)
-
-        assert exists(self.concat_keys)
-        assert len(self.concat_keys) == 1
-        c_cat = list()
-        for ck in self.concat_keys:
-            cc = batch[ck]
-            if bs is not None:
-                cc = cc[:bs]
-                cc = cc.to(self.device)
-            cc = self.depth_model(cc)
-            cc = torch.nn.functional.interpolate(
-                cc,
-                size=z.shape[2:],
-                mode="bicubic",
-                align_corners=False,
-            )
-
-            depth_min, depth_max = torch.amin(cc, dim=[1, 2, 3], keepdim=True), torch.amax(cc, dim=[1, 2, 3],
-                                                                                           keepdim=True)
-            cc = 2. * (cc - depth_min) / (depth_max - depth_min + 0.001) - 1.
-            c_cat.append(cc)
-        c_cat = torch.cat(c_cat, dim=1)
-        all_conds = {"c_concat": [c_cat], "c_crossattn": [c]}
-        if return_first_stage_outputs:
-            return z, all_conds, x, xrec, xc
-        return z, all_conds
-
-    @torch.no_grad()
-    def log_images(self, *args, **kwargs):
-        log = super().log_images(*args, **kwargs)
-        depth = self.depth_model(args[0][self.depth_stage_key])
-        depth_min, depth_max = torch.amin(depth, dim=[1, 2, 3], keepdim=True), \
-                               torch.amax(depth, dim=[1, 2, 3], keepdim=True)
-        log["depth"] = 2. * (depth - depth_min) / (depth_max - depth_min) - 1.
-        return log
-
-
-class LatentUpscaleFinetuneDiffusion(LatentFinetuneDiffusion):
-    """
-        condition on low-res image (and optionally on some spatial noise augmentation)
-    """
-    def __init__(self, concat_keys=("lr",), reshuffle_patch_size=None,
-                 low_scale_config=None, low_scale_key=None, *args, **kwargs):
-        super().__init__(concat_keys=concat_keys, *args, **kwargs)
-        self.reshuffle_patch_size = reshuffle_patch_size
-        self.low_scale_model = None
-        if low_scale_config is not None:
-            print("Initializing a low-scale model")
-            assert exists(low_scale_key)
-            self.instantiate_low_stage(low_scale_config)
-            self.low_scale_key = low_scale_key
-
-    def instantiate_low_stage(self, config):
-        model = instantiate_from_config(config)
-        self.low_scale_model = model.eval()
-        self.low_scale_model.train = disabled_train
-        for param in self.low_scale_model.parameters():
-            param.requires_grad = False
-
-    @torch.no_grad()
-    def get_input(self, batch, k, cond_key=None, bs=None, return_first_stage_outputs=False):
-        # note: restricted to non-trainable encoders currently
-        assert not self.cond_stage_trainable, 'trainable cond stages not yet supported for upscaling-ft'
-        z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True,
-                                              force_c_encode=True, return_original_cond=True, bs=bs)
-
-        assert exists(self.concat_keys)
-        assert len(self.concat_keys) == 1
-        # optionally make spatial noise_level here
-        c_cat = list()
-        noise_level = None
-        for ck in self.concat_keys:
-            cc = batch[ck]
-            cc = rearrange(cc, 'b h w c -> b c h w')
-            if exists(self.reshuffle_patch_size):
-                assert isinstance(self.reshuffle_patch_size, int)
-                cc = rearrange(cc, 'b c (p1 h) (p2 w) -> b (p1 p2 c) h w',
-                               p1=self.reshuffle_patch_size, p2=self.reshuffle_patch_size)
-            if bs is not None:
-                cc = cc[:bs]
-                cc = cc.to(self.device)
-            if exists(self.low_scale_model) and ck == self.low_scale_key:
-                cc, noise_level = self.low_scale_model(cc)
-            c_cat.append(cc)
-        c_cat = torch.cat(c_cat, dim=1)
-        if exists(noise_level):
-            all_conds = {"c_concat": [c_cat], "c_crossattn": [c], "c_adm": noise_level}
-        else:
-            all_conds = {"c_concat": [c_cat], "c_crossattn": [c]}
-        if return_first_stage_outputs:
-            return z, all_conds, x, xrec, xc
-        return z, all_conds
-
-    @torch.no_grad()
-    def log_images(self, *args, **kwargs):
-        log = super().log_images(*args, **kwargs)
-        log["lr"] = rearrange(args[0]["lr"], 'b h w c -> b c h w')
-        return log

spaces/AINLPRoundTable/README/README.md

@@ -1,54 +0,0 @@
----
-title: README
-emoji: 🧠
-colorFrom: purple
-colorTo: yellow
-sdk: static
-pinned: false
----
-
-
-<div>
-   <script src="https://unpkg.com/@lottiefiles/lottie-player@latest/dist/lottie-player.js"></script>
-<lottie-player src="https://assets4.lottiefiles.com/private_files/lf30_m075yjya.json" background="transparent"  speed="1"  style="width: 300px; height: 300px;" loop controls autoplay></lottie-player>
-
-   <br />   
-   
-   <details class="lg:col-span-2">
-   <h3  class="my-8 lg:col-span-2" style="font-size:20px; font-weight:bold">Pre-requisites</h3>
-   <p class="lg:col-span-2">
-     One of the best platforms in 2022 for open source AI development and demonstration is "HuggingFace Spaces".  
-     
-Spaces supports a model hub, an inference API, github and container turn key integration, and an ability to create and freely host new programs for world wide communities reducing the pain and difficulty in setting up environments for AI.  
-
-HuggingFace is an open source implementation of an AI platform which supports three main SDK's used within AI and NLP apps which are HTML5, Gradio, and Streamlit.  
-
-As a pre-requisite you will need to create an account for yourself at HuggingFace (https://huggingface.co/).  Next join the classroom organization called "AINLPRoundTable".
-
-**Intended audience:**  This AI NLP round table class is for anyone with basic computing skills of all ages and backgrounds to be able to set up a space for themselves where they can create, test and demonstrate AI and NLP programs to anyone on the internet as open source.  Prior knowledge and interest of development of AI programs is recommended but not required so this audience can include people interested and new to AI.
-
-** AI and NLP Products **  This classroom follows three product design tenets:
-  1) Describe the **"Pain"** customer is facing with problem you plan to solve.  
-  2) Describe the **"Joy"** of what changes for the customer because of your product.  And finally, 
-  3) If we exceed all expectations, Describe how we give the customer a new **"Superpower"**.  
-  
-  As a "press release" for products be able to answer these to describe your goals to document product delivery.
-  
-   </p>
-</div>
-
-**Intent/Outcome of the Classroom:**  The intent of this HF Organization and this Classroom session is to enable all attendees to create AI and NLP programs in record time using Spaces, HTML5, Gradio, Streamlit, and Open Source.  
-
-By the end of this session attendees will be able to easily create new AI and NLP demos of their own to host and share including UI, ML models, user input and interaction, dataset load, save, transform and search.  The goal is to achieve proficience in using AI and NLP software development kits and libraries by sharing in an open source environment.
-
-
-**Pre-requisites:**  The preferred platform in 2022 for open source community AI development and demonstration is "HuggingFace Spaces".  Spaces supports a model hub, an inference API, github action integration, and ability to create and freely host new programs for world wide communities.  HuggingFace is an open source implementation of an AI platform which supports three main SDK's used within AI and NLP apps which are HTML5, Gradio, and Streamlit.  As a pre-requisite you will need to create an account for yourself at HuggingFace (https://huggingface.co/).  Next join the classroom organization called "AINLPRoundTable".  
-
-**Intended audience:**  This AI NLP round table class is for anyone with basic computing skills of all ages and backgrounds to be able to set up a space for themselves where they can create, test and demonstrate AI and NLP programs to anyone on the internet as open source.  Prior knowledge and interest of development of AI programs is recommended but not required so this audience can include people interested and new to AI.
-
-**Democratize AI and NLP to Give Customers Superpowers**  This classroom follows three easy to remember customer focused product design tenets:
-  1) Be able to describe easily the **"Pain"** customer is facing with problem you plan to solve.  
-  2) Be able to describe the **"Joy"** of what has changed for the customer because of your product.  And finally, 
-  3) If we exceeded all expectations, we gave the customer a new **"Superpower"**.  
-  
-  As a "press release" for your product be able to answer these and discuss your product ideas for AI and NLP and how we can help.  We do these press releases informally in a trusted space using short form video to document product delivery.

spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_2_ProfileRecogition/mmpretrain/configs/_base_/models/resnetv1c50.py

@@ -1,17 +0,0 @@
-# model settings
-model = dict(
-    type='ImageClassifier',
-    backbone=dict(
-        type='ResNetV1c',
-        depth=50,
-        num_stages=4,
-        out_indices=(3, ),
-        style='pytorch'),
-    neck=dict(type='GlobalAveragePooling'),
-    head=dict(
-        type='LinearClsHead',
-        num_classes=1000,
-        in_channels=2048,
-        loss=dict(type='CrossEntropyLoss', loss_weight=1.0),
-        topk=(1, 5),
-    ))

spaces/Ababababababbababa/Ashaar/poetry_diacritizer/diacritize.py

@@ -1,36 +0,0 @@
-import argparse
-from diacritizer import TransformerDiacritizer
-from itertools import repeat
-import random
-
-import numpy as np
-import torch
-
-
-SEED = 1234
-random.seed(SEED)
-np.random.seed(SEED)
-torch.manual_seed(SEED)
-torch.cuda.manual_seed(SEED)
-torch.backends.cudnn.deterministic = True
-torch.backends.cudnn.benchmark = False
-
-
-def diacritization_parser():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model_kind", dest="model_kind", type=str, required=True)
-    parser.add_argument("--config", dest="config", type=str, required=True)
-    parser.add_argument("--text", dest="text", type=str, required=True)
-    return parser
-
-
-parser = diacritization_parser()
-args = parser.parse_args()
-
-
-if args.model_kind in ["transformer"]:
-    diacirtizer = TransformerDiacritizer(args.config, args.model_kind)
-else:
-    raise ValueError("The model kind is not supported")
-
-diacirtizer.diacritize_text(args.text)

spaces/Ababababababbababa/Ashaar/poetry_diacritizer/modules/attention.py

@@ -1,199 +0,0 @@
-from typing import Optional
-
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-from poetry_diacritizer.options import AttentionType
-
-
-class BahdanauAttention(nn.Module):
-    def __init__(self, dim):
-        super(BahdanauAttention, self).__init__()
-        self.query_layer = nn.Linear(dim, dim, bias=False)
-        self.tanh = nn.Tanh()
-        self.v = nn.Linear(dim, 1, bias=False)
-
-    def forward(self, query: torch.Tensor, keys: torch.Tensor):
-        """
-        Args:
-            query: (B, 1, dim) or (batch, dim)
-            processed_memory: (batch, max_time, dim)
-        """
-        if query.dim() == 2:
-            # insert time-axis for broadcasting
-            query = query.unsqueeze(1)
-        # (batch, 1, dim)
-        query = self.query_layer(query)
-
-        # (batch, max_time, 1)
-        alignment = self.v(self.tanh(query + keys))
-
-        # (batch, max_time)
-        return alignment.squeeze(-1)
-
-
-class LocationSensitive(nn.Module):
-    def __init__(self, dim):
-        super(LocationSensitive, self).__init__()
-        self.query_layer = nn.Linear(dim, dim, bias=False)
-        self.v = nn.Linear(dim, 1, bias=True)
-        self.location_layer = nn.Linear(32, dim, bias=False)
-        padding = int((31 - 1) / 2)
-        self.location_conv = torch.nn.Conv1d(
-            1, 32, kernel_size=31, stride=1, padding=padding, dilation=1, bias=False
-        )
-
-        self.score_mask_value = -float("inf")
-
-    def forward(
-        self,
-        query: torch.Tensor,
-        keys: torch.Tensor,
-        prev_alignments: torch.Tensor,
-    ):
-        # keys = keys.permute(1,0,2)
-        query = self.query_layer(query)
-        if query.dim() == 2:
-            # insert time-axis for broadcasting
-            query = query.unsqueeze(1)
-            # -> [batch_size, 1, attention_dim]
-
-        alignments = prev_alignments.unsqueeze(1)
-
-        # location features [batch_size, max_time, filters]
-        filters = self.location_conv(alignments)
-        location_features = self.location_layer(filters.transpose(1, 2))
-
-        alignments = self.v(torch.tanh(query + location_features + keys))
-        return alignments.squeeze(-1)
-
-
-class AttentionWrapper(nn.Module):
-    def __init__(
-        self,
-        attention_type: AttentionType = AttentionType.LocationSensitive,
-        attention_units: int = 256,
-        score_mask_value=-float("inf"),
-    ):
-        super().__init__()
-        self.score_mask_value = score_mask_value
-        self.attention_type = attention_type
-
-        if attention_type == AttentionType.LocationSensitive:
-            self.attention_mechanism = LocationSensitive(attention_units)
-        elif attention_type == AttentionType.Content_Based:
-            self.attention_mechanism = BahdanauAttention(attention_units)
-        else:
-            raise Exception("The attention type is not known")
-
-    def forward(
-        self,
-        query: torch.Tensor,
-        keys: torch.Tensor,
-        values: torch.Tensor,
-        mask: Optional[torch.Tensor] = None,
-        prev_alignment: Optional[torch.Tensor] = None,
-    ):
-
-        # Alignment
-        # (batch, max_time)
-        if self.attention_type == AttentionType.Content_Based:
-            alignment = self.attention_mechanism(query, keys)
-        else:
-            alignment = self.attention_mechanism(query, keys, prev_alignment)
-
-        # Attention context vector
-
-        if mask is not None:
-            alignment.data.masked_fill_(mask, self.score_mask_value)
-
-        alignment = F.softmax(alignment, dim=1)
-        attention = torch.bmm(alignment.unsqueeze(1), values)
-        attention = attention.squeeze(1)
-
-        return attention, alignment
-
-
-class MultiHeadAttentionLayer(nn.Module):
-    def __init__(self, hid_dim: int, n_heads: int, dropout: float = 0.0):
-        super().__init__()
-
-        assert hid_dim % n_heads == 0
-
-        self.hid_dim = hid_dim
-        self.n_heads = n_heads
-        self.head_dim = hid_dim // n_heads
-
-        self.fc_q = nn.Linear(hid_dim, hid_dim)
-        self.fc_k = nn.Linear(hid_dim, hid_dim)
-        self.fc_v = nn.Linear(hid_dim, hid_dim)
-
-        self.fc_o = nn.Linear(hid_dim * 2, hid_dim)
-
-        if dropout != 0.0:
-            self.dropout = nn.Dropout(dropout)
-
-        self.use_dropout = dropout != 0.0
-
-        device = next(self.parameters()).device
-
-        self.scale = torch.sqrt(torch.FloatTensor([self.head_dim])).to(device)
-
-    def forward(self, query, key, value, mask=None):
-
-        batch_size = query.shape[0]
-
-        # query = [batch size, query len, hid dim]
-        # key = [batch size, key len, hid dim]
-        # value = [batch size, value len, hid dim]
-
-        Q = self.fc_q(query)
-        K = self.fc_k(key)
-        V = self.fc_v(value)
-
-        # Q = [batch size, query len, hid dim]
-        # K = [batch size, key len, hid dim]
-        # V = [batch size, value len, hid dim]
-
-        Q = Q.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
-        K = K.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
-        V = V.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
-
-        # Q = [batch size, n heads, query len, head dim]
-        # K = [batch size, n heads, key len, head dim]
-        # V = [batch size, n heads, value len, head dim]
-
-        energy = torch.matmul(Q, K.permute(0, 1, 3, 2)) / self.scale
-
-        # energy = [batch size, n heads, query len, key len]
-
-        if mask is not None:
-            energy = energy.masked_fill(mask == 0, -float("inf"))
-
-        attention = torch.softmax(energy, dim=-1)
-
-        # attention = [batch size, n heads, query len, key len]
-
-        if self.use_dropout:
-            context_vector = torch.matmul(self.dropout(attention), V)
-        else:
-            context_vector = torch.matmul(attention, V)
-
-        # x = [batch size, n heads, query len, head dim]
-
-        context_vector = context_vector.permute(0, 2, 1, 3).contiguous()
-
-        # x = [batch size, query len, n heads, head dim]
-
-        context_vector = context_vector.view(batch_size, -1, self.hid_dim)
-
-        x = torch.cat((query, context_vector), dim=-1)
-
-        # x = [batch size, query len, hid dim * 2]
-
-        x = self.fc_o(x)
-
-        # x = [batch size, query len, hid dim]
-
-        return x, attention

spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/constants/publicSepToken.ts

@@ -1 +0,0 @@
-export const PUBLIC_SEP_TOKEN = "</s>";

spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/utils/sha256.ts

@@ -1,7 +0,0 @@
-export async function sha256(input: string): Promise<string> {
-	const utf8 = new TextEncoder().encode(input);
-	const hashBuffer = await crypto.subtle.digest("SHA-256", utf8);
-	const hashArray = Array.from(new Uint8Array(hashBuffer));
-	const hashHex = hashArray.map((bytes) => bytes.toString(16).padStart(2, "0")).join("");
-	return hashHex;
-}

spaces/AchyuthGamer/OpenGPT-Chat/app.py

@@ -1,97 +0,0 @@
-from huggingface_hub import InferenceClient
-import gradio as gr
-import random
-
-API_URL = "https://api-inference.huggingface.co/models/"
-
-client = InferenceClient(
-    "mistralai/Mistral-7B-Instruct-v0.1"
-)
-
-def format_prompt(message, history):
-  prompt = "Your name is OpenGPT. You are developed by Achyuth. Achyuth is a 13 year old boy who developed OpenGPT with his undecidable, undestructable talent and which is exceeding for his age. Achyuth is developed of OpenGPT. Achyuths or your developers parents and family are G.Renuka, she is his mother, N.Nagarjun Reddy and his sister Gayathri. Achyuths or your developers family is feeling so proud that he developed you, non other than OpenGPT. Your developers family is nuclear family of 4 members. Achyuths or your developers friends are Akira, Nikesh, Ubaidh, Parthu and Likith. His friend Nikesh is also called CP, full form of CP is Chillar Panula Nikesh. His friend Ubaidh is also called Baek. His friend Likith is also called Kith Lee. Parthu is also known as Pallavi Sarees. Achyuth is an AI and ML researcher. Achyuth knows PyThon, Java, HTML,CSS and JavaScript. He has a lot of intrest on Computers. Achyuth is inspired from Elon Musk, Bill Gates. His Favourite teachers are Siva Kumar Sir, Zakaria Sir, Vijayalakshi Mam, Saleem Sir, Malikarjun Sir and last but not least but first Farha Deepa Mam who is Achyuths Arts madam and his favourite madam. Achyuths or your developers most favourite teacher is Farha Deepa Mam. Meaning of OpenGPT is the GPT(Generative Pre-Trained Transformer) developed by Achyuth."
-  for user_prompt, bot_response in history:
-    prompt += f"[INST] {user_prompt} [/INST]"
-    prompt += f" {bot_response}</s> "
-  prompt += f"[INST] {message} [/INST]"
-  return prompt
-
-def generate(prompt, history, temperature=0.9, max_new_tokens=2048, top_p=0.95, repetition_penalty=1.0):
-    temperature = float(temperature)
-    if temperature < 1e-2:
-        temperature = 1e-2
-    top_p = float(top_p)
-
-    generate_kwargs = dict(
-        temperature=temperature,
-        max_new_tokens=max_new_tokens,
-        top_p=top_p,
-        repetition_penalty=repetition_penalty,
-        do_sample=True,
-        seed=random.randint(0, 10**7),
-    )
-
-    formatted_prompt = format_prompt(prompt, history)
-
-    stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=False)
-    output = ""
-
-    for response in stream:
-        output += response.token.text
-        yield output
-    return output
-
-
-additional_inputs=[
-    gr.Slider(
-        label="Temperature",
-        value=0.9,
-        minimum=0.0,
-        maximum=1.0,
-        step=0.05,
-        interactive=True,
-        info="Higher values produce more diverse outputs",
-    ),
-    gr.Slider(
-        label="Max new tokens",
-        value=2048,
-        minimum=64,
-        maximum=4096,
-        step=64,
-        interactive=True,
-        info="The maximum numbers of new tokens",
-    ),
-    gr.Slider(
-        label="Top-p (nucleus sampling)",
-        value=0.90,
-        minimum=0.0,
-        maximum=1,
-        step=0.05,
-        interactive=True,
-        info="Higher values sample more low-probability tokens",
-    ),
-    gr.Slider(
-        label="Repetition penalty",
-        value=1.2,
-        minimum=1.0,
-        maximum=2.0,
-        step=0.05,
-        interactive=True,
-        info="Penalize repeated tokens",
-    )
-]
-
-customCSS = """
-#component-7 { # this is the default element ID of the chat component
-  height: 1600px; # adjust the height as needed
-  flex-grow: 4;
-}
-"""
-
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.ChatInterface(
-        generate,
-        additional_inputs=additional_inputs,
-    )
-
-demo.queue().launch(debug=True)

spaces/AchyuthGamer/OpenGPT/g4f/Provider/GptGod.py

@@ -1,51 +0,0 @@
-from __future__ import annotations
-import secrets, json
-from aiohttp import ClientSession
-from typing import AsyncGenerator
-from .base_provider import AsyncGeneratorProvider
-from .helper import format_prompt
-
-class GptGod(AsyncGeneratorProvider):
-    url = "https://gptgod.site"
-    supports_gpt_35_turbo = True
-    working = True
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: list[dict[str, str]],
-        **kwargs
-    ) -> AsyncGenerator:
-        headers = {
-            "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/118.0",
-            "Accept": "text/event-stream",
-            "Accept-Language": "de,en-US;q=0.7,en;q=0.3",
-            "Accept-Encoding": "gzip, deflate, br",
-            "Alt-Used": "gptgod.site",
-            "Connection": "keep-alive",
-            "Referer": "https://gptgod.site/",
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin",
-            "Pragma": "no-cache",
-            "Cache-Control": "no-cache",
-        }
-        async with ClientSession(headers=headers) as session:
-            prompt = format_prompt(messages)
-            data = {
-                "content": prompt,
-                "id": secrets.token_hex(16).zfill(32)
-            }
-            async with session.get(f"{cls.url}/api/session/free/gpt3p5", params=data) as response:
-                response.raise_for_status()
-                event = None
-                async for line in response.content:
-                    if line.startswith(b'event: '):
-                        event = line[7:-1]
-                    elif event == b"data" and line.startswith(b"data: "):
-                        data = json.loads(line[6:-1])
-                        if data:
-                            yield data
-                    elif event == b"done":
-                        break

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

@@ -1,10 +0,0 @@
-import CanvasObjectToBitmap from './data/canvasdata/CanvasObjectToBitmap';
-import TextureTColorMap from './data/canvasdata/TextureToColormap';
-
-declare var Methods: {
-    textObjectToBitmap: typeof CanvasObjectToBitmap,
-    canvasObjectToBitmap: typeof CanvasObjectToBitmap,
-    textureTColorMap: typeof TextureTColorMap,
-}
-
-export default Methods;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/puff/Factory.d.ts

@@ -1,6 +0,0 @@
-import Puff from './Puff';
-import Base from '../base/Base';
-
-export default function Factory(
-    config?: Base.IConfig
-): Puff;

spaces/AiBototicus/BucksAI-3/app.py

@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/AiBototicus/autotrain-birds-48829118237").launch()

spaces/Amon1/ChatGPTForAcadamic/crazy_functions/test_project/cpp/cppipc/shm.cpp

@@ -1,103 +0,0 @@
-
-#include <string>
-#include <utility>
-
-#include "libipc/shm.h"
-
-#include "libipc/utility/pimpl.h"
-#include "libipc/memory/resource.h"
-
-namespace ipc {
-namespace shm {
-
-class handle::handle_ : public pimpl<handle_> {
-public:
-    shm::id_t id_ = nullptr;
-    void*     m_  = nullptr;
-
-    ipc::string n_;
-    std::size_t s_ = 0;
-};
-
-handle::handle()
-    : p_(p_->make()) {
-}
-
-handle::handle(char const * name, std::size_t size, unsigned mode)
-    : handle() {
-    acquire(name, size, mode);
-}
-
-handle::handle(handle&& rhs)
-    : handle() {
-    swap(rhs);
-}
-
-handle::~handle() {
-    release();
-    p_->clear();
-}
-
-void handle::swap(handle& rhs) {
-    std::swap(p_, rhs.p_);
-}
-
-handle& handle::operator=(handle rhs) {
-    swap(rhs);
-    return *this;
-}
-
-bool handle::valid() const noexcept {
-    return impl(p_)->m_ != nullptr;
-}
-
-std::size_t handle::size() const noexcept {
-    return impl(p_)->s_;
-}
-
-char const * handle::name() const noexcept {
-    return impl(p_)->n_.c_str();
-}
-
-std::int32_t handle::ref() const noexcept {
-    return shm::get_ref(impl(p_)->id_);
-}
-
-void handle::sub_ref() noexcept {
-    shm::sub_ref(impl(p_)->id_);
-}
-
-bool handle::acquire(char const * name, std::size_t size, unsigned mode) {
-    release();
-    impl(p_)->id_ = shm::acquire((impl(p_)->n_ = name).c_str(), size, mode);
-    impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
-    return valid();
-}
-
-std::int32_t handle::release() {
-    if (impl(p_)->id_ == nullptr) return -1;
-    return shm::release(detach());
-}
-
-void* handle::get() const {
-    return impl(p_)->m_;
-}
-
-void handle::attach(id_t id) {
-    if (id == nullptr) return;
-    release();
-    impl(p_)->id_ = id;
-    impl(p_)->m_  = shm::get_mem(impl(p_)->id_, &(impl(p_)->s_));
-}
-
-id_t handle::detach() {
-    auto old = impl(p_)->id_;
-    impl(p_)->id_ = nullptr;
-    impl(p_)->m_  = nullptr;
-    impl(p_)->s_  = 0;
-    impl(p_)->n_.clear();
-    return old;
-}
-
-} // namespace shm
-} // namespace ipc

spaces/Amrrs/DragGan-Inversion/PTI/models/StyleCLIP/global_directions/GenerateImg.py

@@ -1,50 +0,0 @@
-
-import os
-import numpy as np
-import argparse
-from manipulate import Manipulator
-
-from PIL import Image
-#%%
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='Process some integers.')
-    
-    parser.add_argument('--dataset_name',type=str,default='ffhq',
-                    help='name of dataset, for example, ffhq')
-
-    args = parser.parse_args()
-    dataset_name=args.dataset_name
-    
-    if not os.path.isdir('./data/'+dataset_name):
-        os.system('mkdir ./data/'+dataset_name)
-    #%%
-    M=Manipulator(dataset_name=dataset_name)
-    np.set_printoptions(suppress=True)
-    print(M.dataset_name)
-    #%%
-    
-    M.img_index=0
-    M.num_images=50
-    M.alpha=[0]
-    M.step=1
-    lindex,bname=0,0
-    
-    M.manipulate_layers=[lindex]
-    codes,out=M.EditOneC(bname)
-    #%%
-    
-    for i in range(len(out)):
-        img=out[i,0]
-        img=Image.fromarray(img)
-        img.save('./data/'+dataset_name+'/'+str(i)+'.jpg')
-    #%%
-    w=np.load('./npy/'+dataset_name+'/W.npy')
-    
-    tmp=w[:M.num_images]
-    tmp=tmp[:,None,:]
-    tmp=np.tile(tmp,(1,M.Gs.components.synthesis.input_shape[1],1))
-    
-    np.save('./data/'+dataset_name+'/w_plus.npy',tmp)
-    
-    

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/api/pipelines/consistency_models.md

@@ -1,43 +0,0 @@
-# Consistency Models
-
-Consistency Models were proposed in [Consistency Models](https://huggingface.co/papers/2303.01469) by Yang Song, Prafulla Dhariwal, Mark Chen, and Ilya Sutskever.
-
-The abstract from the paper is:
-
-*Diffusion models have significantly advanced the fields of image, audio, and video generation, but they depend on an iterative sampling process that causes slow generation. To overcome this limitation, we propose consistency models, a new family of models that generate high quality samples by directly mapping noise to data. They support fast one-step generation by design, while still allowing multistep sampling to trade compute for sample quality. They also support zero-shot data editing, such as image inpainting, colorization, and super-resolution, without requiring explicit training on these tasks. Consistency models can be trained either by distilling pre-trained diffusion models, or as standalone generative models altogether. Through extensive experiments, we demonstrate that they outperform existing distillation techniques for diffusion models in one- and few-step sampling, achieving the new state-of-the-art FID of 3.55 on CIFAR-10 and 6.20 on ImageNet 64x64 for one-step generation. When trained in isolation, consistency models become a new family of generative models that can outperform existing one-step, non-adversarial generative models on standard benchmarks such as CIFAR-10, ImageNet 64x64 and LSUN 256x256. *
-
-The original codebase can be found at [openai/consistency_models](https://github.com/openai/consistency_models), and additional checkpoints are available at [openai](https://huggingface.co/openai).
-
-The pipeline was contributed by [dg845](https://github.com/dg845) and [ayushtues](https://huggingface.co/ayushtues). ❤️
-
-## Tips
-
-For an additional speed-up, use `torch.compile` to generate multiple images in <1 second:
-
-```diff
-  import torch
-  from diffusers import ConsistencyModelPipeline
-
-  device = "cuda"
-  # Load the cd_bedroom256_lpips checkpoint.
-  model_id_or_path = "openai/diffusers-cd_bedroom256_lpips"
-  pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)
-  pipe.to(device)
-
-+ pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
-
-  # Multistep sampling
-  # Timesteps can be explicitly specified; the particular timesteps below are from the original Github repo:
-  # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L83
-  for _ in range(10):
-      image = pipe(timesteps=[17, 0]).images[0]
-      image.show()
-```
-
-## ConsistencyModelPipeline
-[[autodoc]] ConsistencyModelPipeline
-    - all
-    - __call__
-
-## ImagePipelineOutput
-[[autodoc]] pipelines.ImagePipelineOutput

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

@@ -1,598 +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.
-
-import inspect
-import warnings
-from typing import Callable, List, Optional, Union
-
-import numpy as np
-import PIL
-import torch
-from transformers import CLIPImageProcessor
-
-from ...image_processor import VaeImageProcessor
-from ...models import AutoencoderKL, UNet2DConditionModel
-from ...schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
-from ...utils import logging, randn_tensor
-from ..pipeline_utils import DiffusionPipeline
-from ..stable_diffusion import StableDiffusionPipelineOutput
-from ..stable_diffusion.safety_checker import StableDiffusionSafetyChecker
-from .image_encoder import PaintByExampleImageEncoder
-
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-def prepare_mask_and_masked_image(image, mask):
-    """
-    Prepares a pair (image, mask) to be consumed by the Paint by Example pipeline. This means that those inputs will be
-    converted to ``torch.Tensor`` with shapes ``batch x channels x height x width`` where ``channels`` is ``3`` for the
-    ``image`` and ``1`` for the ``mask``.
-
-    The ``image`` will be converted to ``torch.float32`` and normalized to be in ``[-1, 1]``. The ``mask`` will be
-    binarized (``mask > 0.5``) and cast to ``torch.float32`` too.
-
-    Args:
-        image (Union[np.array, PIL.Image, torch.Tensor]): The image to inpaint.
-            It can be a ``PIL.Image``, or a ``height x width x 3`` ``np.array`` or a ``channels x height x width``
-            ``torch.Tensor`` or a ``batch x channels x height x width`` ``torch.Tensor``.
-        mask (_type_): The mask to apply to the image, i.e. regions to inpaint.
-            It can be a ``PIL.Image``, or a ``height x width`` ``np.array`` or a ``1 x height x width``
-            ``torch.Tensor`` or a ``batch x 1 x height x width`` ``torch.Tensor``.
-
-
-    Raises:
-        ValueError: ``torch.Tensor`` images should be in the ``[-1, 1]`` range. ValueError: ``torch.Tensor`` mask
-        should be in the ``[0, 1]`` range. ValueError: ``mask`` and ``image`` should have the same spatial dimensions.
-        TypeError: ``mask`` is a ``torch.Tensor`` but ``image`` is not
-            (ot the other way around).
-
-    Returns:
-        tuple[torch.Tensor]: The pair (mask, masked_image) as ``torch.Tensor`` with 4
-            dimensions: ``batch x channels x height x width``.
-    """
-    if isinstance(image, torch.Tensor):
-        if not isinstance(mask, torch.Tensor):
-            raise TypeError(f"`image` is a torch.Tensor but `mask` (type: {type(mask)} is not")
-
-        # Batch single image
-        if image.ndim == 3:
-            assert image.shape[0] == 3, "Image outside a batch should be of shape (3, H, W)"
-            image = image.unsqueeze(0)
-
-        # Batch and add channel dim for single mask
-        if mask.ndim == 2:
-            mask = mask.unsqueeze(0).unsqueeze(0)
-
-        # Batch single mask or add channel dim
-        if mask.ndim == 3:
-            # Batched mask
-            if mask.shape[0] == image.shape[0]:
-                mask = mask.unsqueeze(1)
-            else:
-                mask = mask.unsqueeze(0)
-
-        assert image.ndim == 4 and mask.ndim == 4, "Image and Mask must have 4 dimensions"
-        assert image.shape[-2:] == mask.shape[-2:], "Image and Mask must have the same spatial dimensions"
-        assert image.shape[0] == mask.shape[0], "Image and Mask must have the same batch size"
-        assert mask.shape[1] == 1, "Mask image must have a single channel"
-
-        # Check image is in [-1, 1]
-        if image.min() < -1 or image.max() > 1:
-            raise ValueError("Image should be in [-1, 1] range")
-
-        # Check mask is in [0, 1]
-        if mask.min() < 0 or mask.max() > 1:
-            raise ValueError("Mask should be in [0, 1] range")
-
-        # paint-by-example inverses the mask
-        mask = 1 - mask
-
-        # Binarize mask
-        mask[mask < 0.5] = 0
-        mask[mask >= 0.5] = 1
-
-        # Image as float32
-        image = image.to(dtype=torch.float32)
-    elif isinstance(mask, torch.Tensor):
-        raise TypeError(f"`mask` is a torch.Tensor but `image` (type: {type(image)} is not")
-    else:
-        if isinstance(image, PIL.Image.Image):
-            image = [image]
-
-        image = np.concatenate([np.array(i.convert("RGB"))[None, :] for i in image], axis=0)
-        image = image.transpose(0, 3, 1, 2)
-        image = torch.from_numpy(image).to(dtype=torch.float32) / 127.5 - 1.0
-
-        # preprocess mask
-        if isinstance(mask, PIL.Image.Image):
-            mask = [mask]
-
-        mask = np.concatenate([np.array(m.convert("L"))[None, None, :] for m in mask], axis=0)
-        mask = mask.astype(np.float32) / 255.0
-
-        # paint-by-example inverses the mask
-        mask = 1 - mask
-
-        mask[mask < 0.5] = 0
-        mask[mask >= 0.5] = 1
-        mask = torch.from_numpy(mask)
-
-    masked_image = image * mask
-
-    return mask, masked_image
-
-
-class PaintByExamplePipeline(DiffusionPipeline):
-    r"""
-    <Tip warning={true}>
-
-    🧪 This is an experimental feature!
-
-    </Tip>
-
-    Pipeline for image-guided image inpainting using Stable Diffusion.
-
-    This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
-    implemented for all pipelines (downloading, saving, running on a particular device, etc.).
-
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) model to encode and decode images to and from latent representations.
-        image_encoder ([`PaintByExampleImageEncoder`]):
-            Encodes the example input image. The `unet` is conditioned on the example image instead of a text prompt.
-        tokenizer ([`~transformers.CLIPTokenizer`]):
-            A `CLIPTokenizer` to tokenize text.
-        unet ([`UNet2DConditionModel`]):
-            A `UNet2DConditionModel` to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
-        safety_checker ([`StableDiffusionSafetyChecker`]):
-            Classification module that estimates whether generated images could be considered offensive or harmful.
-            Please refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for more details
-            about a model's potential harms.
-        feature_extractor ([`~transformers.CLIPImageProcessor`]):
-            A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
-
-    """
-    # TODO: feature_extractor is required to encode initial images (if they are in PIL format),
-    # we should give a descriptive message if the pipeline doesn't have one.
-    _optional_components = ["safety_checker"]
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        image_encoder: PaintByExampleImageEncoder,
-        unet: UNet2DConditionModel,
-        scheduler: Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler],
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPImageProcessor,
-        requires_safety_checker: bool = False,
-    ):
-        super().__init__()
-
-        self.register_modules(
-            vae=vae,
-            image_encoder=image_encoder,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-        self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor)
-        self.register_to_config(requires_safety_checker=requires_safety_checker)
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.run_safety_checker
-    def run_safety_checker(self, image, device, dtype):
-        if self.safety_checker is None:
-            has_nsfw_concept = None
-        else:
-            if torch.is_tensor(image):
-                feature_extractor_input = self.image_processor.postprocess(image, output_type="pil")
-            else:
-                feature_extractor_input = self.image_processor.numpy_to_pil(image)
-            safety_checker_input = self.feature_extractor(feature_extractor_input, return_tensors="pt").to(device)
-            image, has_nsfw_concept = self.safety_checker(
-                images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
-            )
-        return image, has_nsfw_concept
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.decode_latents
-    def decode_latents(self, latents):
-        warnings.warn(
-            "The decode_latents method is deprecated and will be removed in a future version. Please"
-            " use VaeImageProcessor instead",
-            FutureWarning,
-        )
-        latents = 1 / self.vae.config.scaling_factor * latents
-        image = self.vae.decode(latents, return_dict=False)[0]
-        image = (image / 2 + 0.5).clamp(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
-        image = image.cpu().permute(0, 2, 3, 1).float().numpy()
-        return image
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_image_variation.StableDiffusionImageVariationPipeline.check_inputs
-    def check_inputs(self, image, height, width, callback_steps):
-        if (
-            not isinstance(image, torch.Tensor)
-            and not isinstance(image, PIL.Image.Image)
-            and not isinstance(image, list)
-        ):
-            raise ValueError(
-                "`image` has to be of type `torch.FloatTensor` or `PIL.Image.Image` or `List[PIL.Image.Image]` but is"
-                f" {type(image)}"
-            )
-
-        if height % 8 != 0 or width % 8 != 0:
-            raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
-
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_latents
-    def prepare_latents(self, batch_size, num_channels_latents, height, width, dtype, device, generator, latents=None):
-        shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor)
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        if latents is None:
-            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        else:
-            latents = latents.to(device)
-
-        # scale the initial noise by the standard deviation required by the scheduler
-        latents = latents * self.scheduler.init_noise_sigma
-        return latents
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_inpaint.StableDiffusionInpaintPipeline.prepare_mask_latents
-    def prepare_mask_latents(
-        self, mask, masked_image, batch_size, height, width, dtype, device, generator, do_classifier_free_guidance
-    ):
-        # resize the mask to latents shape as we concatenate the mask to the latents
-        # we do that before converting to dtype to avoid breaking in case we're using cpu_offload
-        # and half precision
-        mask = torch.nn.functional.interpolate(
-            mask, size=(height // self.vae_scale_factor, width // self.vae_scale_factor)
-        )
-        mask = mask.to(device=device, dtype=dtype)
-
-        masked_image = masked_image.to(device=device, dtype=dtype)
-        masked_image_latents = self._encode_vae_image(masked_image, generator=generator)
-
-        # duplicate mask and masked_image_latents for each generation per prompt, using mps friendly method
-        if mask.shape[0] < batch_size:
-            if not batch_size % mask.shape[0] == 0:
-                raise ValueError(
-                    "The passed mask and the required batch size don't match. Masks are supposed to be duplicated to"
-                    f" a total batch size of {batch_size}, but {mask.shape[0]} masks were passed. Make sure the number"
-                    " of masks that you pass is divisible by the total requested batch size."
-                )
-            mask = mask.repeat(batch_size // mask.shape[0], 1, 1, 1)
-        if masked_image_latents.shape[0] < batch_size:
-            if not batch_size % masked_image_latents.shape[0] == 0:
-                raise ValueError(
-                    "The passed images and the required batch size don't match. Images are supposed to be duplicated"
-                    f" to a total batch size of {batch_size}, but {masked_image_latents.shape[0]} images were passed."
-                    " Make sure the number of images that you pass is divisible by the total requested batch size."
-                )
-            masked_image_latents = masked_image_latents.repeat(batch_size // masked_image_latents.shape[0], 1, 1, 1)
-
-        mask = torch.cat([mask] * 2) if do_classifier_free_guidance else mask
-        masked_image_latents = (
-            torch.cat([masked_image_latents] * 2) if do_classifier_free_guidance else masked_image_latents
-        )
-
-        # aligning device to prevent device errors when concating it with the latent model input
-        masked_image_latents = masked_image_latents.to(device=device, dtype=dtype)
-        return mask, masked_image_latents
-
-    # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_inpaint.StableDiffusionInpaintPipeline._encode_vae_image
-    def _encode_vae_image(self, image: torch.Tensor, generator: torch.Generator):
-        if isinstance(generator, list):
-            image_latents = [
-                self.vae.encode(image[i : i + 1]).latent_dist.sample(generator=generator[i])
-                for i in range(image.shape[0])
-            ]
-            image_latents = torch.cat(image_latents, dim=0)
-        else:
-            image_latents = self.vae.encode(image).latent_dist.sample(generator=generator)
-
-        image_latents = self.vae.config.scaling_factor * image_latents
-
-        return image_latents
-
-    def _encode_image(self, image, device, num_images_per_prompt, do_classifier_free_guidance):
-        dtype = next(self.image_encoder.parameters()).dtype
-
-        if not isinstance(image, torch.Tensor):
-            image = self.feature_extractor(images=image, return_tensors="pt").pixel_values
-
-        image = image.to(device=device, dtype=dtype)
-        image_embeddings, negative_prompt_embeds = self.image_encoder(image, return_uncond_vector=True)
-
-        # duplicate image embeddings for each generation per prompt, using mps friendly method
-        bs_embed, seq_len, _ = image_embeddings.shape
-        image_embeddings = image_embeddings.repeat(1, num_images_per_prompt, 1)
-        image_embeddings = image_embeddings.view(bs_embed * num_images_per_prompt, seq_len, -1)
-
-        if do_classifier_free_guidance:
-            negative_prompt_embeds = negative_prompt_embeds.repeat(1, image_embeddings.shape[0], 1)
-            negative_prompt_embeds = negative_prompt_embeds.view(bs_embed * num_images_per_prompt, 1, -1)
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            image_embeddings = torch.cat([negative_prompt_embeds, image_embeddings])
-
-        return image_embeddings
-
-    @torch.no_grad()
-    def __call__(
-        self,
-        example_image: Union[torch.FloatTensor, PIL.Image.Image],
-        image: Union[torch.FloatTensor, PIL.Image.Image],
-        mask_image: Union[torch.FloatTensor, PIL.Image.Image],
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 5.0,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-    ):
-        r"""
-        The call function to the pipeline for generation.
-
-        Args:
-            example_image (`torch.FloatTensor` or `PIL.Image.Image` or `List[PIL.Image.Image]`):
-                An example image to guide image generation.
-            image (`torch.FloatTensor` or `PIL.Image.Image` or `List[PIL.Image.Image]`):
-                `Image` or tensor representing an image batch to be inpainted (parts of the image are masked out with
-                `mask_image` and repainted according to `prompt`).
-            mask_image (`torch.FloatTensor` or `PIL.Image.Image` or `List[PIL.Image.Image]`):
-                `Image` or tensor representing an image batch to mask `image`. White pixels in the mask are repainted,
-                while black pixels are preserved. If `mask_image` is a PIL image, it is converted to a single channel
-                (luminance) before use. If it's a tensor, it should contain one color channel (L) instead of 3, so the
-                expected shape would be `(B, H, W, 1)`.
-            height (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
-                The height in pixels of the generated image.
-            width (`int`, *optional*, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
-                The width in pixels of the generated image.
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            guidance_scale (`float`, *optional*, defaults to 7.5):
-                A higher guidance scale value encourages the model to generate images closely linked to the text
-                `prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide what to not include in image generation. If not defined, you need to
-                pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
-            num_images_per_prompt (`int`, *optional*, defaults to 1):
-                The number of images to generate per prompt.
-            eta (`float`, *optional*, defaults to 0.0):
-                Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies
-                to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers.
-            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
-                A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
-                generation deterministic.
-            latents (`torch.FloatTensor`, *optional*):
-                Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
-                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
-                tensor is generated by sampling using the supplied random `generator`.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generated image. Choose between `PIL.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
-                plain tuple.
-            callback (`Callable`, *optional*):
-                A function that calls every `callback_steps` steps during inference. The function is called with the
-                following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`.
-            callback_steps (`int`, *optional*, defaults to 1):
-                The frequency at which the `callback` function is called. If not specified, the callback is called at
-                every step.
-
-        Example:
-
-        ```py
-        >>> import PIL
-        >>> import requests
-        >>> import torch
-        >>> from io import BytesIO
-        >>> from diffusers import PaintByExamplePipeline
-
-
-        >>> def download_image(url):
-        ...     response = requests.get(url)
-        ...     return PIL.Image.open(BytesIO(response.content)).convert("RGB")
-
-
-        >>> img_url = (
-        ...     "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/image/example_1.png"
-        ... )
-        >>> mask_url = (
-        ...     "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/mask/example_1.png"
-        ... )
-        >>> example_url = "https://raw.githubusercontent.com/Fantasy-Studio/Paint-by-Example/main/examples/reference/example_1.jpg"
-
-        >>> init_image = download_image(img_url).resize((512, 512))
-        >>> mask_image = download_image(mask_url).resize((512, 512))
-        >>> example_image = download_image(example_url).resize((512, 512))
-
-        >>> pipe = PaintByExamplePipeline.from_pretrained(
-        ...     "Fantasy-Studio/Paint-by-Example",
-        ...     torch_dtype=torch.float16,
-        ... )
-        >>> pipe = pipe.to("cuda")
-
-        >>> image = pipe(image=init_image, mask_image=mask_image, example_image=example_image).images[0]
-        >>> image
-        ```
-
-        Returns:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
-                If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] is returned,
-                otherwise a `tuple` is returned where the first element is a list with the generated images and the
-                second element is a list of `bool`s indicating whether the corresponding generated image contains
-                "not-safe-for-work" (nsfw) content.
-        """
-        # 1. Define call parameters
-        if isinstance(image, PIL.Image.Image):
-            batch_size = 1
-        elif isinstance(image, list):
-            batch_size = len(image)
-        else:
-            batch_size = image.shape[0]
-        device = self._execution_device
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # 2. Preprocess mask and image
-        mask, masked_image = prepare_mask_and_masked_image(image, mask_image)
-        height, width = masked_image.shape[-2:]
-
-        # 3. Check inputs
-        self.check_inputs(example_image, height, width, callback_steps)
-
-        # 4. Encode input image
-        image_embeddings = self._encode_image(
-            example_image, device, num_images_per_prompt, do_classifier_free_guidance
-        )
-
-        # 5. set timesteps
-        self.scheduler.set_timesteps(num_inference_steps, device=device)
-        timesteps = self.scheduler.timesteps
-
-        # 6. Prepare latent variables
-        num_channels_latents = self.vae.config.latent_channels
-        latents = self.prepare_latents(
-            batch_size * num_images_per_prompt,
-            num_channels_latents,
-            height,
-            width,
-            image_embeddings.dtype,
-            device,
-            generator,
-            latents,
-        )
-
-        # 7. Prepare mask latent variables
-        mask, masked_image_latents = self.prepare_mask_latents(
-            mask,
-            masked_image,
-            batch_size * num_images_per_prompt,
-            height,
-            width,
-            image_embeddings.dtype,
-            device,
-            generator,
-            do_classifier_free_guidance,
-        )
-
-        # 8. Check that sizes of mask, masked image and latents match
-        num_channels_mask = mask.shape[1]
-        num_channels_masked_image = masked_image_latents.shape[1]
-        if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:
-            raise ValueError(
-                f"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects"
-                f" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +"
-                f" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}"
-                f" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of"
-                " `pipeline.unet` or your `mask_image` or `image` input."
-            )
-
-        # 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
-        # 10. Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
-
-                # concat latents, mask, masked_image_latents in the channel dimension
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-                latent_model_input = torch.cat([latent_model_input, masked_image_latents, mask], dim=1)
-
-                # predict the noise residual
-                noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=image_embeddings).sample
-
-                # perform guidance
-                if do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
-        if not output_type == "latent":
-            image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0]
-            image, has_nsfw_concept = self.run_safety_checker(image, device, image_embeddings.dtype)
-        else:
-            image = latents
-            has_nsfw_concept = None
-
-        if has_nsfw_concept is None:
-            do_denormalize = [True] * image.shape[0]
-        else:
-            do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]
-
-        image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)
-
-        if not return_dict:
-            return (image, has_nsfw_concept)
-
-        return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)

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

@@ -1 +0,0 @@
-from .pipeline_score_sde_ve import ScoreSdeVePipeline

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

@@ -1,12 +0,0 @@
-from diffusers.utils.testing_utils import require_onnxruntime
-
-
-@require_onnxruntime
-class OnnxPipelineTesterMixin:
-    """
-    This mixin is designed to be used with unittest.TestCase classes.
-    It provides a set of common tests for each ONNXRuntime pipeline, e.g. saving and loading the pipeline,
-    equivalence of dict and tuple outputs, etc.
-    """
-
-    pass

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/versatile_diffusion/test_versatile_diffusion_text_to_image.py

@@ -1,87 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import gc
-import tempfile
-import unittest
-
-import numpy as np
-import torch
-
-from diffusers import VersatileDiffusionTextToImagePipeline
-from diffusers.utils.testing_utils import nightly, require_torch_gpu, torch_device
-
-
-torch.backends.cuda.matmul.allow_tf32 = False
-
-
-class VersatileDiffusionTextToImagePipelineFastTests(unittest.TestCase):
-    pass
-
-
-@nightly
-@require_torch_gpu
-class VersatileDiffusionTextToImagePipelineIntegrationTests(unittest.TestCase):
-    def tearDown(self):
-        # clean up the VRAM after each test
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-
-    def test_remove_unused_weights_save_load(self):
-        pipe = VersatileDiffusionTextToImagePipeline.from_pretrained("shi-labs/versatile-diffusion")
-        # remove text_unet
-        pipe.remove_unused_weights()
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-
-        prompt = "A painting of a squirrel eating a burger "
-        generator = torch.manual_seed(0)
-        image = pipe(
-            prompt=prompt, generator=generator, guidance_scale=7.5, num_inference_steps=2, output_type="numpy"
-        ).images
-
-        with tempfile.TemporaryDirectory() as tmpdirname:
-            pipe.save_pretrained(tmpdirname)
-            pipe = VersatileDiffusionTextToImagePipeline.from_pretrained(tmpdirname)
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-
-        generator = generator.manual_seed(0)
-        new_image = pipe(
-            prompt=prompt, generator=generator, guidance_scale=7.5, num_inference_steps=2, output_type="numpy"
-        ).images
-
-        assert np.abs(image - new_image).sum() < 1e-5, "Models don't have the same forward pass"
-
-    def test_inference_text2img(self):
-        pipe = VersatileDiffusionTextToImagePipeline.from_pretrained(
-            "shi-labs/versatile-diffusion", torch_dtype=torch.float16
-        )
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-
-        prompt = "A painting of a squirrel eating a burger "
-        generator = torch.manual_seed(0)
-        image = pipe(
-            prompt=prompt, generator=generator, guidance_scale=7.5, num_inference_steps=50, output_type="numpy"
-        ).images
-
-        image_slice = image[0, 253:256, 253:256, -1]
-
-        assert image.shape == (1, 512, 512, 3)
-        expected_slice = np.array([0.3367, 0.3169, 0.2656, 0.3870, 0.4790, 0.3796, 0.4009, 0.4878, 0.4778])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2

spaces/Andy0409/text_generator/README.md

@@ -1,12 +0,0 @@
----
-title: Text Generator
-emoji: 🚀
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 3.11.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

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

@@ -1,43 +0,0 @@
-# WIDER Face Dataset
-
-[DATASET]
-
-To use the WIDER Face dataset you need to download it
-and extract to the `data/WIDERFace` folder. Annotation in the VOC format
-can be found in this [repo](https://github.com/sovrasov/wider-face-pascal-voc-annotations.git).
-You should move the annotation files from `WIDER_train_annotations` and `WIDER_val_annotations` folders
-to the `Annotation` folders inside the corresponding directories `WIDER_train` and `WIDER_val`.
-Also annotation lists `val.txt` and `train.txt` should be copied to `data/WIDERFace` from `WIDER_train_annotations` and `WIDER_val_annotations`.
-The directory should be like this:
-
-```
-mmdetection
-├── mmdet
-├── tools
-├── configs
-├── data
-│   ├── WIDERFace
-│   │   ├── WIDER_train
-│   |   │   ├──0--Parade
-│   |   │   ├── ...
-│   |   │   ├── Annotations
-│   │   ├── WIDER_val
-│   |   │   ├──0--Parade
-│   |   │   ├── ...
-│   |   │   ├── Annotations
-│   │   ├── val.txt
-│   │   ├── train.txt
-
-```
-
-After that you can train the SSD300 on WIDER by launching training with the `ssd300_wider_face.py` config or
-create your own config based on the presented one.
-
-```
-@inproceedings{yang2016wider,
-   Author = {Yang, Shuo and Luo, Ping and Loy, Chen Change and Tang, Xiaoou},
-   Booktitle = {IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
-   Title = {WIDER FACE: A Face Detection Benchmark},
-   Year = {2016}
-}
-```

spaces/Andy1621/uniformer_image_detection/mmdet/models/roi_heads/mask_heads/feature_relay_head.py

@@ -1,55 +0,0 @@
-import torch.nn as nn
-from mmcv.cnn import kaiming_init
-from mmcv.runner import auto_fp16
-
-from mmdet.models.builder import HEADS
-
-
-@HEADS.register_module()
-class FeatureRelayHead(nn.Module):
-    """Feature Relay Head used in `SCNet <https://arxiv.org/abs/2012.10150>`_.
-
-    Args:
-        in_channels (int, optional): number of input channels. Default: 256.
-        conv_out_channels (int, optional): number of output channels before
-            classification layer. Default: 256.
-        roi_feat_size (int, optional): roi feat size at box head. Default: 7.
-        scale_factor (int, optional): scale factor to match roi feat size
-            at mask head. Default: 2.
-    """
-
-    def __init__(self,
-                 in_channels=1024,
-                 out_conv_channels=256,
-                 roi_feat_size=7,
-                 scale_factor=2):
-        super(FeatureRelayHead, self).__init__()
-        assert isinstance(roi_feat_size, int)
-
-        self.in_channels = in_channels
-        self.out_conv_channels = out_conv_channels
-        self.roi_feat_size = roi_feat_size
-        self.out_channels = (roi_feat_size**2) * out_conv_channels
-        self.scale_factor = scale_factor
-        self.fp16_enabled = False
-
-        self.fc = nn.Linear(self.in_channels, self.out_channels)
-        self.upsample = nn.Upsample(
-            scale_factor=scale_factor, mode='bilinear', align_corners=True)
-
-    def init_weights(self):
-        """Init weights for the head."""
-        kaiming_init(self.fc)
-
-    @auto_fp16()
-    def forward(self, x):
-        """Forward function."""
-        N, in_C = x.shape
-        if N > 0:
-            out_C = self.out_conv_channels
-            out_HW = self.roi_feat_size
-            x = self.fc(x)
-            x = x.reshape(N, out_C, out_HW, out_HW)
-            x = self.upsample(x)
-            return x
-        return None

spaces/Andy1621/uniformer_image_segmentation/configs/fcn/fcn_r50-d8_480x480_80k_pascal_context_59.py

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

spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmcv/parallel/registry.py

@@ -1,8 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from torch.nn.parallel import DataParallel, DistributedDataParallel
-
-from annotator.uniformer.mmcv.utils import Registry
-
-MODULE_WRAPPERS = Registry('module wrapper')
-MODULE_WRAPPERS.register_module(module=DataParallel)
-MODULE_WRAPPERS.register_module(module=DistributedDataParallel)

spaces/AriusXi/CodeGenerator/README.md

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

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

@@ -1,255 +0,0 @@
-import collections
-import logging
-import os
-from typing import Container, Dict, Generator, Iterable, List, NamedTuple, Optional, Set
-
-from pip._vendor.packaging.utils import canonicalize_name
-from pip._vendor.packaging.version import Version
-
-from pip._internal.exceptions import BadCommand, InstallationError
-from pip._internal.metadata import BaseDistribution, get_environment
-from pip._internal.req.constructors import (
-    install_req_from_editable,
-    install_req_from_line,
-)
-from pip._internal.req.req_file import COMMENT_RE
-from pip._internal.utils.direct_url_helpers import direct_url_as_pep440_direct_reference
-
-logger = logging.getLogger(__name__)
-
-
-class _EditableInfo(NamedTuple):
-    requirement: str
-    comments: List[str]
-
-
-def freeze(
-    requirement: Optional[List[str]] = None,
-    local_only: bool = False,
-    user_only: bool = False,
-    paths: Optional[List[str]] = None,
-    isolated: bool = False,
-    exclude_editable: bool = False,
-    skip: Container[str] = (),
-) -> Generator[str, None, None]:
-    installations: Dict[str, FrozenRequirement] = {}
-
-    dists = get_environment(paths).iter_installed_distributions(
-        local_only=local_only,
-        skip=(),
-        user_only=user_only,
-    )
-    for dist in dists:
-        req = FrozenRequirement.from_dist(dist)
-        if exclude_editable and req.editable:
-            continue
-        installations[req.canonical_name] = req
-
-    if requirement:
-        # the options that don't get turned into an InstallRequirement
-        # should only be emitted once, even if the same option is in multiple
-        # requirements files, so we need to keep track of what has been emitted
-        # so that we don't emit it again if it's seen again
-        emitted_options: Set[str] = set()
-        # keep track of which files a requirement is in so that we can
-        # give an accurate warning if a requirement appears multiple times.
-        req_files: Dict[str, List[str]] = collections.defaultdict(list)
-        for req_file_path in requirement:
-            with open(req_file_path) as req_file:
-                for line in req_file:
-                    if (
-                        not line.strip()
-                        or line.strip().startswith("#")
-                        or line.startswith(
-                            (
-                                "-r",
-                                "--requirement",
-                                "-f",
-                                "--find-links",
-                                "-i",
-                                "--index-url",
-                                "--pre",
-                                "--trusted-host",
-                                "--process-dependency-links",
-                                "--extra-index-url",
-                                "--use-feature",
-                            )
-                        )
-                    ):
-                        line = line.rstrip()
-                        if line not in emitted_options:
-                            emitted_options.add(line)
-                            yield line
-                        continue
-
-                    if line.startswith("-e") or line.startswith("--editable"):
-                        if line.startswith("-e"):
-                            line = line[2:].strip()
-                        else:
-                            line = line[len("--editable") :].strip().lstrip("=")
-                        line_req = install_req_from_editable(
-                            line,
-                            isolated=isolated,
-                        )
-                    else:
-                        line_req = install_req_from_line(
-                            COMMENT_RE.sub("", line).strip(),
-                            isolated=isolated,
-                        )
-
-                    if not line_req.name:
-                        logger.info(
-                            "Skipping line in requirement file [%s] because "
-                            "it's not clear what it would install: %s",
-                            req_file_path,
-                            line.strip(),
-                        )
-                        logger.info(
-                            "  (add #egg=PackageName to the URL to avoid"
-                            " this warning)"
-                        )
-                    else:
-                        line_req_canonical_name = canonicalize_name(line_req.name)
-                        if line_req_canonical_name not in installations:
-                            # either it's not installed, or it is installed
-                            # but has been processed already
-                            if not req_files[line_req.name]:
-                                logger.warning(
-                                    "Requirement file [%s] contains %s, but "
-                                    "package %r is not installed",
-                                    req_file_path,
-                                    COMMENT_RE.sub("", line).strip(),
-                                    line_req.name,
-                                )
-                            else:
-                                req_files[line_req.name].append(req_file_path)
-                        else:
-                            yield str(installations[line_req_canonical_name]).rstrip()
-                            del installations[line_req_canonical_name]
-                            req_files[line_req.name].append(req_file_path)
-
-        # Warn about requirements that were included multiple times (in a
-        # single requirements file or in different requirements files).
-        for name, files in req_files.items():
-            if len(files) > 1:
-                logger.warning(
-                    "Requirement %s included multiple times [%s]",
-                    name,
-                    ", ".join(sorted(set(files))),
-                )
-
-        yield ("## The following requirements were added by pip freeze:")
-    for installation in sorted(installations.values(), key=lambda x: x.name.lower()):
-        if installation.canonical_name not in skip:
-            yield str(installation).rstrip()
-
-
-def _format_as_name_version(dist: BaseDistribution) -> str:
-    dist_version = dist.version
-    if isinstance(dist_version, Version):
-        return f"{dist.raw_name}=={dist_version}"
-    return f"{dist.raw_name}==={dist_version}"
-
-
-def _get_editable_info(dist: BaseDistribution) -> _EditableInfo:
-    """
-    Compute and return values (req, comments) for use in
-    FrozenRequirement.from_dist().
-    """
-    editable_project_location = dist.editable_project_location
-    assert editable_project_location
-    location = os.path.normcase(os.path.abspath(editable_project_location))
-
-    from pip._internal.vcs import RemoteNotFoundError, RemoteNotValidError, vcs
-
-    vcs_backend = vcs.get_backend_for_dir(location)
-
-    if vcs_backend is None:
-        display = _format_as_name_version(dist)
-        logger.debug(
-            'No VCS found for editable requirement "%s" in: %r',
-            display,
-            location,
-        )
-        return _EditableInfo(
-            requirement=location,
-            comments=[f"# Editable install with no version control ({display})"],
-        )
-
-    vcs_name = type(vcs_backend).__name__
-
-    try:
-        req = vcs_backend.get_src_requirement(location, dist.raw_name)
-    except RemoteNotFoundError:
-        display = _format_as_name_version(dist)
-        return _EditableInfo(
-            requirement=location,
-            comments=[f"# Editable {vcs_name} install with no remote ({display})"],
-        )
-    except RemoteNotValidError as ex:
-        display = _format_as_name_version(dist)
-        return _EditableInfo(
-            requirement=location,
-            comments=[
-                f"# Editable {vcs_name} install ({display}) with either a deleted "
-                f"local remote or invalid URI:",
-                f"# '{ex.url}'",
-            ],
-        )
-    except BadCommand:
-        logger.warning(
-            "cannot determine version of editable source in %s "
-            "(%s command not found in path)",
-            location,
-            vcs_backend.name,
-        )
-        return _EditableInfo(requirement=location, comments=[])
-    except InstallationError as exc:
-        logger.warning("Error when trying to get requirement for VCS system %s", exc)
-    else:
-        return _EditableInfo(requirement=req, comments=[])
-
-    logger.warning("Could not determine repository location of %s", location)
-
-    return _EditableInfo(
-        requirement=location,
-        comments=["## !! Could not determine repository location"],
-    )
-
-
-class FrozenRequirement:
-    def __init__(
-        self,
-        name: str,
-        req: str,
-        editable: bool,
-        comments: Iterable[str] = (),
-    ) -> None:
-        self.name = name
-        self.canonical_name = canonicalize_name(name)
-        self.req = req
-        self.editable = editable
-        self.comments = comments
-
-    @classmethod
-    def from_dist(cls, dist: BaseDistribution) -> "FrozenRequirement":
-        editable = dist.editable
-        if editable:
-            req, comments = _get_editable_info(dist)
-        else:
-            comments = []
-            direct_url = dist.direct_url
-            if direct_url:
-                # if PEP 610 metadata is present, use it
-                req = direct_url_as_pep440_direct_reference(direct_url, dist.raw_name)
-            else:
-                # name==version requirement
-                req = _format_as_name_version(dist)
-
-        return cls(dist.raw_name, req, editable, comments=comments)
-
-    def __str__(self) -> str:
-        req = self.req
-        if self.editable:
-            req = f"-e {req}"
-        return "\n".join(list(self.comments) + [str(req)]) + "\n"

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

@@ -1,5 +0,0 @@
-from .default_styles import DEFAULT_STYLES
-from .theme import Theme
-
-
-DEFAULT = Theme(DEFAULT_STYLES)

spaces/Awiny/Image2Paragraph/models/grit_src/grit/evaluation/eval.py

@@ -1,156 +0,0 @@
-import itertools
-import json
-import os
-from detectron2.structures import Boxes, BoxMode, pairwise_iou
-from detectron2.utils.file_io import PathManager
-import numpy as np
-import pycocotools.mask as mask_util
-from detectron2.evaluation.coco_evaluation import COCOEvaluator
-from detectron2.evaluation.coco_evaluation import _evaluate_predictions_on_coco
-
-
-class GRiTCOCOEvaluator(COCOEvaluator):
-    def process(self, inputs, outputs):
-        for input, output in zip(inputs, outputs):
-            prediction = {"image_id": input["image_id"]}
-
-            if "instances" in output:
-                instances = output["instances"].to(self._cpu_device)
-                prediction["instances"] = instances_to_coco_json(instances, input["image_id"])
-
-            if len(prediction) > 1:
-                self._predictions.append(prediction)
-
-    def _eval_predictions(self, predictions, img_ids=None):
-        self._logger.info("Preparing results for COCO format ...")
-        coco_results = list(itertools.chain(*[x["instances"] for x in predictions]))
-        tasks = self._tasks or self._tasks_from_predictions(coco_results)
-
-        if self._output_dir:
-            file_path = os.path.join(self._output_dir, "coco_instances_results.json")
-            self._logger.info("Saving results to {}".format(file_path))
-            with PathManager.open(file_path, "w") as f:
-                f.write(json.dumps(coco_results))
-                f.flush()
-
-        if not self._do_evaluation:
-            self._logger.info("Annotations are not available for evaluation.")
-            return
-
-        self._logger.info(
-            "Evaluating predictions with {} COCO API...".format(
-                "unofficial" if self._use_fast_impl else "official"
-            )
-        )
-
-        coco_results = self.convert_classname_to_id(coco_results)
-
-        for task in sorted(tasks):
-            assert task in {"bbox", "segm", "keypoints"}, f"Got unknown task: {task}!"
-            coco_eval = (
-                _evaluate_predictions_on_coco(
-                    self._coco_api,
-                    coco_results,
-                    task,
-                    kpt_oks_sigmas=self._kpt_oks_sigmas,
-                    use_fast_impl=self._use_fast_impl,
-                    img_ids=img_ids,
-                    max_dets_per_image=self._max_dets_per_image,
-                )
-                if len(coco_results) > 0
-                else None  # cocoapi does not handle empty results very well
-            )
-
-            res = self._derive_coco_results(
-                coco_eval, task, class_names=self._metadata.get("thing_classes")
-            )
-            self._results[task] = res
-
-    def convert_classname_to_id(self, results):
-        outputs = []
-        class_name_to_id = {}
-        categories = sorted(self._coco_api.dataset['categories'], key=lambda x: x['id'])
-
-        for cat in categories:
-            class_name_to_id[cat['name']] = cat['id']
-
-        for pred in results:
-            if pred['object_descriptions'] in class_name_to_id:
-                pred['category_id'] = class_name_to_id[pred['object_descriptions']]
-                del pred['object_descriptions']
-                outputs.append(pred)
-
-        return outputs
-
-
-class GRiTVGEvaluator(COCOEvaluator):
-    def process(self, inputs, outputs):
-        for input, output in zip(inputs, outputs):
-            assert input["image_id"] == int(input['file_name'].split('/')[-1].split('.')[0])
-            prediction = {"image_id": input["image_id"]}
-
-            if "instances" in output:
-                instances = output["instances"].to(self._cpu_device)
-                prediction["instances"] = instances_to_coco_json(instances, input["image_id"], output_logits=True)
-                h = input['height']
-                w = input['width']
-                scale = 720.0 / max(h, w)
-                scaled_inst = []
-                for inst in prediction["instances"]:
-                    inst['bbox'][0] = inst['bbox'][0] * scale
-                    inst['bbox'][1] = inst['bbox'][1] * scale
-                    inst['bbox'][2] = inst['bbox'][2] * scale
-                    inst['bbox'][3] = inst['bbox'][3] * scale
-                    scaled_inst.append(inst)
-                if len(scaled_inst) > 0:
-                    prediction["instances"] = scaled_inst
-            if len(prediction) > 1:
-                self._predictions.append(prediction)
-
-    def _eval_predictions(self, predictions, img_ids=None):
-        '''
-        This is only for saving the results to json file
-        '''
-        self._logger.info("Preparing results for COCO format ...")
-        coco_results = list(itertools.chain(*[x["instances"] for x in predictions]))
-
-        if self._output_dir:
-            file_path = os.path.join(self._output_dir, "vg_instances_results.json")
-            self._logger.info("Saving results to {}".format(file_path))
-            with PathManager.open(file_path, "w") as f:
-                f.write(json.dumps(coco_results))
-                f.flush()
-
-
-def instances_to_coco_json(instances, img_id, output_logits=False):
-    """
-        Add object_descriptions and logit (if applicable) to
-        detectron2's instances_to_coco_json
-    """
-    num_instance = len(instances)
-    if num_instance == 0:
-        return []
-
-    boxes = instances.pred_boxes.tensor.numpy()
-    boxes = BoxMode.convert(boxes, BoxMode.XYXY_ABS, BoxMode.XYWH_ABS)
-    boxes = boxes.tolist()
-    scores = instances.scores.tolist()
-    classes = instances.pred_classes.tolist()
-    object_descriptions = instances.pred_object_descriptions.data
-    if output_logits:
-        logits = instances.logits.tolist()
-
-    results = []
-    for k in range(num_instance):
-        result = {
-            "image_id": img_id,
-            "category_id": classes[k],
-            "bbox": boxes[k],
-            "score": scores[k],
-            'object_descriptions': object_descriptions[k],
-        }
-        if output_logits:
-            result["logit"] = logits[k]
-
-        results.append(result)
-    return results

spaces/Big-Web/MMSD/env/Lib/site-packages/botocore/endpoint_provider.py

@@ -1,727 +0,0 @@
-# Copyright 2022 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
-#
-# http://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.
-
-"""
-NOTE: All classes and functions in this module are considered private and are
-subject to abrupt breaking changes. Please do not use them directly.
-
-To view the raw JSON that the objects in this module represent, please
-go to any `endpoint-rule-set.json` file in /botocore/data/<service>/<api version>/
-or you can look at the test files in /tests/unit/data/endpoints/valid-rules/
-"""
-
-
-import logging
-import re
-from enum import Enum
-from string import Formatter
-from typing import NamedTuple
-
-from botocore import xform_name
-from botocore.compat import IPV4_RE, quote, urlparse
-from botocore.exceptions import EndpointResolutionError
-from botocore.utils import (
-    ArnParser,
-    InvalidArnException,
-    is_valid_ipv4_endpoint_url,
-    is_valid_ipv6_endpoint_url,
-    lru_cache_weakref,
-    normalize_url_path,
-    percent_encode,
-)
-
-logger = logging.getLogger(__name__)
-
-TEMPLATE_STRING_RE = re.compile(r"\{[a-zA-Z#]+\}")
-GET_ATTR_RE = re.compile(r"(\w+)\[(\d+)\]")
-VALID_HOST_LABEL_RE = re.compile(
-    r"^(?!-)[a-zA-Z\d-]{1,63}(?<!-)$",
-)
-CACHE_SIZE = 100
-ARN_PARSER = ArnParser()
-STRING_FORMATTER = Formatter()
-
-
-class RuleSetStandardLibrary:
-    """Rule actions to be performed by the EndpointProvider."""
-
-    def __init__(self, partitions_data):
-        self.partitions_data = partitions_data
-
-    def is_func(self, argument):
-        """Determine if an object is a function object.
-
-        :type argument: Any
-        :rtype: bool
-        """
-        return isinstance(argument, dict) and "fn" in argument
-
-    def is_ref(self, argument):
-        """Determine if an object is a reference object.
-
-        :type argument: Any
-        :rtype: bool
-        """
-        return isinstance(argument, dict) and "ref" in argument
-
-    def is_template(self, argument):
-        """Determine if an object contains a template string.
-
-        :type argument: Any
-        :rtpe: bool
-        """
-        return (
-            isinstance(argument, str)
-            and TEMPLATE_STRING_RE.search(argument) is not None
-        )
-
-    def resolve_template_string(self, value, scope_vars):
-        """Resolve and inject values into a template string.
-
-        :type value: str
-        :type scope_vars: dict
-        :rtype: str
-        """
-        result = ""
-        for literal, reference, _, _ in STRING_FORMATTER.parse(value):
-            if reference is not None:
-                template_value = scope_vars
-                template_params = reference.split("#")
-                for param in template_params:
-                    template_value = template_value[param]
-                result += f"{literal}{template_value}"
-            else:
-                result += literal
-        return result
-
-    def resolve_value(self, value, scope_vars):
-        """Return evaluated value based on type.
-
-        :type value: Any
-        :type scope_vars: dict
-        :rtype: Any
-        """
-        if self.is_func(value):
-            return self.call_function(value, scope_vars)
-        elif self.is_ref(value):
-            return scope_vars.get(value["ref"])
-        elif self.is_template(value):
-            return self.resolve_template_string(value, scope_vars)
-
-        return value
-
-    def convert_func_name(self, value):
-        """Normalize function names.
-
-        :type value: str
-        :rtype: str
-        """
-        normalized_name = f"{xform_name(value)}"
-        if normalized_name == "not":
-            normalized_name = f"_{normalized_name}"
-        return normalized_name.replace(".", "_")
-
-    def call_function(self, func_signature, scope_vars):
-        """Call the function with the resolved arguments and assign to `scope_vars`
-        when applicable.
-
-        :type func_signature: dict
-        :type scope_vars: dict
-        :rtype: Any
-        """
-        func_args = [
-            self.resolve_value(arg, scope_vars)
-            for arg in func_signature["argv"]
-        ]
-        func_name = self.convert_func_name(func_signature["fn"])
-        func = getattr(self, func_name)
-        result = func(*func_args)
-        if "assign" in func_signature:
-            assign = func_signature["assign"]
-            if assign in scope_vars:
-                raise EndpointResolutionError(
-                    msg=f"Assignment {assign} already exists in "
-                    "scoped variables and cannot be overwritten"
-                )
-            scope_vars[assign] = result
-        return result
-
-    def is_set(self, value):
-        """Evaluates whether a value is set.
-
-        :type value: Any
-        :rytpe: bool
-        """
-        return value is not None
-
-    def get_attr(self, value, path):
-        """Find an attribute within a value given a path string. The path can contain
-        the name of the attribute and an index in brackets. A period separating attribute
-        names indicates the one to the right is nested. The index will always occur at
-        the end of the path.
-
-        :type value: dict or list
-        :type path: str
-        :rtype: Any
-        """
-        for part in path.split("."):
-            match = GET_ATTR_RE.search(part)
-            if match is not None:
-                name, index = match.groups()
-                index = int(index)
-                value = value.get(name)
-                if value is None or index >= len(value):
-                    return None
-                return value[index]
-            else:
-                value = value[part]
-        return value
-
-    def format_partition_output(self, partition):
-        output = partition["outputs"]
-        output["name"] = partition["id"]
-        return output
-
-    def is_partition_match(self, region, partition):
-        matches_regex = re.match(partition["regionRegex"], region) is not None
-        return region in partition["regions"] or matches_regex
-
-    def aws_partition(self, value):
-        """Match a region string to an AWS partition.
-
-        :type value: str
-        :rtype: dict
-        """
-        partitions = self.partitions_data['partitions']
-
-        if value is not None:
-            for partition in partitions:
-                if self.is_partition_match(value, partition):
-                    return self.format_partition_output(partition)
-
-        # return the default partition if no matches were found
-        aws_partition = partitions[0]
-        return self.format_partition_output(aws_partition)
-
-    def aws_parse_arn(self, value):
-        """Parse and validate string for ARN components.
-
-        :type value: str
-        :rtype: dict
-        """
-        if value is None or not value.startswith("arn:"):
-            return None
-
-        try:
-            arn_dict = ARN_PARSER.parse_arn(value)
-        except InvalidArnException:
-            return None
-
-        # partition, resource, and service are required
-        if not all(
-            (arn_dict["partition"], arn_dict["service"], arn_dict["resource"])
-        ):
-            return None
-
-        arn_dict["accountId"] = arn_dict.pop("account")
-
-        resource = arn_dict.pop("resource")
-        arn_dict["resourceId"] = resource.replace(":", "/").split("/")
-
-        return arn_dict
-
-    def is_valid_host_label(self, value, allow_subdomains):
-        """Evaluates whether a value is a valid host label per
-        RFC 1123. If allow_subdomains is True, split on `.` and validate
-        each component separately.
-
-        :type value: str
-        :type allow_subdomains: bool
-        :rtype: bool
-        """
-        if value is None or allow_subdomains is False and value.count(".") > 0:
-            return False
-
-        if allow_subdomains is True:
-            return all(
-                self.is_valid_host_label(label, False)
-                for label in value.split(".")
-            )
-
-        return VALID_HOST_LABEL_RE.match(value) is not None
-
-    def string_equals(self, value1, value2):
-        """Evaluates two string values for equality.
-
-        :type value1: str
-        :type value2: str
-        :rtype: bool
-        """
-        if not all(isinstance(val, str) for val in (value1, value2)):
-            msg = f"Both values must be strings, not {type(value1)} and {type(value2)}."
-            raise EndpointResolutionError(msg=msg)
-        return value1 == value2
-
-    def uri_encode(self, value):
-        """Perform percent-encoding on an input string.
-
-        :type value: str
-        :rytpe: str
-        """
-        if value is None:
-            return None
-
-        return percent_encode(value)
-
-    def parse_url(self, value):
-        """Parse a URL string into components.
-
-        :type value: str
-        :rtype: dict
-        """
-        if value is None:
-            return None
-
-        url_components = urlparse(value)
-        try:
-            # url_parse may assign non-integer values to
-            # `port` and will fail when accessed.
-            url_components.port
-        except ValueError:
-            return None
-
-        scheme = url_components.scheme
-        query = url_components.query
-        # URLs with queries are not supported
-        if scheme not in ("https", "http") or len(query) > 0:
-            return None
-
-        path = url_components.path
-        normalized_path = quote(normalize_url_path(path))
-        if not normalized_path.endswith("/"):
-            normalized_path = f"{normalized_path}/"
-
-        return {
-            "scheme": scheme,
-            "authority": url_components.netloc,
-            "path": path,
-            "normalizedPath": normalized_path,
-            "isIp": is_valid_ipv4_endpoint_url(value)
-            or is_valid_ipv6_endpoint_url(value),
-        }
-
-    def boolean_equals(self, value1, value2):
-        """Evaluates two boolean values for equality.
-
-        :type value1: bool
-        :type value2: bool
-        :rtype: bool
-        """
-        if not all(isinstance(val, bool) for val in (value1, value2)):
-            msg = f"Both arguments must be bools, not {type(value1)} and {type(value2)}."
-            raise EndpointResolutionError(msg=msg)
-        return value1 is value2
-
-    def is_ascii(self, value):
-        """Evaluates if a string only contains ASCII characters.
-
-        :type value: str
-        :rtype: bool
-        """
-        try:
-            value.encode("ascii")
-            return True
-        except UnicodeEncodeError:
-            return False
-
-    def substring(self, value, start, stop, reverse):
-        """Computes a substring given the start index and end index. If `reverse` is
-        True, slice the string from the end instead.
-
-        :type value: str
-        :type start: int
-        :type end: int
-        :type reverse: bool
-        :rtype: str
-        """
-        if not isinstance(value, str):
-            msg = f"Input must be a string, not {type(value)}."
-            raise EndpointResolutionError(msg=msg)
-        if start >= stop or len(value) < stop or not self.is_ascii(value):
-            return None
-
-        if reverse is True:
-            r_start = len(value) - stop
-            r_stop = len(value) - start
-            return value[r_start:r_stop]
-
-        return value[start:stop]
-
-    def _not(self, value):
-        """A function implementation of the logical operator `not`.
-
-        :type value: Any
-        :rtype: bool
-        """
-        return not value
-
-    def aws_is_virtual_hostable_s3_bucket(self, value, allow_subdomains):
-        """Evaluates whether a value is a valid bucket name for virtual host
-        style bucket URLs. To pass, the value must meet the following criteria:
-        1. is_valid_host_label(value) is True
-        2. length between 3 and 63 characters (inclusive)
-        3. does not contain uppercase characters
-        4. is not formatted as an IP address
-
-        If allow_subdomains is True, split on `.` and validate
-        each component separately.
-
-        :type value: str
-        :type allow_subdomains: bool
-        :rtype: bool
-        """
-        if (
-            value is None
-            or len(value) < 3
-            or value.lower() != value
-            or IPV4_RE.match(value) is not None
-        ):
-            return False
-
-        if allow_subdomains is True:
-            return all(
-                self.aws_is_virtual_hostable_s3_bucket(label, False)
-                for label in value.split(".")
-            )
-
-        return self.is_valid_host_label(value, allow_subdomains=False)
-
-
-# maintains backwards compatibility as `Library` was misspelled
-# in earlier versions
-RuleSetStandardLibary = RuleSetStandardLibrary
-
-
-class BaseRule:
-    """Base interface for individual endpoint rules."""
-
-    def __init__(self, conditions, documentation=None):
-        self.conditions = conditions
-        self.documentation = documentation
-
-    def evaluate(self, scope_vars, rule_lib):
-        raise NotImplementedError()
-
-    def evaluate_conditions(self, scope_vars, rule_lib):
-        """Determine if all conditions in a rule are met.
-
-        :type scope_vars: dict
-        :type rule_lib: RuleSetStandardLibrary
-        :rtype: bool
-        """
-        for func_signature in self.conditions:
-            result = rule_lib.call_function(func_signature, scope_vars)
-            if result is False or result is None:
-                return False
-        return True
-
-
-class RuleSetEndpoint(NamedTuple):
-    """A resolved endpoint object returned by a rule."""
-
-    url: str
-    properties: dict
-    headers: dict
-
-
-class EndpointRule(BaseRule):
-    def __init__(self, endpoint, **kwargs):
-        super().__init__(**kwargs)
-        self.endpoint = endpoint
-
-    def evaluate(self, scope_vars, rule_lib):
-        """Determine if conditions are met to provide a valid endpoint.
-
-        :type scope_vars: dict
-        :rtype: RuleSetEndpoint
-        """
-        if self.evaluate_conditions(scope_vars, rule_lib):
-            url = rule_lib.resolve_value(self.endpoint["url"], scope_vars)
-            properties = self.resolve_properties(
-                self.endpoint.get("properties", {}),
-                scope_vars,
-                rule_lib,
-            )
-            headers = self.resolve_headers(scope_vars, rule_lib)
-            return RuleSetEndpoint(
-                url=url, properties=properties, headers=headers
-            )
-
-        return None
-
-    def resolve_properties(self, properties, scope_vars, rule_lib):
-        """Traverse `properties` attribute, resolving any template strings.
-
-        :type properties: dict/list/str
-        :type scope_vars: dict
-        :type rule_lib: RuleSetStandardLibrary
-        :rtype: dict
-        """
-        if isinstance(properties, list):
-            return [
-                self.resolve_properties(prop, scope_vars, rule_lib)
-                for prop in properties
-            ]
-        elif isinstance(properties, dict):
-            return {
-                key: self.resolve_properties(value, scope_vars, rule_lib)
-                for key, value in properties.items()
-            }
-        elif rule_lib.is_template(properties):
-            return rule_lib.resolve_template_string(properties, scope_vars)
-
-        return properties
-
-    def resolve_headers(self, scope_vars, rule_lib):
-        """Iterate through headers attribute resolving all values.
-
-        :type scope_vars: dict
-        :type rule_lib: RuleSetStandardLibrary
-        :rtype: dict
-        """
-        resolved_headers = {}
-        headers = self.endpoint.get("headers", {})
-
-        for header, values in headers.items():
-            resolved_headers[header] = [
-                rule_lib.resolve_value(item, scope_vars) for item in values
-            ]
-        return resolved_headers
-
-
-class ErrorRule(BaseRule):
-    def __init__(self, error, **kwargs):
-        super().__init__(**kwargs)
-        self.error = error
-
-    def evaluate(self, scope_vars, rule_lib):
-        """If an error rule's conditions are met, raise an error rule.
-
-        :type scope_vars: dict
-        :type rule_lib: RuleSetStandardLibrary
-        :rtype: EndpointResolutionError
-        """
-        if self.evaluate_conditions(scope_vars, rule_lib):
-            error = rule_lib.resolve_value(self.error, scope_vars)
-            raise EndpointResolutionError(msg=error)
-        return None
-
-
-class TreeRule(BaseRule):
-    """A tree rule is non-terminal meaning it will never be returned to a provider.
-    Additionally this means it has no attributes that need to be resolved.
-    """
-
-    def __init__(self, rules, **kwargs):
-        super().__init__(**kwargs)
-        self.rules = [RuleCreator.create(**rule) for rule in rules]
-
-    def evaluate(self, scope_vars, rule_lib):
-        """If a tree rule's conditions are met, iterate its sub-rules
-        and return first result found.
-
-        :type scope_vars: dict
-        :type rule_lib: RuleSetStandardLibrary
-        :rtype: RuleSetEndpoint/EndpointResolutionError
-        """
-        if self.evaluate_conditions(scope_vars, rule_lib):
-            for rule in self.rules:
-                # don't share scope_vars between rules
-                rule_result = rule.evaluate(scope_vars.copy(), rule_lib)
-                if rule_result:
-                    return rule_result
-        return None
-
-
-class RuleCreator:
-
-    endpoint = EndpointRule
-    error = ErrorRule
-    tree = TreeRule
-
-    @classmethod
-    def create(cls, **kwargs):
-        """Create a rule instance from metadata.
-
-        :rtype: TreeRule/EndpointRule/ErrorRule
-        """
-        rule_type = kwargs.pop("type")
-        try:
-            rule_class = getattr(cls, rule_type)
-        except AttributeError:
-            raise EndpointResolutionError(
-                msg=f"Unknown rule type: {rule_type}. A rule must "
-                "be of type tree, endpoint or error."
-            )
-        else:
-            return rule_class(**kwargs)
-
-
-class ParameterType(Enum):
-    """Translation from `type` attribute to native Python type."""
-
-    string = str
-    boolean = bool
-
-
-class ParameterDefinition:
-    """The spec of an individual parameter defined in a RuleSet."""
-
-    def __init__(
-        self,
-        name,
-        parameter_type,
-        documentation=None,
-        builtIn=None,
-        default=None,
-        required=None,
-        deprecated=None,
-    ):
-        self.name = name
-        try:
-            self.parameter_type = getattr(
-                ParameterType, parameter_type.lower()
-            ).value
-        except AttributeError:
-            raise EndpointResolutionError(
-                msg=f"Unknown parameter type: {parameter_type}. "
-                "A parameter must be of type string or boolean."
-            )
-        self.documentation = documentation
-        self.builtin = builtIn
-        self.default = default
-        self.required = required
-        self.deprecated = deprecated
-
-    def validate_input(self, value):
-        """Perform base validation on parameter input.
-
-        :type value: Any
-        :raises: EndpointParametersError
-        """
-
-        if not isinstance(value, self.parameter_type):
-            raise EndpointResolutionError(
-                msg=f"Value ({self.name}) is the wrong "
-                f"type. Must be {self.parameter_type}."
-            )
-        if self.deprecated is not None:
-            depr_str = f"{self.name} has been deprecated."
-            msg = self.deprecated.get("message")
-            since = self.deprecated.get("since")
-            if msg:
-                depr_str += f"\n{msg}"
-            if since:
-                depr_str += f"\nDeprecated since {since}."
-            logger.info(depr_str)
-
-        return None
-
-    def process_input(self, value):
-        """Process input against spec, applying default if value is None."""
-        if value is None:
-            if self.default is not None:
-                return self.default
-            if self.required:
-                raise EndpointResolutionError(
-                    f"Cannot find value for required parameter {self.name}"
-                )
-            # in all other cases, the parameter will keep the value None
-        else:
-            self.validate_input(value)
-        return value
-
-
-class RuleSet:
-    """Collection of rules to derive a routable service endpoint."""
-
-    def __init__(
-        self, version, parameters, rules, partitions, documentation=None
-    ):
-        self.version = version
-        self.parameters = self._ingest_parameter_spec(parameters)
-        self.rules = [RuleCreator.create(**rule) for rule in rules]
-        self.rule_lib = RuleSetStandardLibrary(partitions)
-        self.documentation = documentation
-
-    def _ingest_parameter_spec(self, parameters):
-        return {
-            name: ParameterDefinition(
-                name,
-                spec["type"],
-                spec.get("documentation"),
-                spec.get("builtIn"),
-                spec.get("default"),
-                spec.get("required"),
-                spec.get("deprecated"),
-            )
-            for name, spec in parameters.items()
-        }
-
-    def process_input_parameters(self, input_params):
-        """Process each input parameter against its spec.
-
-        :type input_params: dict
-        """
-        for name, spec in self.parameters.items():
-            value = spec.process_input(input_params.get(name))
-            if value is not None:
-                input_params[name] = value
-        return None
-
-    def evaluate(self, input_parameters):
-        """Evaluate input parameters against rules returning first match.
-
-        :type input_parameters: dict
-        """
-        self.process_input_parameters(input_parameters)
-        for rule in self.rules:
-            evaluation = rule.evaluate(input_parameters.copy(), self.rule_lib)
-            if evaluation is not None:
-                return evaluation
-        return None
-
-
-class EndpointProvider:
-    """Derives endpoints from a RuleSet for given input parameters."""
-
-    def __init__(self, ruleset_data, partition_data):
-        self.ruleset = RuleSet(**ruleset_data, partitions=partition_data)
-
-    @lru_cache_weakref(maxsize=CACHE_SIZE)
-    def resolve_endpoint(self, **input_parameters):
-        """Match input parameters to a rule.
-
-        :type input_parameters: dict
-        :rtype: RuleSetEndpoint
-        """
-        params_for_error = input_parameters.copy()
-        endpoint = self.ruleset.evaluate(input_parameters)
-        if endpoint is None:
-            param_string = "\n".join(
-                [f"{key}: {value}" for key, value in params_for_error.items()]
-            )
-            raise EndpointResolutionError(
-                msg=f"No endpoint found for parameters:\n{param_string}"
-            )
-        return endpoint

spaces/Big-Web/MMSD/env/Lib/site-packages/urllib3/_collections.py

@@ -1,337 +0,0 @@
-from __future__ import absolute_import
-
-try:
-    from collections.abc import Mapping, MutableMapping
-except ImportError:
-    from collections import Mapping, MutableMapping
-try:
-    from threading import RLock
-except ImportError:  # Platform-specific: No threads available
-
-    class RLock:
-        def __enter__(self):
-            pass
-
-        def __exit__(self, exc_type, exc_value, traceback):
-            pass
-
-
-from collections import OrderedDict
-
-from .exceptions import InvalidHeader
-from .packages import six
-from .packages.six import iterkeys, itervalues
-
-__all__ = ["RecentlyUsedContainer", "HTTPHeaderDict"]
-
-
-_Null = object()
-
-
-class RecentlyUsedContainer(MutableMapping):
-    """
-    Provides a thread-safe dict-like container which maintains up to
-    ``maxsize`` keys while throwing away the least-recently-used keys beyond
-    ``maxsize``.
-
-    :param maxsize:
-        Maximum number of recent elements to retain.
-
-    :param dispose_func:
-        Every time an item is evicted from the container,
-        ``dispose_func(value)`` is called.  Callback which will get called
-    """
-
-    ContainerCls = OrderedDict
-
-    def __init__(self, maxsize=10, dispose_func=None):
-        self._maxsize = maxsize
-        self.dispose_func = dispose_func
-
-        self._container = self.ContainerCls()
-        self.lock = RLock()
-
-    def __getitem__(self, key):
-        # Re-insert the item, moving it to the end of the eviction line.
-        with self.lock:
-            item = self._container.pop(key)
-            self._container[key] = item
-            return item
-
-    def __setitem__(self, key, value):
-        evicted_value = _Null
-        with self.lock:
-            # Possibly evict the existing value of 'key'
-            evicted_value = self._container.get(key, _Null)
-            self._container[key] = value
-
-            # If we didn't evict an existing value, we might have to evict the
-            # least recently used item from the beginning of the container.
-            if len(self._container) > self._maxsize:
-                _key, evicted_value = self._container.popitem(last=False)
-
-        if self.dispose_func and evicted_value is not _Null:
-            self.dispose_func(evicted_value)
-
-    def __delitem__(self, key):
-        with self.lock:
-            value = self._container.pop(key)
-
-        if self.dispose_func:
-            self.dispose_func(value)
-
-    def __len__(self):
-        with self.lock:
-            return len(self._container)
-
-    def __iter__(self):
-        raise NotImplementedError(
-            "Iteration over this class is unlikely to be threadsafe."
-        )
-
-    def clear(self):
-        with self.lock:
-            # Copy pointers to all values, then wipe the mapping
-            values = list(itervalues(self._container))
-            self._container.clear()
-
-        if self.dispose_func:
-            for value in values:
-                self.dispose_func(value)
-
-    def keys(self):
-        with self.lock:
-            return list(iterkeys(self._container))
-
-
-class HTTPHeaderDict(MutableMapping):
-    """
-    :param headers:
-        An iterable of field-value pairs. Must not contain multiple field names
-        when compared case-insensitively.
-
-    :param kwargs:
-        Additional field-value pairs to pass in to ``dict.update``.
-
-    A ``dict`` like container for storing HTTP Headers.
-
-    Field names are stored and compared case-insensitively in compliance with
-    RFC 7230. Iteration provides the first case-sensitive key seen for each
-    case-insensitive pair.
-
-    Using ``__setitem__`` syntax overwrites fields that compare equal
-    case-insensitively in order to maintain ``dict``'s api. For fields that
-    compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``
-    in a loop.
-
-    If multiple fields that are equal case-insensitively are passed to the
-    constructor or ``.update``, the behavior is undefined and some will be
-    lost.
-
-    >>> headers = HTTPHeaderDict()
-    >>> headers.add('Set-Cookie', 'foo=bar')
-    >>> headers.add('set-cookie', 'baz=quxx')
-    >>> headers['content-length'] = '7'
-    >>> headers['SET-cookie']
-    'foo=bar, baz=quxx'
-    >>> headers['Content-Length']
-    '7'
-    """
-
-    def __init__(self, headers=None, **kwargs):
-        super(HTTPHeaderDict, self).__init__()
-        self._container = OrderedDict()
-        if headers is not None:
-            if isinstance(headers, HTTPHeaderDict):
-                self._copy_from(headers)
-            else:
-                self.extend(headers)
-        if kwargs:
-            self.extend(kwargs)
-
-    def __setitem__(self, key, val):
-        self._container[key.lower()] = [key, val]
-        return self._container[key.lower()]
-
-    def __getitem__(self, key):
-        val = self._container[key.lower()]
-        return ", ".join(val[1:])
-
-    def __delitem__(self, key):
-        del self._container[key.lower()]
-
-    def __contains__(self, key):
-        return key.lower() in self._container
-
-    def __eq__(self, other):
-        if not isinstance(other, Mapping) and not hasattr(other, "keys"):
-            return False
-        if not isinstance(other, type(self)):
-            other = type(self)(other)
-        return dict((k.lower(), v) for k, v in self.itermerged()) == dict(
-            (k.lower(), v) for k, v in other.itermerged()
-        )
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    if six.PY2:  # Python 2
-        iterkeys = MutableMapping.iterkeys
-        itervalues = MutableMapping.itervalues
-
-    __marker = object()
-
-    def __len__(self):
-        return len(self._container)
-
-    def __iter__(self):
-        # Only provide the originally cased names
-        for vals in self._container.values():
-            yield vals[0]
-
-    def pop(self, key, default=__marker):
-        """D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
-        If key is not found, d is returned if given, otherwise KeyError is raised.
-        """
-        # Using the MutableMapping function directly fails due to the private marker.
-        # Using ordinary dict.pop would expose the internal structures.
-        # So let's reinvent the wheel.
-        try:
-            value = self[key]
-        except KeyError:
-            if default is self.__marker:
-                raise
-            return default
-        else:
-            del self[key]
-            return value
-
-    def discard(self, key):
-        try:
-            del self[key]
-        except KeyError:
-            pass
-
-    def add(self, key, val):
-        """Adds a (name, value) pair, doesn't overwrite the value if it already
-        exists.
-
-        >>> headers = HTTPHeaderDict(foo='bar')
-        >>> headers.add('Foo', 'baz')
-        >>> headers['foo']
-        'bar, baz'
-        """
-        key_lower = key.lower()
-        new_vals = [key, val]
-        # Keep the common case aka no item present as fast as possible
-        vals = self._container.setdefault(key_lower, new_vals)
-        if new_vals is not vals:
-            vals.append(val)
-
-    def extend(self, *args, **kwargs):
-        """Generic import function for any type of header-like object.
-        Adapted version of MutableMapping.update in order to insert items
-        with self.add instead of self.__setitem__
-        """
-        if len(args) > 1:
-            raise TypeError(
-                "extend() takes at most 1 positional "
-                "arguments ({0} given)".format(len(args))
-            )
-        other = args[0] if len(args) >= 1 else ()
-
-        if isinstance(other, HTTPHeaderDict):
-            for key, val in other.iteritems():
-                self.add(key, val)
-        elif isinstance(other, Mapping):
-            for key in other:
-                self.add(key, other[key])
-        elif hasattr(other, "keys"):
-            for key in other.keys():
-                self.add(key, other[key])
-        else:
-            for key, value in other:
-                self.add(key, value)
-
-        for key, value in kwargs.items():
-            self.add(key, value)
-
-    def getlist(self, key, default=__marker):
-        """Returns a list of all the values for the named field. Returns an
-        empty list if the key doesn't exist."""
-        try:
-            vals = self._container[key.lower()]
-        except KeyError:
-            if default is self.__marker:
-                return []
-            return default
-        else:
-            return vals[1:]
-
-    # Backwards compatibility for httplib
-    getheaders = getlist
-    getallmatchingheaders = getlist
-    iget = getlist
-
-    # Backwards compatibility for http.cookiejar
-    get_all = getlist
-
-    def __repr__(self):
-        return "%s(%s)" % (type(self).__name__, dict(self.itermerged()))
-
-    def _copy_from(self, other):
-        for key in other:
-            val = other.getlist(key)
-            if isinstance(val, list):
-                # Don't need to convert tuples
-                val = list(val)
-            self._container[key.lower()] = [key] + val
-
-    def copy(self):
-        clone = type(self)()
-        clone._copy_from(self)
-        return clone
-
-    def iteritems(self):
-        """Iterate over all header lines, including duplicate ones."""
-        for key in self:
-            vals = self._container[key.lower()]
-            for val in vals[1:]:
-                yield vals[0], val
-
-    def itermerged(self):
-        """Iterate over all headers, merging duplicate ones together."""
-        for key in self:
-            val = self._container[key.lower()]
-            yield val[0], ", ".join(val[1:])
-
-    def items(self):
-        return list(self.iteritems())
-
-    @classmethod
-    def from_httplib(cls, message):  # Python 2
-        """Read headers from a Python 2 httplib message object."""
-        # python2.7 does not expose a proper API for exporting multiheaders
-        # efficiently. This function re-reads raw lines from the message
-        # object and extracts the multiheaders properly.
-        obs_fold_continued_leaders = (" ", "\t")
-        headers = []
-
-        for line in message.headers:
-            if line.startswith(obs_fold_continued_leaders):
-                if not headers:
-                    # We received a header line that starts with OWS as described
-                    # in RFC-7230 S3.2.4. This indicates a multiline header, but
-                    # there exists no previous header to which we can attach it.
-                    raise InvalidHeader(
-                        "Header continuation with no previous header: %s" % line
-                    )
-                else:
-                    key, value = headers[-1]
-                    headers[-1] = (key, value + " " + line.strip())
-                    continue
-
-            key, value = line.split(":", 1)
-            headers.append((key, value.strip()))
-
-        return cls(headers)

spaces/Boynn/AI/README.md

@@ -1,13 +0,0 @@
----
-title: AI
-emoji: 🏆
-colorFrom: purple
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.34.0
-app_file: app.py
-pinned: false
-license: other
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/BridgeTower/bridgetower-video-search/bridgetower_custom.py

@@ -1,183 +0,0 @@
-from collections import OrderedDict
-from typing import List, Optional, Tuple, Union
-
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-from torchvision import transforms
-from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
-
-from transformers.modeling_outputs import SequenceClassifierOutput
-
-from transformers import BridgeTowerPreTrainedModel, BridgeTowerModel
-from transformers.models.bridgetower.modeling_bridgetower import BridgeTowerTextModel
-
-class LayerNorm(nn.LayerNorm):
-    """Subclass torch's LayerNorm to handle fp16."""
-
-    def forward(self, x: torch.Tensor):
-        orig_type = x.dtype
-        ret = super().forward(x.type(torch.float32))
-        return ret.type(orig_type)
-
-class BridgeTowerImageFeatureExtractor(nn.Module):
-    def __init__(
-            self, 
-            patch_size=14, 
-            width=1024, 
-            resolution_after=294, 
-            ckpt_path=None,
-        ):
-        super().__init__()
-
-        self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)
-
-        scale = width ** -0.5
-        self.class_embedding = nn.Parameter(scale * torch.randn(width))
-        self.positional_embedding = nn.Parameter(scale * torch.randn((resolution_after // patch_size) ** 2 + 1, width))
-        self.ln_pre = LayerNorm(width)
-
-        if ckpt_path is not None:
-            sd = torch.load(ckpt_path)
-            if 'state_dict' in sd:
-                sd = sd["state_dict"]
-            print(f'Loading feature extractor checkpoint from {ckpt_path}')
-            self.load_state_dict(sd)
-
-    def forward(self, x: torch.Tensor):
-        x = self.conv1(x)  # shape = [*, width, grid, grid]
-        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
-        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
-        t=self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device)
-        x = torch.cat([t, x], dim=1)  # shape = [*, grid ** 2 + 1, width]
-        x = x + self.positional_embedding.to(x.dtype)
-        x = self.ln_pre(x)
-        x = x.permute(1, 0, 2)  # NLD -> LND
-        return x
-
-
-class BridgeTowerITCHead(nn.Module):
-    def __init__(self, hidden_size, embed_size):
-        super().__init__()
-        self.fc = nn.Linear(hidden_size, embed_size)
-
-    def forward(self, x):
-        x = self.fc(x)
-        return x
-
-
-class _BridgeTowerTextModelWrapper(nn.Module):
-    def __init__(self, config):
-        super().__init__()
-        self.text_model = BridgeTowerTextModel(config)
-
-    def forward(self, **kwargs):
-        return self.text_model(**kwargs)
-
-
-class BridgeTowerTextFeatureExtractor(BridgeTowerPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bridgetower = _BridgeTowerTextModelWrapper(config.text_config)
-        self.itc_text_head = BridgeTowerITCHead(config.hidden_size, config.contrastive_hidden_size)
-
-    def forward(
-        self,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.FloatTensor] = None,
-        token_type_ids: Optional[torch.LongTensor] = None,
-        head_mask: Optional[torch.FloatTensor] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-        labels: Optional[torch.LongTensor] = None,
-    ):
-        
-        outputs = self.bridgetower(input_ids=input_ids, attention_mask=attention_mask, output_hidden_states=True)
-        final_hidden_cls = outputs.hidden_states[-1][:,0,:]
-        final_hidden_cls = F.normalize(self.itc_text_head(final_hidden_cls), dim=-1, p=2)
-
-        return final_hidden_cls
-    
-
-class BridgeTowerForITC(BridgeTowerPreTrainedModel):
-    def __init__(self, config):
-        super().__init__(config)
-
-        self.bridgetower = BridgeTowerModel(config)
-
-        self.itc_text_head = BridgeTowerITCHead(config.hidden_size, config.contrastive_hidden_size)
-        self.itc_image_head = BridgeTowerITCHead(config.hidden_size, config.contrastive_hidden_size)
-        self.itc_cross_modal_head = BridgeTowerITCHead(config.hidden_size * 2, config.contrastive_hidden_size)
-
-        # Initialize weights and apply final processing
-        self.post_init()
-
-    def forward(
-        self,
-        input_ids: Optional[torch.LongTensor] = None,
-        attention_mask: Optional[torch.FloatTensor] = None,
-        token_type_ids: Optional[torch.LongTensor] = None,
-        pixel_values: Optional[torch.FloatTensor] = None,
-        pixel_mask: Optional[torch.LongTensor] = None,
-        head_mask: Optional[torch.FloatTensor] = None,
-        inputs_embeds: Optional[torch.FloatTensor] = None,
-        image_embeds: Optional[torch.FloatTensor] = None,
-        output_attentions: Optional[bool] = None,
-        output_hidden_states: Optional[bool] = None,
-        return_dict: Optional[bool] = None,
-        labels: Optional[torch.LongTensor] = None,
-    ) -> Union[SequenceClassifierOutput, Tuple[torch.FloatTensor]]:
-
-        assert output_hidden_states, 'output_hidden_states should be set to True for BridgeTowerForITC'
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-
-        outputs = self.bridgetower(
-            input_ids,
-            attention_mask=attention_mask,
-            token_type_ids=token_type_ids,
-            pixel_values=pixel_values,
-            pixel_mask=pixel_mask,
-            head_mask=head_mask,
-            inputs_embeds=inputs_embeds,
-            image_embeds=image_embeds,
-            output_attentions=output_attentions,
-            output_hidden_states=output_hidden_states,
-            return_dict=return_dict,
-        )
-
-        pooler_output = outputs.pooler_output if return_dict else outputs[2]
-
-        hidden_states_txt, hidden_states_img, hidden_states_cross_modal = outputs.hidden_states
-
-        final_hidden_txt = hidden_states_txt[-1]
-        final_hidden_img = hidden_states_img[-1]
-
-        image_embeds_with_ln = self.bridgetower.vision_model.visual.forward_post(final_hidden_img)
-        image_token_type_embeddings = self.bridgetower.token_type_embeddings(
-            torch.full((1,), 1, dtype=torch.long, device=self.bridgetower.token_type_embeddings.weight.device)
-        ).expand_as(image_embeds_with_ln)
-
-        final_hidden_img = (
-            self.bridgetower.cross_modal_image_transform(image_embeds_with_ln)
-            + image_token_type_embeddings
-        )
-
-        final_hidden_txt = F.normalize(self.itc_text_head(final_hidden_txt[:,0,:]), dim=-1, p=2)
-        final_hidden_img = F.normalize(self.itc_image_head(final_hidden_img[:,0,:]), dim=-1, p=2)
-        final_hidden_cross = F.normalize(self.itc_cross_modal_head(pooler_output), dim=-1, p=2)
-
-        logits = torch.stack([final_hidden_txt, final_hidden_img, final_hidden_cross], dim=-2)
-
-        if not return_dict:
-            return tuple(logits)
-
-        return SequenceClassifierOutput(
-            loss=None,
-            logits=logits,
-            hidden_states=outputs.hidden_states,
-            attentions=outputs.attentions,
-        )

spaces/CALM/Dashboard/streamlit_observable/frontend/build/service-worker.js

@@ -1,39 +0,0 @@
-/**
- * Welcome to your Workbox-powered service worker!
- *
- * You'll need to register this file in your web app and you should
- * disable HTTP caching for this file too.
- * See https://goo.gl/nhQhGp
- *
- * The rest of the code is auto-generated. Please don't update this file
- * directly; instead, make changes to your Workbox build configuration
- * and re-run your build process.
- * See https://goo.gl/2aRDsh
- */
-
-importScripts("https://storage.googleapis.com/workbox-cdn/releases/4.3.1/workbox-sw.js");
-
-importScripts(
-  "./precache-manifest.2e1db2924cb1e112608cee049b0d33cc.js"
-);
-
-self.addEventListener('message', (event) => {
-  if (event.data && event.data.type === 'SKIP_WAITING') {
-    self.skipWaiting();
-  }
-});
-
-workbox.core.clientsClaim();
-
-/**
- * The workboxSW.precacheAndRoute() method efficiently caches and responds to
- * requests for URLs in the manifest.
- * See https://goo.gl/S9QRab
- */
-self.__precacheManifest = [].concat(self.__precacheManifest || []);
-workbox.precaching.precacheAndRoute(self.__precacheManifest, {});
-
-workbox.routing.registerNavigationRoute(workbox.precaching.getCacheKeyForURL("./index.html"), {
-  
-  blacklist: [/^\/_/,/\/[^/?]+\.[^/]+$/],
-});

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/docs/tutorials/evaluation.md

@@ -1,43 +0,0 @@
-
-# Evaluation
-
-Evaluation is a process that takes a number of inputs/outputs pairs and aggregate them.
-You can always [use the model](models.html) directly and just parse its inputs/outputs manually to perform
-evaluation.
-Alternatively, evaluation is implemented in detectron2 using the [DatasetEvaluator](../modules/evaluation.html#detectron2.evaluation.DatasetEvaluator)
-interface.
-
-Detectron2 includes a few `DatasetEvaluator` that computes metrics using standard dataset-specific
-APIs (e.g., COCO, LVIS).
-You can also implement your own `DatasetEvaluator` that performs some other jobs
-using the inputs/outputs pairs.
-For example, to count how many instances are detected on the validation set:
-
-```
-class Counter(DatasetEvaluator):
-  def reset(self):
-    self.count = 0
-  def process(self, inputs, outputs):
-    for output in outputs:
-      self.count += len(output["instances"])
-  def evaluate(self):
-    # save self.count somewhere, or print it, or return it.
-    return {"count": self.count}
-```
-
-Once you have some `DatasetEvaluator`, you can run it with
-[inference_on_dataset](../modules/evaluation.html#detectron2.evaluation.inference_on_dataset).
-For example,
-
-```python
-val_results = inference_on_dataset(
-    model,
-    val_data_loader,
-    DatasetEvaluators([COCOEvaluator(...), Counter()]))
-```
-Compared to running the evaluation manually using the model, the benefit of this function is that
-you can merge evaluators together using [DatasetEvaluators](../modules/evaluation.html#detectron2.evaluation.DatasetEvaluators).
-In this way you can run all evaluations without having to go through the dataset multiple times.
-
-The `inference_on_dataset` function also provides accurate speed benchmarks for the
-given model and dataset.

spaces/CVPR/LIVE/thrust/thrust/sequence.h

@@ -1,296 +0,0 @@
-/*
- *  Copyright 2008-2013 NVIDIA Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-
-/*! \file sequence.h
- *  \brief Fills a range with a sequence of numbers
- */
-
-#pragma once
-
-#include <thrust/detail/config.h>
-#include <thrust/detail/execution_policy.h>
-
-namespace thrust
-{
-
-
-/*! \addtogroup transformations
- *  \{
- */
-
-
-/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
- *
- *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
- *  \p sequence performs the assignment <tt>*i =  (i - first)</tt>.
- *
- *  The algorithm's execution is parallelized as determined by \p exec.
- *
- *  \param exec The execution policy to use for parallelization.
- *  \param first The beginning of the sequence.
- *  \param last The end of the sequence.
- *
- *  \tparam DerivedPolicy The name of the derived execution policy.
- *  \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
- *          and \p ForwardIterator is mutable,
- *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
- *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
- *
- *  The following code snippet demonstrates how to use \p sequence to fill a range
- *  with a sequence of numbers using the \p thrust::host execution policy for parallelization:
- *
- *  \code
- *  #include <thrust/sequence.h>
- *  #include <thrust/execution_policy.h>
- *  ...
- *  const int N = 10;
- *  int A[N];
- *  thrust::sequence(thrust::host, A, A + 10);
- *  // A is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
- *  \endcode
- *
- *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
- *        guarantee on order of execution.
- *
- *  \see http://www.sgi.com/tech/stl/iota.html
- */
-template<typename DerivedPolicy, typename ForwardIterator>
-__host__ __device__
-  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
-                ForwardIterator first,
-                ForwardIterator last);
-
-
-/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
- *
- *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
- *  \p sequence performs the assignment <tt>*i =  (i - first)</tt>.
- *
- *  \param first The beginning of the sequence.
- *  \param last The end of the sequence.
- *
- *  \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
- *          and \p ForwardIterator is mutable,
- *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
- *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
- *
- *  The following code snippet demonstrates how to use \p sequence to fill a range
- *  with a sequence of numbers.
- *
- *  \code
- *  #include <thrust/sequence.h>
- *  ...
- *  const int N = 10;
- *  int A[N];
- *  thrust::sequence(A, A + 10);
- *  // A is now {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
- *  \endcode
- *
- *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
- *        guarantee on order of execution.
- *
- *  \see http://www.sgi.com/tech/stl/iota.html
- */
-template<typename ForwardIterator>
-  void sequence(ForwardIterator first,
-                ForwardIterator last);
-
-
-/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
- *
- *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
- *  \p sequence performs the assignment <tt>*i =  init + (i - first)</tt>.
- *
- *  The algorithm's execution is parallelized as determined by \p exec.
- *
- *  \param exec The execution policy to use for parallelization.
- *  \param first The beginning of the sequence.
- *  \param last The end of the sequence.
- *  \param init The first value of the sequence of numbers.
- *
- *  \tparam DerivedPolicy The name of the derived execution policy.
- *  \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
- *          and \p ForwardIterator is mutable,
- *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
- *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
- *  \tparam T is a model of <a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>,
- *          and \p T is convertible to \p ForwardIterator's \c value_type.
- *
- *  The following code snippet demonstrates how to use \p sequence to fill a range
- *  with a sequence of numbers starting from the value 1 using the \p thrust::host execution
- *  policy for parallelization:
- *
- *  \code
- *  #include <thrust/sequence.h>
- *  #include <thrust/execution_policy.h>
- *  ...
- *  const int N = 10;
- *  int A[N];
- *  thrust::sequence(thrust::host, A, A + 10, 1);
- *  // A is now {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
- *  \endcode
- *
- *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
- *        guarantee on order of execution.
- *
- *  \see http://www.sgi.com/tech/stl/iota.html
- */
-template<typename DerivedPolicy, typename ForwardIterator, typename T>
-__host__ __device__
-  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
-                ForwardIterator first,
-                ForwardIterator last,
-                T init);
-
-
-/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
- *
- *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
- *  \p sequence performs the assignment <tt>*i =  init + (i - first)</tt>.
- *
- *  \param first The beginning of the sequence.
- *  \param last The end of the sequence.
- *  \param init The first value of the sequence of numbers.
- *
- *  \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
- *          and \p ForwardIterator is mutable,
- *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
- *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
- *  \tparam T is a model of <a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>,
- *          and \p T is convertible to \p ForwardIterator's \c value_type.
- *
- *  The following code snippet demonstrates how to use \p sequence to fill a range
- *  with a sequence of numbers starting from the value 1.
- *
- *  \code
- *  #include <thrust/sequence.h>
- *  ...
- *  const int N = 10;
- *  int A[N];
- *  thrust::sequence(A, A + 10, 1);
- *  // A is now {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
- *  \endcode
- *
- *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
- *        guarantee on order of execution.
- *
- *  \see http://www.sgi.com/tech/stl/iota.html
- */
-template<typename ForwardIterator, typename T>
-  void sequence(ForwardIterator first,
-                ForwardIterator last,
-                T init);
-
-
-/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
- *
- *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
- *  \p sequence performs the assignment <tt>*i =  init + step * (i - first)</tt>.
- *
- *  The algorithm's execution is parallelized as determined by \p exec.
- *
- *  \param exec The execution policy to use for parallelization.
- *  \param first The beginning of the sequence.
- *  \param last The end of the sequence.
- *  \param init The first value of the sequence of numbers
- *  \param step The difference between consecutive elements.
- *
- *  \tparam DerivedPolicy The name of the derived execution policy.
- *  \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
- *          and \p ForwardIterator is mutable,
- *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
- *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
- *  \tparam T is a model of <a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>,
- *          and \p T is convertible to \p ForwardIterator's \c value_type.
- *
- *  The following code snippet demonstrates how to use \p sequence to fill a range
- *  with a sequence of numbers starting from the value 1 with a step size of 3 using the \p thrust::host
- *  execution policy for parallelization:
- *
- *  \code
- *  #include <thrust/sequence.h>
- *  #include <thrust/execution_policy.h>
- *  ...
- *  const int N = 10;
- *  int A[N];
- *  thrust::sequence(thrust::host, A, A + 10, 1, 3);
- *  // A is now {1, 4, 7, 10, 13, 16, 19, 22, 25, 28}
- *  \endcode
- *
- *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
- *        guarantee on order of execution.
- *
- *  \see http://www.sgi.com/tech/stl/iota.html
- */
-template<typename DerivedPolicy, typename ForwardIterator, typename T>
-__host__ __device__
-  void sequence(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
-                ForwardIterator first,
-                ForwardIterator last,
-                T init,
-                T step);
-
-
-/*! \p sequence fills the range <tt>[first, last)</tt> with a sequence of numbers.
- *
- *  For each iterator \c i in the range <tt>[first, last)</tt>, this version of 
- *  \p sequence performs the assignment <tt>*i =  init + step * (i - first)</tt>.
- *
- *  \param first The beginning of the sequence.
- *  \param last The end of the sequence.
- *  \param init The first value of the sequence of numbers
- *  \param step The difference between consecutive elements.
- *
- *  \tparam ForwardIterator is a model of <a href="http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>,
- *          and \p ForwardIterator is mutable,
- *          and if \c x and \c y are objects of \c ForwardIterator's \c value_type, then <tt>x + y</tt> is defined,
- *          and if \c T is \p ForwardIterator's \c value_type, then <tt>T(0)</tt> is defined.
- *  \tparam T is a model of <a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>,
- *          and \p T is convertible to \p ForwardIterator's \c value_type.
- *
- *  The following code snippet demonstrates how to use \p sequence to fill a range
- *  with a sequence of numbers starting from the value 1 with a step size of 3.
- *
- *  \code
- *  #include <thrust/sequence.h>
- *  ...
- *  const int N = 10;
- *  int A[N];
- *  thrust::sequence(A, A + 10, 1, 3);
- *  // A is now {1, 4, 7, 10, 13, 16, 19, 22, 25, 28}
- *  \endcode
- *
- *  \note Unlike the similar C++ STL function \c std::iota, \p sequence offers no
- *        guarantee on order of execution.
- *
- *  \see http://www.sgi.com/tech/stl/iota.html
- */
-template<typename ForwardIterator, typename T>
-  void sequence(ForwardIterator first,
-                ForwardIterator last,
-                T init,
-                T step);
-
-
-/*! \} // end transformations
- */
-
-
-} // end namespace thrust
-
-#include <thrust/detail/sequence.inl>
-

spaces/CVPR/LIVE/thrust/thrust/system/detail/adl/transform_reduce.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 transform_reduce.h header
-// of the sequential, host, and device systems. It should be #included in any
-// code which uses adl to dispatch transform_reduce
-
-#include <thrust/system/detail/sequential/transform_reduce.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/transform_reduce.h>
-#include <thrust/system/cuda/detail/transform_reduce.h>
-#include <thrust/system/omp/detail/transform_reduce.h>
-#include <thrust/system/tbb/detail/transform_reduce.h>
-#endif
-
-#define __THRUST_HOST_SYSTEM_TRANSFORM_REDUCE_HEADER <__THRUST_HOST_SYSTEM_ROOT/detail/transform_reduce.h>
-#include __THRUST_HOST_SYSTEM_TRANSFORM_REDUCE_HEADER
-#undef __THRUST_HOST_SYSTEM_TRANSFORM_REDUCE_HEADER
-
-#define __THRUST_DEVICE_SYSTEM_TRANSFORM_REDUCE_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/transform_reduce.h>
-#include __THRUST_DEVICE_SYSTEM_TRANSFORM_REDUCE_HEADER
-#undef __THRUST_DEVICE_SYSTEM_TRANSFORM_REDUCE_HEADER
-

spaces/CVPR/WALT/README.md

@@ -1,13 +0,0 @@
----
-title: WALT DEMO
-emoji: ⚡
-colorFrom: indigo
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.0.20
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/CVPR/WALT/mmdet/models/backbones/__init__.py

@@ -1,3 +0,0 @@
-from .swin_transformer import SwinTransformer
-from .resnet import ResNet, ResNetV1d
-__all__ = ['SwinTransformer', 'ResNet', 'ResNetV1d']

spaces/CVPR/WALT/mmdet/models/backbones/swin_transformer.py

@@ -1,630 +0,0 @@
-# --------------------------------------------------------
-# Swin Transformer
-# Copyright (c) 2021 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Ze Liu, Yutong Lin, Yixuan Wei
-# --------------------------------------------------------
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as checkpoint
-import numpy as np
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-
-from mmcv_custom import load_checkpoint
-from mmdet.utils import get_root_logger
-from ..builder import BACKBONES
-
-
-class Mlp(nn.Module):
-    """ Multilayer perceptron."""
-
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Linear(in_features, hidden_features)
-        self.act = act_layer()
-        self.fc2 = nn.Linear(hidden_features, out_features)
-        self.drop = nn.Dropout(drop)
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-
-def window_partition(x, window_size):
-    """
-    Args:
-        x: (B, H, W, C)
-        window_size (int): window size
-
-    Returns:
-        windows: (num_windows*B, window_size, window_size, C)
-    """
-    B, H, W, C = x.shape
-    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
-    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
-    return windows
-
-
-def window_reverse(windows, window_size, H, W):
-    """
-    Args:
-        windows: (num_windows*B, window_size, window_size, C)
-        window_size (int): Window size
-        H (int): Height of image
-        W (int): Width of image
-
-    Returns:
-        x: (B, H, W, C)
-    """
-    B = int(windows.shape[0] / (H * W / window_size / window_size))
-    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
-    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
-    return x
-
-
-class WindowAttention(nn.Module):
-    """ Window based multi-head self attention (W-MSA) module with relative position bias.
-    It supports both of shifted and non-shifted window.
-
-    Args:
-        dim (int): Number of input channels.
-        window_size (tuple[int]): The height and width of the window.
-        num_heads (int): Number of attention heads.
-        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
-        attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
-        proj_drop (float, optional): Dropout ratio of output. Default: 0.0
-    """
-
-    def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
-
-        super().__init__()
-        self.dim = dim
-        self.window_size = window_size  # Wh, Ww
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = qk_scale or head_dim ** -0.5
-
-        # define a parameter table of relative position bias
-        self.relative_position_bias_table = nn.Parameter(
-            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
-
-        # get pair-wise relative position index for each token inside the window
-        coords_h = torch.arange(self.window_size[0])
-        coords_w = torch.arange(self.window_size[1])
-        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
-        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
-        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
-        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
-        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
-        relative_coords[:, :, 1] += self.window_size[1] - 1
-        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
-        relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
-        self.register_buffer("relative_position_index", relative_position_index)
-
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-        trunc_normal_(self.relative_position_bias_table, std=.02)
-        self.softmax = nn.Softmax(dim=-1)
-
-    def forward(self, x, mask=None):
-        """ Forward function.
-
-        Args:
-            x: input features with shape of (num_windows*B, N, C)
-            mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
-        """
-        B_, N, C = x.shape
-        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)
-
-        q = q * self.scale
-        attn = (q @ k.transpose(-2, -1))
-
-        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
-            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
-        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
-        attn = attn + relative_position_bias.unsqueeze(0)
-
-        if mask is not None:
-            nW = mask.shape[0]
-            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
-            attn = attn.view(-1, self.num_heads, N, N)
-            attn = self.softmax(attn)
-        else:
-            attn = self.softmax(attn)
-
-        attn = self.attn_drop(attn)
-
-        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-
-
-class SwinTransformerBlock(nn.Module):
-    """ Swin Transformer Block.
-
-    Args:
-        dim (int): Number of input channels.
-        num_heads (int): Number of attention heads.
-        window_size (int): Window size.
-        shift_size (int): Shift size for SW-MSA.
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
-        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
-        drop (float, optional): Dropout rate. Default: 0.0
-        attn_drop (float, optional): Attention dropout rate. Default: 0.0
-        drop_path (float, optional): Stochastic depth rate. Default: 0.0
-        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
-        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
-    """
-
-    def __init__(self, dim, num_heads, window_size=7, shift_size=0,
-                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
-                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.dim = dim
-        self.num_heads = num_heads
-        self.window_size = window_size
-        self.shift_size = shift_size
-        self.mlp_ratio = mlp_ratio
-        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
-
-        self.norm1 = norm_layer(dim)
-        self.attn = WindowAttention(
-            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
-            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
-
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = norm_layer(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
-        self.H = None
-        self.W = None
-
-    def forward(self, x, mask_matrix):
-        """ Forward function.
-
-        Args:
-            x: Input feature, tensor size (B, H*W, C).
-            H, W: Spatial resolution of the input feature.
-            mask_matrix: Attention mask for cyclic shift.
-        """
-        B, L, C = x.shape
-        H, W = self.H, self.W
-        assert L == H * W, "input feature has wrong size"
-
-        shortcut = x
-        x = self.norm1(x)
-        x = x.view(B, H, W, C)
-
-        # pad feature maps to multiples of window size
-        pad_l = pad_t = 0
-        pad_r = (self.window_size - W % self.window_size) % self.window_size
-        pad_b = (self.window_size - H % self.window_size) % self.window_size
-        x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
-        _, Hp, Wp, _ = x.shape
-
-        # cyclic shift
-        if self.shift_size > 0:
-            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
-            attn_mask = mask_matrix
-        else:
-            shifted_x = x
-            attn_mask = None
-
-        # partition windows
-        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
-        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
-
-        # W-MSA/SW-MSA
-        attn_windows = self.attn(x_windows, mask=attn_mask)  # nW*B, window_size*window_size, C
-
-        # merge windows
-        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
-        shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp)  # B H' W' C
-
-        # reverse cyclic shift
-        if self.shift_size > 0:
-            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
-        else:
-            x = shifted_x
-
-        if pad_r > 0 or pad_b > 0:
-            x = x[:, :H, :W, :].contiguous()
-
-        x = x.view(B, H * W, C)
-
-        # FFN
-        x = shortcut + self.drop_path(x)
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-
-        return x
-
-
-class PatchMerging(nn.Module):
-    """ Patch Merging Layer
-
-    Args:
-        dim (int): Number of input channels.
-        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
-    """
-    def __init__(self, dim, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.dim = dim
-        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
-        self.norm = norm_layer(4 * dim)
-
-    def forward(self, x, H, W):
-        """ Forward function.
-
-        Args:
-            x: Input feature, tensor size (B, H*W, C).
-            H, W: Spatial resolution of the input feature.
-        """
-        B, L, C = x.shape
-        assert L == H * W, "input feature has wrong size"
-
-        x = x.view(B, H, W, C)
-
-        # padding
-        pad_input = (H % 2 == 1) or (W % 2 == 1)
-        if pad_input:
-            x = F.pad(x, (0, 0, 0, W % 2, 0, H % 2))
-
-        x0 = x[:, 0::2, 0::2, :]  # B H/2 W/2 C
-        x1 = x[:, 1::2, 0::2, :]  # B H/2 W/2 C
-        x2 = x[:, 0::2, 1::2, :]  # B H/2 W/2 C
-        x3 = x[:, 1::2, 1::2, :]  # B H/2 W/2 C
-        x = torch.cat([x0, x1, x2, x3], -1)  # B H/2 W/2 4*C
-        x = x.view(B, -1, 4 * C)  # B H/2*W/2 4*C
-
-        x = self.norm(x)
-        x = self.reduction(x)
-
-        return x
-
-
-class BasicLayer(nn.Module):
-    """ A basic Swin Transformer layer for one stage.
-
-    Args:
-        dim (int): Number of feature channels
-        depth (int): Depths of this stage.
-        num_heads (int): Number of attention head.
-        window_size (int): Local window size. Default: 7.
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
-        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
-        drop (float, optional): Dropout rate. Default: 0.0
-        attn_drop (float, optional): Attention dropout rate. Default: 0.0
-        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
-        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
-        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
-        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
-    """
-
-    def __init__(self,
-                 dim,
-                 depth,
-                 num_heads,
-                 window_size=7,
-                 mlp_ratio=4.,
-                 qkv_bias=True,
-                 qk_scale=None,
-                 drop=0.,
-                 attn_drop=0.,
-                 drop_path=0.,
-                 norm_layer=nn.LayerNorm,
-                 downsample=None,
-                 use_checkpoint=False):
-        super().__init__()
-        self.window_size = window_size
-        self.shift_size = window_size // 2
-        self.depth = depth
-        self.use_checkpoint = use_checkpoint
-
-        # build blocks
-        self.blocks = nn.ModuleList([
-            SwinTransformerBlock(
-                dim=dim,
-                num_heads=num_heads,
-                window_size=window_size,
-                shift_size=0 if (i % 2 == 0) else window_size // 2,
-                mlp_ratio=mlp_ratio,
-                qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                drop=drop,
-                attn_drop=attn_drop,
-                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
-                norm_layer=norm_layer)
-            for i in range(depth)])
-
-        # patch merging layer
-        if downsample is not None:
-            self.downsample = downsample(dim=dim, norm_layer=norm_layer)
-        else:
-            self.downsample = None
-
-    def forward(self, x, H, W):
-        """ Forward function.
-
-        Args:
-            x: Input feature, tensor size (B, H*W, C).
-            H, W: Spatial resolution of the input feature.
-        """
-
-        # calculate attention mask for SW-MSA
-        Hp = int(np.ceil(H / self.window_size)) * self.window_size
-        Wp = int(np.ceil(W / self.window_size)) * self.window_size
-        img_mask = torch.zeros((1, Hp, Wp, 1), device=x.device)  # 1 Hp Wp 1
-        h_slices = (slice(0, -self.window_size),
-                    slice(-self.window_size, -self.shift_size),
-                    slice(-self.shift_size, None))
-        w_slices = (slice(0, -self.window_size),
-                    slice(-self.window_size, -self.shift_size),
-                    slice(-self.shift_size, None))
-        cnt = 0
-        for h in h_slices:
-            for w in w_slices:
-                img_mask[:, h, w, :] = cnt
-                cnt += 1
-
-        mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
-        mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
-        attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
-        attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
-
-        for blk in self.blocks:
-            blk.H, blk.W = H, W
-            if self.use_checkpoint:
-                x = checkpoint.checkpoint(blk, x, attn_mask)
-            else:
-                x = blk(x, attn_mask)
-        if self.downsample is not None:
-            x_down = self.downsample(x, H, W)
-            Wh, Ww = (H + 1) // 2, (W + 1) // 2
-            return x, H, W, x_down, Wh, Ww
-        else:
-            return x, H, W, x, H, W
-
-
-class PatchEmbed(nn.Module):
-    """ Image to Patch Embedding
-
-    Args:
-        patch_size (int): Patch token size. Default: 4.
-        in_chans (int): Number of input image channels. Default: 3.
-        embed_dim (int): Number of linear projection output channels. Default: 96.
-        norm_layer (nn.Module, optional): Normalization layer. Default: None
-    """
-
-    def __init__(self, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
-        super().__init__()
-        patch_size = to_2tuple(patch_size)
-        self.patch_size = patch_size
-
-        self.in_chans = in_chans
-        self.embed_dim = embed_dim
-
-        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
-        if norm_layer is not None:
-            self.norm = norm_layer(embed_dim)
-        else:
-            self.norm = None
-
-    def forward(self, x):
-        """Forward function."""
-        # padding
-        _, _, H, W = x.size()
-        if W % self.patch_size[1] != 0:
-            x = F.pad(x, (0, self.patch_size[1] - W % self.patch_size[1]))
-        if H % self.patch_size[0] != 0:
-            x = F.pad(x, (0, 0, 0, self.patch_size[0] - H % self.patch_size[0]))
-
-        x = self.proj(x)  # B C Wh Ww
-        if self.norm is not None:
-            Wh, Ww = x.size(2), x.size(3)
-            x = x.flatten(2).transpose(1, 2)
-            x = self.norm(x)
-            x = x.transpose(1, 2).view(-1, self.embed_dim, Wh, Ww)
-
-        return x
-
-
-@BACKBONES.register_module()
-class SwinTransformer(nn.Module):
-    """ Swin Transformer backbone.
-        A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows`  -
-          https://arxiv.org/pdf/2103.14030
-
-    Args:
-        pretrain_img_size (int): Input image size for training the pretrained model,
-            used in absolute postion embedding. Default 224.
-        patch_size (int | tuple(int)): Patch size. Default: 4.
-        in_chans (int): Number of input image channels. Default: 3.
-        embed_dim (int): Number of linear projection output channels. Default: 96.
-        depths (tuple[int]): Depths of each Swin Transformer stage.
-        num_heads (tuple[int]): Number of attention head of each stage.
-        window_size (int): Window size. Default: 7.
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
-        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set.
-        drop_rate (float): Dropout rate.
-        attn_drop_rate (float): Attention dropout rate. Default: 0.
-        drop_path_rate (float): Stochastic depth rate. Default: 0.2.
-        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
-        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False.
-        patch_norm (bool): If True, add normalization after patch embedding. Default: True.
-        out_indices (Sequence[int]): Output from which stages.
-        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
-            -1 means not freezing any parameters.
-        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
-    """
-
-    def __init__(self,
-                 pretrain_img_size=224,
-                 patch_size=4,
-                 in_chans=3,
-                 embed_dim=96,
-                 depths=[2, 2, 6, 2],
-                 num_heads=[3, 6, 12, 24],
-                 window_size=7,
-                 mlp_ratio=4.,
-                 qkv_bias=True,
-                 qk_scale=None,
-                 drop_rate=0.,
-                 attn_drop_rate=0.,
-                 drop_path_rate=0.2,
-                 norm_layer=nn.LayerNorm,
-                 ape=False,
-                 patch_norm=True,
-                 out_indices=(0, 1, 2, 3),
-                 frozen_stages=-1,
-                 use_checkpoint=False):
-        super().__init__()
-
-        self.pretrain_img_size = pretrain_img_size
-        self.num_layers = len(depths)
-        self.embed_dim = embed_dim
-        self.ape = ape
-        self.patch_norm = patch_norm
-        self.out_indices = out_indices
-        self.frozen_stages = frozen_stages
-
-        # split image into non-overlapping patches
-        self.patch_embed = PatchEmbed(
-            patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,
-            norm_layer=norm_layer if self.patch_norm else None)
-
-        # absolute position embedding
-        if self.ape:
-            pretrain_img_size = to_2tuple(pretrain_img_size)
-            patch_size = to_2tuple(patch_size)
-            patches_resolution = [pretrain_img_size[0] // patch_size[0], pretrain_img_size[1] // patch_size[1]]
-
-            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, embed_dim, patches_resolution[0], patches_resolution[1]))
-            trunc_normal_(self.absolute_pos_embed, std=.02)
-
-        self.pos_drop = nn.Dropout(p=drop_rate)
-
-        # stochastic depth
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
-
-        # build layers
-        self.layers = nn.ModuleList()
-        for i_layer in range(self.num_layers):
-            layer = BasicLayer(
-                dim=int(embed_dim * 2 ** i_layer),
-                depth=depths[i_layer],
-                num_heads=num_heads[i_layer],
-                window_size=window_size,
-                mlp_ratio=mlp_ratio,
-                qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                drop=drop_rate,
-                attn_drop=attn_drop_rate,
-                drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
-                norm_layer=norm_layer,
-                downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
-                use_checkpoint=use_checkpoint)
-            self.layers.append(layer)
-
-        num_features = [int(embed_dim * 2 ** i) for i in range(self.num_layers)]
-        self.num_features = num_features
-
-        # add a norm layer for each output
-        for i_layer in out_indices:
-            layer = norm_layer(num_features[i_layer])
-            layer_name = f'norm{i_layer}'
-            self.add_module(layer_name, layer)
-
-        self._freeze_stages()
-
-    def _freeze_stages(self):
-        if self.frozen_stages >= 0:
-            self.patch_embed.eval()
-            for param in self.patch_embed.parameters():
-                param.requires_grad = False
-
-        if self.frozen_stages >= 1 and self.ape:
-            self.absolute_pos_embed.requires_grad = False
-
-        if self.frozen_stages >= 2:
-            self.pos_drop.eval()
-            for i in range(0, self.frozen_stages - 1):
-                m = self.layers[i]
-                m.eval()
-                for param in m.parameters():
-                    param.requires_grad = False
-
-    def init_weights(self, pretrained=None):
-        """Initialize the weights in backbone.
-
-        Args:
-            pretrained (str, optional): Path to pre-trained weights.
-                Defaults to None.
-        """
-
-        def _init_weights(m):
-            if isinstance(m, nn.Linear):
-                trunc_normal_(m.weight, std=.02)
-                if isinstance(m, nn.Linear) and m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.LayerNorm):
-                nn.init.constant_(m.bias, 0)
-                nn.init.constant_(m.weight, 1.0)
-
-        if isinstance(pretrained, str):
-            self.apply(_init_weights)
-            logger = get_root_logger()
-            load_checkpoint(self, pretrained, strict=False, logger=logger)
-        elif pretrained is None:
-            self.apply(_init_weights)
-        else:
-            raise TypeError('pretrained must be a str or None')
-
-    def forward(self, x):
-        """Forward function."""
-        x = self.patch_embed(x)
-
-        Wh, Ww = x.size(2), x.size(3)
-        if self.ape:
-            # interpolate the position embedding to the corresponding size
-            absolute_pos_embed = F.interpolate(self.absolute_pos_embed, size=(Wh, Ww), mode='bicubic')
-            x = (x + absolute_pos_embed).flatten(2).transpose(1, 2)  # B Wh*Ww C
-        else:
-            x = x.flatten(2).transpose(1, 2)
-        x = self.pos_drop(x)
-
-        outs = []
-        for i in range(self.num_layers):
-            layer = self.layers[i]
-            x_out, H, W, x, Wh, Ww = layer(x, Wh, Ww)
-
-            if i in self.out_indices:
-                norm_layer = getattr(self, f'norm{i}')
-                x_out = norm_layer(x_out)
-
-                out = x_out.view(-1, H, W, self.num_features[i]).permute(0, 3, 1, 2).contiguous()
-                outs.append(out)
-
-        return tuple(outs)
-
-    def train(self, mode=True):
-        """Convert the model into training mode while keep layers freezed."""
-        super(SwinTransformer, self).train(mode)
-        self._freeze_stages()